If I had to choose one book, just one book, to elect as the number one must-read to every programmer, I’d choose “The Pragmatic Programmer”. It’s a no-brainer. It’s just that good.
The Pragmatic Programmer: From Journeyman to Master is a book about software engineering by Andrew Hunt and David Thomas, published in October 1999. The book is organized in short, self-contained chapters, that you can read in any order you’d like. Each chapter features tips (there are 70 in total) that offer advice on several subjects, like estimating, testing, debugging, how to prototype, how to communicate effectively, best practices about exception handling, and a whole lot more.
Each chapter also has exercises and/or challenges. What’s the difference? All the exercises have answers, and you can find them in the appendix in the end of the book. The challenges, on the other hand, are not supposed to have clear answers. They are designed to make you think, reflect and (guess what!) challenge yourself and the way you currently do things.
One thing I really like about this book is that it is very practical. Of course theory has its value and its place, and I personally believe that a lot of programmers lack knowledge in the fundamentals of Computer Science and that really hurts our industry. That said, I think it’s awesome that two programmers took the time to translate their years of experience and knowledge into a book that goes straight to the point with very practical advice that you can put in use right away!
Another point I’d like to highlight is how easy and fun it is to read this book. Its chapters and sections are short, providing a very comfortable pace. It also has a great sense of humor. Not the type that makes you laugh hysterically, but the type that makes you feel at ease, as if the book was a conversation. But I think the number one thing I love about “The Pragmatic Programmer” is that it isn’t really focused on code, or tied to a particular technology, or to particular tools. Sure, it has its fair share of code samples (mostly Java and C/C++). Yeah, it mentions some particular tools and applications. But for the most part, this book is about a mindset. A certain way of thinking, a way of approaching problems and challenges. Once this mindset, this “ Pragmatic Philosophy” is really ingrained in your way of thinking, you’ll be able to apply it to a lot of areas in your professional life, not just coding. And I think this is the real strength of this book. Had it been focused on tools or a specific language, I probably wouldn’t be writing about it now, almost 17 year later.
A little bit of cons
Of course, now that I have sang the many praises of this book, let me talk about some bad things in it. And, to be honest, it’s not that easy to find something bad to say about it.But if there’s one thing that I think most readers would agree, is that some parts of it are somewhat outdated.
I mean, come on! It’s been almost two decades! It’s amazing for a software development book to remain influential for this long. Of course at least some parts must be outdated. For example, one of the tips is to always use version control. Nowadays, version control is something that we take for granted, every developer worth his/her salt knows what Github is, so it’s almost funny to read that recommendation. It is like when you watch Steve Jobs giving the first iPhone presentation, and the audience is mesmerized about its capabilities, that are weak by today’s standards, but were amazing for them at the time. (Yeah, I know there are companies out there in which developers don’t even know about version control. My tip is: if you work in a place like this, try to evangelize version control to them. If you succeed, great! If you don’t, get out as soon as possible.)
In another point of the book, they explain a technique called “tracer-bullet development”. The name may be a little strange, but when they start to explain it, you may find that it sounds a lot like the “minimum viable product” concept, that you may be familiar with from the agile methodologies.
Which shouldn’t be a surprise at all, since Andy Thomas and Dave Hunt were among the signatories of the now legendary Manifesto For Agile Software Development.
That’s why is so hard to find anything wrong with this book. You see, it may seem a little outdated today, but that’s just because the authors were way ahead of their time. Some things that are commonplace and obvious today, we’re totally non-obvious and even counter-intuitive almost 20 years ago. It took a lot of vision to write this book, and for this, and all of the above, I think it’s a very worth read.← Value and reference types in C# Unit testing for beginners - Part 1 →