Five Programming Books That Changed How I Think
A look beyond the usual top five to discover other books that are profoundly novel. Each book influenced how I think about code.
Since you’re reading this post, I think it’s safe to assume that you — just like me — love top five lists. I click on more lists than I care to remember, but often end up doing just a casual scroll. Most lists tend to rehash the same five classics.
In this article, I’d like to go beyond the usual suspects and highlight books that influenced how I think about code.
This selection is from books written pre-2015. Why stop there? Simply because a decade is the time I need to truly see the impact a specific book had on me.
The litmus test is: did the book a) change my coding style, and b) was it a sustainable change that made a positive difference?
My take on the classics
It wouldn’t be fair to just skim past the common recommendations. So let me fall into my own trap with a brief take on those.
First, Refactoring, Domain-Driven Design, and the Pragmatic Programmer are all classics for a reason. Amazing books, and mandatory reads.
Working Effectively with Legacy Code deserves all its praise, and of course everyone (yes, really) should check out the Mythical Man-Month.
Clean Code is another standard recommendation, but that one wasn't for me. There are useful design principles in there worth studying, but the book as a whole is too narrow and a bit too dogmatic for my taste. Your mileage might vary. I'd point to Modern Software Engineering by David Farley instead. (See — There are exceptions to all rules. Even my "pre-2015" rule.)
With that said, it’s time for my own list. What do we find when we look beyond these classics?
Beyond the usual suspects: Adam’s Top 5 Programming Books
Smalltalk Best Practice Patterns. True, Kent Beck is better known for his later work, which is excellent too. But Smalltalk Best Practice Patterns is particularly strong on coding style. I learned a lot by just reading the code examples. Small tweaks to names and abstractions add up. No one captures that better than Kent.
Structure and Interpretation of Computer Programs (SICP) by Gerald Jay Sussman and Hal Abelson. SICP is my all-time favourite programming book. It’s also where I learned about the power of wishful thinking when coding. SICP uses wishful thinking as a design tool: write code as if the abstraction already existed. Pretend. Then, once the ideal abstraction has taken shape, you go ahead and implement those functions. This meta-level is what made SICP so valuable. Ultimately, it’s a book that teaches how to think about code and problem solving. I’m tempted to even say that SICP is more a work of art than a pure coding book, but I won’t go there. A beautiful book.
Paradigms of Artificial Intelligence by Peter Norvig. Learning the AI described in this book probably won’t land you a job today. But reading the code examples will transform how you think about source code. The book shines when it comes to code comments, a topic that I’ve never seen demonstrated well in other sources. Here we get to see how comments become valuable as a narrative that explains both intent and reasoning. Brilliant, just brilliant.
Facts and Fallacies of Software Engineering by Robert L. Glass. In essence, this is a book about an industry that refuses to learn. That was true 25 years ago when this book was published, and it’s probably twice as true today. (Just think about all the AI adoption metrics being rolled out — back to productivity mistaken for lines of code produced, only more elaborate. And expensive). What I like about this book is that Glass doesn’t present anything new. Quite the opposite, actually. Rather, it’s about research lessons that we all should know, but tend to forget. Ever had to do an estimate, or plan according to a requirements spec? Or maybe you thought that enough eyeballs make all bugs shallow? Then this book is for you. A great work by a fantastic author.
Thinking Forth by Leo Brodie. I used to have this habit where I learned various programming languages. To challenge my perspective, I chose languages from families and paradigms that were fundamentally different from what I already knew. Occasionally, I stumbled upon greatness. Thinking Forth presents programming as a creative process, and it delivers those lessons in an entertaining and pedagogical way. The book is particularly strong on software analysis and design, but it’s the execution and technical writing that brought the book to my top five. This is the book for anyone writing about software — Leo’s way is the way to do it.
Since the ranking is zero-indexed, there’s one more book in the top 5:
The Nature of Code: Simulating Natural Systems with Processing by Daniel Shiffman. This book is a beautiful introduction to simulations of natural systems. We get concise prose, clear illustrations, and carefully chosen systems with a guided tour through the math. All done in the Processing language, which is fun and easy to pick up. The reason I like this book so much is probably due to timing. In 2013, I was on the verge of abandoning software development. I was fed up. (That’s a story for another time.) Instead, I planned to go into cognitive psychology full-time as a researcher. This book brought back the joy in programming for me. Sometimes, a good book is the book that motivated you.
Honorable mentions
Picking a top five was hard. There are so many other enjoyable books, and on a different day, the list above might have included any of the ones below:
The Art of the Metaobject Protocol by Kiczales, Rivieres and Bobrow. This one is for those times when you need to bend your mind in interesting ways...
...and Let Over Lambda by Doug Hoyte is perfect for those three people in the world who find The Art of the Metaobject Protocol underwhelming. One of the most impressive books I’ve read.
The Design of Design by Frederick P. Brooks. It never received the attention that The Mythical Man-Month got, yet The Design of Design shares many of its qualities. It’s a book that grows, and there’s a wealth of insights on offer.
The Little Schemer by Friedman and Felleisen. This book won’t teach you Scheme. Rather, it teaches something more valuable: it teaches how to think recursively. Working through the book even made me comfortable with the Y-combinator in lambda calculus. (At least for some time).
Multi-Paradigm Design for C++ by James O. Coplien. Twenty years after reading this, the core techniques are still with me. These are commonality analysis, where the purpose is to identify families of systems, and variability analysis, which focuses on capturing the domain parameters that vary. In essence: the foundation of great software design.
Alright, I’ll try to stop here. Otherwise I get tempted to also throw in The Timeless Way of Building, Programming Erlang, The Art of UNIX Programming, and, and, and... No — promise: I stop right here. Let me just offer some parting words.
The books in this post might use a specific programming language. But it would be a mistake to think that they are about that language. Their lessons are wider, much wider. They demonstrate better ways to think about software.
So when reading these books, we shouldn’t focus on the specifics. It’s all about the general lessons. And those transcend the Lisp, C++, Smalltalk, or Forth used in coding examples. To me, that’s the hallmark of truly great books.