100 books like Head First Design Patterns

In my consulting gigs, I come across plenty of clueless remarks. Here's a classic one: “We're falling behind schedule, so let's hire more coders.” Or a more recent gem: “We'll be ten times more productive if we generate code with AI.”

When I encounter such nonsense, I don't facepalm or cringe. Instead, I put on my poker face and drop a quote from The Mythical Man-Month.

In an industry where last year’s book is already outdated, Fred Brooks' collection of essays has been a guiding light for nearly half a century. His aphorisms have become legendary. “The bearing of a child takes nine months, no matter how many women are assigned.” “Adding manpower to a late software project makes it later.” “There is no silver bullet.” The list goes on and on.

John Carmack, one of the greatest programmers of our times, used to revisit this book every year or… show more.

This book’s title is absolutely perfect! There’s no agenda here other than identifying things that will make you a more effective and productive programmer.

That leads to a book packed with solid advice, whether it’s about how to write code or how to think about your career. The authors are consultants, so there are plenty of clear and interesting examples drawn from many different problem domains. That’s super fun for someone like me who’s hyper-focused on a single kind of programming.

If one author influenced my way of thinking about software, that’s Martin Fowler. From planning to architectures, his insights are embedded in every line of code I write. I was certain that one of his books would make my list.

But which one? Let’s face it–many of Fowler's books feel dated today. Not because his ideas became obsolete, but because they're now taken for granted. Who needs to re-read a book like Refactoring, when we all have a refactoring menu at our fingertips?

So I settled on this book. It’s a catalog of patterns, but one of the best. And don’t be misled by the word “enterprise” in the title: even lightweight patterns such as Active Record were popularized by this book.

Whether or not you work in a large company, this is still an essential collection of knowledge, written in Fowler’s signature clean style.

Few people want to grow up like their parents. In the early 2010s, many programmers scoffed at the design principles of the ‘90s. Why should anyone care about the nuances of object-oriented design? That’s such a Java thing to bother with!

To seasoned developers, this rejection felt like a baby and bathwater situation. Then Sandy Metz came to the rescue. Her book persuaded younger developers (or at least, those in the Ruby community) that those old ideas were still valuable.

Practical Object-Oriented Design in Ruby traced a straight line from the pioneering times of Smalltalk, through the years of the software craftsmanship movement, directly to modern programming.

It’s a timeless book in the best sense of the word: it would have felt relevant back in the 90s, or when it was published, or today. Few people want to grow up like our parents–but as it turns out, we all do.

When trying to become a better Java developer, there is so much to learn.

97 Things covers, well 97, of them in a series of brief essays. What’s cool is that the essays were written by different people so you get lots of points of view on what is important. Topics range from language (comments, fat jars) to the ecosystem (benchmarking, frequent releases) to the language-agnostic (definition of done and breaking down problems.)

Note that two of these are mine. The book is thin at just over 200 pieces. And since each “thing” is short, it’s easy to read on the go.

When learning a new language, you'll want to avoid the mistake of assuming that you can adapt your old way of doing things to your new language (like I first tried many years ago). Even though Java and Ruby are both object-oriented languages, the "right" approach to implementing things is dramatically different between the two. Practical Object-Oriented Design in Ruby makes it easy to learn how to apply object-oriented design and to implement the code properly in Ruby, making your system easier to change as it grows.

This tour of programming is a humorous reminder that we should always question our assumptions.

This book presents example after example of very simple Java programs all of which behave differently than you expect. It's both humbling and so provocative that you have to go into an editor and see if their claims are true.

When seeking a book on how to use a language effectively, getting one written by someone who helped design and implement the language is usually a great idea. With Effective Java, you get a book written by someone who contributed a significant amount to the language: Joshua Bloch had a lot to do with the design of the Java 5.0 features circa 2004, which is where Java moved for me from "inelegant" to "hey I can finally make things look good in this language." Bloch goes into considerable and passionate depth about each of the 90 items in the 2018 edition and will help you ensure you don't make the mistakes that can lead to defective or bad code.

The Clojure ecosystem presents a multifaceted landscape that can pose a significant challenge for novices, thereby rendering the language itself daunting to approach. However, this comprehensive book aims to alleviate these complexities by providing a guided pathway for readers to construct practical web applications using Clojure.

By following the structured framework within these pages, readers will not only gain a deeper understanding of the language's nuances but also acquire essential proficiency in employing it efficiently. Furthermore, this authoritative resource elucidates numerous best practices, empowering readers to cultivate a skillset that maximizes their effectiveness in utilizing Clojure to its fullest potential.

This book is a great choice for Clojure beginners because it takes the reader through pragmatic examples of using the language, and applying its features effective to solve real-world problems.

To be honest, I did not expect to learn something new from this book, given the fact that I have been working on enterprise-level applications since high school, which mostly follow a microservice architecture. 

Still, I have to admit that in Richardson's discussion on decomposition strategies, inter-service communication, and managing distributed data, I still got some valuable insights into dealing with such an architecture. Particularly, the saga pattern for managing transactions was definitely a game-changer for me.