Whew! This book took a little while to get through. That was partly because it’s a healthy 862 pages, and partly because I became addicted to StarCraft II halfway through reading it 😉 Nonetheless, it is an awesome book. Five out of five stars. Jeff Atwood classifies this book as “The Joy of Cooking for software developers.” I would have to agree. If there was such a thing as a modern programming Bible, this is it.
This book reads like a how-to for all aspects of software development. It begins with preliminary things like gathering specifications, defining prerequisites, and planning. It moves through very high-level decisions such as choice of language for a project, and how much project infrastructure to use (build tools, version control, automated testing, etc). It covers estimation, and different techniques for planning the development and integration of large projects.
The author then moves through high level decisions within your code. Things like class structure, interfaces, and guidelines for creating routines are covered. He weighs pros and cons of breaking routines into sub-routines, choosing parameters to pass effectively, and vital concepts such as abstraction and encapsulation. There is a very informative chapter on defensive programming that covers topics such as error-handling, assertions, exceptions, and debugging.
The bulk of the book is on the nitty-gritty of writing code. Variables are covered in depth. He thoroughly covers topics such as variable scope, initialization, placement, and persistence. He devotes an entire chapter to variable names. Following variables is an excellent discussion of data types. Moving right along, conditionals, loops, and other control structures are covered in great detail.
Next McConnell takes the reader through various other aspects of programming, including collaboration, testing, debugging, refactoring, and code tuning. Finally, the book addresses topics such as the effect of project size on construction, using programming tools effectively, code documentation, and the considerations of programmer personalities themselves.
What stuck out most to me about this book (and what makes it stand out from the crowd) is the author’s effective merging of both professional experience and academic knowledge. For things like variable names: he won’t just tell you a variable name should be between 7 and 20 letters, he’ll cite a study showing that code using variables of that length were shown to have fewer bugs. The book is filled with pieces of “hard data” that are usually a result of a formal study that confirms what he has learned through experience. McConnell’s bibliography is extensive, and his command of sources is impressive.
Also, what impressed me about this book is how the small topics reinforce larger themes. One of the primary tenets of good software construction (and one that is thoroughly covered here) is managing complexity. Concepts such as good class structure, good routine names, and good commenting are not effective for their own sake. They are effective because they make code less complex and easier to understand. Programs that are broken down into smaller, less complex pieces are programs that are easier to develop, debug, and maintain.
All in all, I would strongly recommend this book to any software developer. Even if you don’t feel like reading through a 2″ thick book with thin pages and no pictures, you can jump to any particular topic of interest and absorb what tidbit you need. The book is also structured well enough to serve as a reference. It will likely serve as such for me until a year or two from now when I plan on re-reading it. It’s that good.
