Holy shit this guy keeps going on and on about japanese culture and the spirituality of galaxies...

Holy shit this guy keeps going on and on about japanese culture and the spirituality of galaxies. Who recommends this crap?

Attached: serveimage(2).jpg (584x832, 42K)

d e p r e c a t e d

Okay what do the cool kids read these days?

they do bootcamps and read huffpost

I would say no book is perfect and you don't need to follow what he says in clean code 100% but reading it helped me understand how I should write code a lot better.

Yeah it's shit, most books in it's line : design patterns, the pragmatic programmer, sicp are all shit if you think about it after reading them yeah you know some stuff but you could also learn it on your own by actually programming that's why when buying a book if it doesn't present you code you can run which does sth useful you can just gtfo bc it' just a waste of time

Just learn perl6. It's a new high level language that actually does what you want and doesn't require meme white space for if statements like Python.

kek

>Indian version

Attached: 1510482812519.webm (1280x720, 416K)

They aren't useless. They aren't super enlightening but they are worth it to read through or at least skim through.

I agree that it's a pretty garbage book, but sometimes the best way to learn a concept is by crossing discipline or exploring something completely different to get a different perspective. I enjoyed "the design of design" for this reason. It's a book about the thoughtful design of everyday objects, and it gave me a better UI design philosophy.

In order to learn good technique from reading code you have to be reading good code. Since that's in such short supply, reading books which show you non-shit methods of going about things will keep you from being gaslighted by deceptive anti-patterns.

The best design pattern is just to use data oriented design EVERYWHERE

Did you even get past the intro you blubbering child?

Yes, all 40 pages of it. This was the author's first book ever, wasn't it?

>instructor recommends it
>>if a function has 3 or more params then it should be made into an object

Was good warning

Robert Martin makes a living out of selling books, not out of programming.
To become a good programmer, YOU SHOULD FIRST DO IT WRONG. This will come naturally either if it is a project of your own that is subject to a lot of change, or if it is a normal everyday project at Mr. Shecklesteinberg's shop.
Then recognize it is increasingly hard to add new features and make modifications over that program.
Then be aware that somebody before you has encountered the very same problems, and finally go read those damn books out of curiosity and conviction, not out of dogmatism.
Don't try to follow them exactly, because in software there is no magical recipe. Uncle Bob and other authors have to pretend to know things better and go into greater detail because nobody would publish a 10 pages book. So just take ideas and general concepts, and forget the filler.

This was on recommend reading lists

Anything to recommend then? I'm all for optimization

It's an amazing book, I literally kissed it halfway through out of joy. I've never kissed a book before, it was the weirdest compulsion ever.

When I started reading it I had spent approx 8 months working on horrible code at my internship, reading that book was a huge blast of fresh air. Especially the chapter on functions, I found that bit to be utterly indispensable.

>I'm all for optimization
Then don't buy any recommended programming book, because profesional programming is all about modifiability.
Optimization is niche.

This is an interesting point. I had not considered from the perspective of a newbie, starting out "doing it right" in a pragmatic sense, would not convey the urgency of doing so. The consequences of fucking it up become an innate part of your decision making process over time. I can totally see the argument that - the more fuck-ups you encounter (even if you cant mitigate them), the more capable you will be in the future at avoiding the same traps. Personally, I find it to be a subconscious thing at this point. I can make a quick 5-10 second call on some architectural decision and then when asked to justify it, it takes me 20-30 minutes to write out an email in order to fully-establish the context in which that decision was made.

This. I was a hotshot who never believed in extensibility until I tried making my own game and died.

Recommend me a book or tutorial for learning perl6. I was thinking of learning Python recently, so maybe I'll try both.

銀河です。
よろしくお願いします。

Attached: 1514325173354.jpg (185x156, 17K)

Read Code Complete instead.

This is required reading. If you don't write clean code, don't interview for a job.

Holy shit this. It's so intuitive now after years of writing solid but I remember spending hours fucking up over and over again when I started. If you asked my why my architecture is structured the way it is now I'd just say it's maintainable. Expanding the true meaning of that word to someone who doesn't know would take days of lecturer.

And that's why there are so many pajeets running around writing garbage. Writing good code is hard.

is there one single book that could teach me how to program in 2018? I think now reading github readmes and finding out somehow which tools to use and how to get working app is more preferable than reading books. But it is pretty difficult to learn that way if you are lazy an clingy from nature

Is there a fucking reason you wrote this ridiculously long sentence without using periods stupid faggot bitch i hope you fucking die tonight

thanks, that was a good warning

>is there one single book that could teach me how to program
no

What's the reason he gives for this, I can't think of any legit ones.

You can read all this shit much better explained on oodesign.com

Yes because this book will teach you anything of value as opposed to sitting the fuck down and writing

Your generalization is very problematic.

Attached: 911.jpg (640x643, 44K)

Ehh, whatever is in this book should just point how to make functions easier to debug/prove at glance. It does not, so it fails. Everyone should at some point have task at work where they spend 1 week debugging some old code. You will learn more this way.

No book will also teach You how to abstract stuff. Design patterns are 'nice', but when You can create Your own patterns to organize code, there is less use of them. Or rather they will come to You naturally.

* too many parameters are confusing (e.g. if 4 ints are required)
* it's hard to give reason for order of params (there should be a reason for the order, if there is not it makes it unintuitive)
* too much shit to remember in signature
* wrapping in object makes it easier to change type/add/remove params later

Personally I do not agree with this rule, but You wanted reasons, so...