As an experienced software developer, I was looking for a book that I could recommend to more junior members of my team to help them improve their skills. This book wasn't it. Although this book has a lot of very good advice in it, it's mostly a mile wide and an inch deep. For a junior developer not already familiar with these ideas, there isn't enough meat here for them to gain any real appreciation or understanding of the material.
In contrast, take Code Complete. It's *only* a book about code construction, a small portion of what Pragmatic Programmer tries to cover. And yet, Code Complete weighs in at nearly 900 pages, versus Pragmatic's 300 or so. The difference is detail. Code Complete really digs into each topic, explaining it completely and giving examples. It's a bigger read to be sure, but when you're done, you have truly learned something. When you finish Pragmatic Programmer, you're left wanting another book that actually explains everything you just read.
My 1st pragmatic book
Fantastic book that sets me out reading a series of pragmatic book.
Get this book and be inspired!
One of those books that puts everything together.
As you read through this book you realize that you know most of this stuff in the back of your head, but it gives you focus along with concise rules that allow you to rapidly improve your coding style regardless of what language you choose.
A must-have guide for software development
This is a great book that details good coding practices, techniques, as well as guidance to become the best programmer that you can be. Now following it and putting all that knowledge into practice is another thing--but once you do, you'll be ahead of the game. The book is non-language specific although there's tidbits of code that somehow explains the logic behind some concepts.
The author explains in the beginning that this book doesn't go from chapter to chapter in successive order but you can rather jump around each one. Although this might be true once you finish the book, I still believe that each chapter builds up one after another. Each chapter provides insights and strategies that will solidify your programming structure and mindset. I found new knowledge that I've wished I knew right when I first started programming and techniques that I can apply to how I currently do things.
I believe that beginners and more advanced programmers alike can equally benefit from this book, as well as project managers. The author presents mistakes and programming pitfalls that they've encountered throughout their career--and shows how to tactically avoid them. They also provide solutions to common mistakes as well as tips in order to keep up with new programming trends.
Overall, this is a great refreshing reading as it introduces new and not-so-new concepts that programmers of any level can benefit from. It is also a good book to have in the book shelf in case you need to get a good refresher on the concepts later on. It's one of those books that I'd wish I've read before but at the same time, it's better late than never.
"From Journeyman to Master" fits perfectly
This is a good handbook for programmers who care about their craft. It serves as an good overview of many best-practices. The book provides a strong motivational force to reflect on your own techniques, habits, and mistakes, and to then go forward and improve.
Many of the Tips in the book might seem obvious and well known to an experienced programmer. Indeed the subtitle is "from journeyman to master". We humans seem to learn by repetition, so even if you already understand know every single idea in the book, it's not a bad to review, reconsider, and re-align yourself from time to time.
In general the quality of the tips leads me to make this a 'must-read' recommendation for any programmer aspiring to greatness. The book provides a strong focus on test driven development via several related tips, so it has quite a bit of overlap with many other books on the market, some of which I have reviewed here.
Some of my favorite tips are:
"Don't Live With Broken Windows" -- This one really stuck with me and comes back to mind on a frequent basis. The idea that a little bit of disorder naturally leads to more disorder (entropy) is a strong one. The example given is the well known "broken windows theory" that describes a form of inner city degradation.
"Prototype to Learn" -- this is something that has really become important to me over the last few years. You absolutely must create experiments when solving unknown problems. And once the learning has been accomplished, you must be prepared to throw the code away, but keep the knowledge gained. One of the mistakes junior programmers tend to make is to believe that every line of code is precious and should be preserved.
"Design to Test" -- this is of course some of the TDD overlap I mentioned earlier. However in my experience this side effect of TDD is one of the most powerful aspects of the technique. When you are planning or writing your tests from the very beginning, you are _forced_ to consider how your modules will be properly unit tested. And this consideration _forces_ your modules to be, well, modular. Testable. Cleaner.
