Ask HN: What's an (article|book|vid) that changed the way you view programming?

[daryllxd]

I was wondering, what were really valuable resources for you as a dev, either when you were starting out or when you had a bunch of years of experience. What's some event that changed the way you approached programming?

--- For me it's these:

- Watching DHH/the video that introduced me to Rails. I was a student coding in PHP/CodeIgniter, and it blew my mind re: the speed at which things got done. (Now, not so much, hehe.) - Watching [Destroy All Software](https://www.destroyallsoftware.com/), I think that was the first time I saw someone with a high mastery of the Vim editor, and the first time I saw someone write tests/talk about app/class design. The next week, I was pulling my hair out trying to learn Vim. - Non-programming: [Cracked article on harsh truths.](cracked.com/blog/6-harsh-truths-that-will-make-you-better-person/) I read that several years ago, and every year I try to add a new skill to learn. It's still my auto-complete when I type in "cr" on my browser.

[stuxnet79]

First 10 mins of the first Structure and Interpretation lecture (by Harold Abelson) [1]

Famous first words ...

"I'd like to welcome you to this course on computer science. Actually, that's a terrible way to start. Computer science is a terrible name for this business."

... and this is where it all clicked to me ....

"Well, similarly, I think in the future people will look back and say, yes, those primitives in the 20th century were fiddling around with these gadgets called computers, but really what they were doing is starting to learn how to formalize intuitions about process"

[1] https://www.youtube.com/watch?v=2Op3QLzMgSY

[catpolice]

Rick Hickey's Simple Made Easy permanently made me a better programmer: https://www.infoq.com/presentations/Simple-Made-Easy

Also his talks on transducers in clojure changed the way I think about functional programming

[daryllxd]

Oh I forgot about that! I actually have some notes: https://github.com/daryllxd/lifelong-learning/blob/master/pr...

[dpeck]

Joe Armstrong, one of the creators of Erlang, thesis http://erlang.org/download/armstrong_thesis_2003.pdf

It’s very readable.

[eddd]

It is a good read, but for someone who already understands problems erlang solves - it is not for beginner.

[dpeck]

definitely, and something well discussed in the erlang community over the years. The problem it solves aren't ones that most people realize are there until you've built things and encountered them.

[atsaloli]

"Understanding Software" by Max Kanat-Alexander, https://www.amazon.com/Understanding-Software-Kanat-Alexande...

I've started re-factoring code before adding new features, our code base is getting a little better every day (more maintainable) which reversed a trend, it was getting harder to add features, now it is easier; plus when I design now, my designs are cleaner and result in maintainable code.

[whatyoucantsay]

Masters of Doom. It opened my eyes to how high a level at which some can play the game (of software).

[stuxnet79]

I'm having difficulties interpreting this. By high level, you mean game design? I read Masters of Doom too and it was a fantastic read. But for me what I really found interesting was how the "two Johns" were able to leverage their different personalities, skill sets and areas of focus in a way that allowed Id Software to become a world famous studio. Since I'm more of a technical guy, I found the glimpses into the business side of software / game development to be illuminating. In particular, I really got a kick out of learning about the "shareware" model of selling games - it's incredible the sums of money they were able to get just from that alone. Also it was interesting to see how once you've established a reputation for yourself in the industry it's easy to acquire capital for future ventures, even though the fundamentals of these new ventures may not be obvious. Perhaps it had something to do with the climate at the time (dot com mania) but the amount of venture funding John Romero and Tom Hall were able to secure for Ion Storm and how that capital was subsequently (wasted) is utterly mind boggling to me.

If you ask me John Romero made Eidos his b*h, not his fans!

[is_true]

What I got from that book was fuel. It gave me energy, like I read it for 5 minutes and I wanted to work on some side projects.

[Jeff_Brown]

Simon Peyton Jones on lenses: https://www.youtube.com/watch?v=wguYuQwjTtI

[protoplant]

Head First Design Patterns helped me. I'm not saying to go overboard with design patterns. But it helped me understand some ideas about Object Oriented design

[EdwardCoffin]

End-to-end arguments in System Design [1] convinced me that a lot of special case handling I thought was necessary was really optimization and optional.

Though I already understood recursion pretty well when I read this, the explanation Paul Graham gives in section 2.7 of ANSI Common Lisp was pretty useful [2].

[1] http://web.mit.edu/Saltzer/www/publications/endtoend/endtoen...

[2] http://ep.yimg.com/ty/cdn/paulgraham/acl2.txt

[hemantv]

Effective Engineer by Edmound Lau

Game Programming Patterns by Robert Nystrom

Free book is available here http://www.gameprogrammingpatterns.com/

C++ How to Program Dietiel and Dietiel

Algorithms by CLRS

[tomdre]

"The Art of Computer Programming" by D. Knuth taught me the beauty of well designed algorithms. "The Art of Prolog" by E. Shapiro opened my mind to new programming paradigms.

[partisan]

A video of Udi Dahan explaining CQRS. This changed the way I viewed programming in just about every way. There are others such as Greg Young and Rinat Abdullin, but that one video was the first to make it clear there are other ways to approach the business apps I worked on. https://vimeo.com/8944337

[eddd]

https://www.youtube.com/watch?v=f84n5oFoZBc

[catpolice]

I like the 100% Rich Hickey link rate in the comments so far

[hakanderyal]

This discussion on HN: Smaller Code, Better Code - https://news.ycombinator.com/item?id=13565743

Especially this comment chain: https://news.ycombinator.com/item?id=13571159

[andrei_says_]

Sandi Metz’s talks and Practical Object Oriented Design with Ruby book.

Here’s one of the talks, nothing is something : https://youtu.be/29MAL8pJImQ

[daryllxd]

She's one of my favorite speakers! I actually took down notes of 2 of her conference talks. https://github.com/daryllxd/every_ruby_talk_ever/blob/master.... I watched that specific talk before too!

[slipwalker]

Laziness Impatience Hubris http://wiki.c2.com/?LazinessImpatienceHubris

[mr_noda]

Mike Acton cppcon talk on data oriented design https://youtu.be/rX0ItVEVjHc

[jefflombardjr]

Code Complete by Steve McConnell.

[baccredited]

Agree with this. Even just reading the first 50 pages or so will likely make you much better at your job.

[squarefoot]

"Godel, Escher, Bach" by D. R. Hofstadter.

[lgunsch]

Test-Driven Development by Example: by Kent Beck.

also,

Clean Code: by Robert Martin

[swaggyBoatswain]

I went through a lot of MOOCs early on when learning development (still am). Some courses don't really stick that well to me partially because the author gleams over important steps quickly (skips over the core logic / behind the scenes work). Or there's no comments on videos (lynda.com) so sometimes there's some critical information missing that the author didn't forsee. On things like youtube playlists, its sometimes hard to gleam "why" the author is thinking a certain way when making an implementation to an app, or what context they are thinking of when writing their code. Some comp science courses (CS50) are great for learning the core concepts, but it would be nice to have a course to teach you how to "think" like a programmer

The course that really changed my perspective on development in general was this one https://watchandcode.com/. Its a javascript based course that looks at one simple CRUD (todomvc) app in both vanilla js and jquery.

It assumes you know nothing about programming. To give a crash course overview of what the contents look like

First,

- It doesn't waste time making you setup a dev environment

- First step it asks you to do is play with the todomvc app, to get familiar with the end product

Iteratively,

- The author asks you to write the requirements of the next steps, e.g. "It should have a way to a place to store todos"

- Next, the author teaches you just enough things to meet those requirements in the console

- You implement those simple things per your requirements

- Repeat

- Throw in some computer science concepts only when its needed in context of next problem

What sets it apart from other courses is it teaches you how to "think" like a programmer regardless of what programming language you use. I would say its a modern day video implementation of something similar to books like "Clean Code" or "Pragmatic Programmer" where it discusses why things are done in certain order.

At the end of it you have a nice implementation of the todoMVC app in a prototype pattern / MVC format, and you understand why it was written this way. Next video series he goes into how this implementation is different than the jQuery implementation of todoMVC. But first you would have to understand how to read someone elses code, so he covers how to methodically break down a codebase (what to read, what not to read, how to determine starting points to understand what the code is doing).

Then he introduces you the tools to do so (debugger). Then how to write your own native javascript reduce function and break down the MDN docs. Then how to write TDD (test driven development) based on things discussed earlier on the course. What the `this` object is, what `apply` is, what routing and templating are used for, in context to singular project made above

I haven't finished the 2nd series he's made (26% finished), but it goes into much more detail later about regex, clojures, etc. I think by the end of it you can largely ignore what YDKJS has to offer since its all covered in this course, in a slow methodically well planned out manner. To give you a perspective of how long the series is

- Series 1 is short and to the point (4-5 hours)

- Series 2 is ongoing and about 30-40 worth of video content. On one video he talks about writing a native javascript reduce implementation for 2 hours.

Watching this series makes me realize how my lackof knowledge of discrete math / core math / data structures would ideally make a lot of programming concepts much easier

[Adamantcheese]

Basically anything on http://wiki.c2.com/. The antipattern section is a fun read.