92 Books Like The Pragmatic Programmer

I’ve found in this book many useful topics about low-level design which connected with my first recommendation (Code Complete). For instance, about creating functions not only as a tactic for reusing code, but more as a way to give clear meaning to parts of the code, and make it more readable. I was happy to find in these authors ideas I have been agreeing with for a long time.

Then there’s also the fact that this book provides several examples with code on how to make the design simpler to maintain, and clearly illustrates the S.O.L.I.D. principles.

I've found this book enlightening in many key areas of software development, and as I was reading it, I felt connected with the author (even though I've never met him, I could imagine us having a conversation about software engineering, and agreeing on pretty much everything).

It was a revealing book for me, in the sense that it gave a formal framework to several ideas I've noticed as a practitioner over the years. In that regard, I wish I'd come across this work way earlier in my career.

I have to be honest here: when I was reading this book on a trip to New York, I found myself quite surprised because I had seen so many praises for this book, yet I did not particularly agree with most of the topics I was reading about. In particular, I found several points that contradicted those in Clean Code and Code Complete.

I know there’s a debate going on between the authors on a distribution list, but besides some of these points on which I respectfully disagree with the author, I can see is a book of immense value, and there are tons of other great points made about great software design (for example, ”modules should be deep”). And the explanations are crystal clear.

A final reason for recommending this book is that it’s always enriching to expose oneself to a different viewpoint.

The marvel of this book is that it's a rare one: most of the books focus on the construction part of software, all the design and preparation. But what happens once the system is out there, launched? Release It! focuses on the software architecture aspects that entail designing a platform to make it reliable once it’s been released.

It touches on concepts like logging, locking, circuit breakers, and it’s written from the author’s experience with real-life examples (and even code snippets). As someone who has worked on several different types of software products (and been on-call), I’ve enjoyed reading the author tell us about things that went wrong in the past, and what lessons were learnt from them.

This book helped me set my initial approach to software development and I still periodically return to it for grounding.

An MIT project theorized that new-fangled PC software developers knew something mainframe and mini-computer makers didn’t. MIT’s research revealed something else entirely: Microsoft had uniquely effective ideas on how to build complex products in rapidly evolving competitive markets. Here is “agile” before it was put into the Manifesto in 2001, in a more complete form. Ever wonder where the idea of a team comprising functional specialists with overlapping roles, united by a common goal, came from? Or incremental feature evolution with periodic synchronization and constant testing? Early brilliance still of foundational relevance, in a coherent and engaging form.

During the early years of my career as a software developer, I regularly developed very small programs that would exercise parts of the system that I was working on back then. I realized very quickly that those small programs would save me a lot of time figuring out whether the changes that I made would actually work or not. Until at some point a colleague mentioned the concept of Test-Driven Development. I first did some experimentation, dipping a toe into the water to feel the temperature. It wasn’t until the first time I picked up this book that I jumped right in. From then moment on, it all made sense. Although this book was published back in 2002, for me it still is the book when it comes to the subject of Test-Driven Development.      

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.

Many of the most significant principles of effective software development are timeless. They’re independent of the development life cycle or model, programming language, application type, and so forth. Although this book is quite a few years old now, nearly all of its contents are still valid. The 201 principles cover the full spectrum of software engineering: general principles, requirements engineering, design, coding, testing, management, product assurance, and evolution. The descriptions of each principle are concise, whereas my 60 lessons in Software Development Pearls go into a great deal more detail and offer many practical techniques.

There’s an unfortunate tendency among young software people to disregard knowledge from the past as irrelevant to them. That’s not correct. This book can help close significant gaps in any practicing software developer’s knowledge.

This book changed my entire perspective on writing the UI and UX of great software. Even the revised edition is a bit old but still has many valuable lessons to teach. Platt established many of the fundamental principles of writing usable and transparent software, and his book should be read not only by designers, but perhaps especially by programmers.

Wow! This book is exactly what every programmer has always wanted to know or even felt guilty about not knowing and it’s all presented in an extremely simplified and fun way. 

This is one of those books where you get excited in the morning when you wake up because you know you are going to be able to read more in the book and you are hoping the book will never end.

It’s rare to find a big book that I enjoyed reading so much and felt so short. This book covers almost everything you ever wondered about computer science. After reading this book, I felt like I finally understood everything a programmer was supposed to know and I no longer felt that nagging feeling of being an imposter.