Kris’ Book Reviews

TomTom ONE XL-S GPS - a detailed review of the bestselling auto navigator

Usually most computer programming related books contain a language course or an API specification/description, sometimes algorithms. As a result computer industry lacks books dealing with software development in general, telling how to “do it” not in a specific language, but in a broader aspect. “The Pragmatic Programmer” is different, gives a more general view on the subject of programming, as such it is much more valuable than any book talking about specifics of a language or operating system internals.

First part of the book presents the main philosophy behind the pragmatic programmer, like taking care of a program, don’t let it deteriorate, being the catalyst of changes, looking at the big picture (not only at the details). More over a pragmatic programmer should communicate with users on their requirements, make quality one of its requirements. There is a very good section about knowledge and how to increase it, by buying diverse books regularly, , reading them with a critical eye, and even where you can learn (e.g. a bus stop, waiting in a queue to the doctor). There is also emphasis on communication, like knowing your listeners, creating appropriate documents, or even how your email should look like.

Following chapter introduces the DRY (Don’t Repeat Yourself) principle, and presents why usually the code looks like copy-pasted, and connected with it orthogonality (keep unrelated objects loose). There is also a very enlightening section about tracer bullets and building prototypes, this way the user can see earlier what is being done, and programmer can see how complicated a certain problem really is. And near the end we have a discussion about domain languages (this was a very entertaining topic for me) and estimations.Third chapter talks about programming tools, here we have a subsection about shells, giving the most out of your editor/IDE, and source code control (believe it or not, there are still workplaces that don’t use any kind of version control). In this chapter we have very helpful paragraph about talking to a duck, when you have an “unsolvable” problem, go and try to tell about it to a bubble duck, or other plastic pet, you will see how everything starts to clear out when you start to verbalize your problem.

Next chapter presents design by contract, and does it in such a good way that I started to learn Eiffel (the original design by contract language). Rest of the chapter deals with various error handling and prevention like sopping the program if it goes wrong, programming using assertions and exceptions, resource allocation balance.

Fifth chapter gives a presentation of elastic programming, how to help your program adapt to new situations. First we have a law of Demeter (keeping the minimal amount of bindings), than there is a section about meta programming, that is making the code highly configurable (e.g. allowing to change the algorithm, by changing a config file entry) keeping the generals in the code and specifics in the meta data. This last section is very interesting and I highly recommend studying it. In the same chapter authors introduce separating logic from the view and introduce Model View Controller pattern. As a last section of this chapter we have a short introduction to shared array systems (like JavaSpaces or T Spaces).

Chapter six starts with a critique of random programming, and how to program more reasonably. Following there is a section about estimation of algorithms, refactoring, unit testing (you might want to check out Test Driven Development book review for an interesting technique based on unit testing).

Next chapter deals with the “things” that you have to do before starting coding, like requirements gathering and how not to fall in the specification trap, at the end, there is a discussion of pitfalls in formal processes and methodologies.

Last chapter takes on the subject of team projects, how to bring together pragmatism and teamwork, very crucial in teams is automatization of repetitive tasks, like installing plugins to IDE or adding a header comment to all source files.

Besides the pure content, book is filled with exercises and homeworks, which increase understanding of the problem in the section, in the appendix there is a list of books and magazines that programmers should look into.

“The Pragmatic Programmer” is one of the two books on the market that take programming from this general perspective, the second one is “Code Complete” (book review), but both books do it in different way. The former gives a small article like sections with a more flexible content (and lesser number of pages), and the latter is more formal (with almost overwhelming 900 big pages). Both take a distinct way and discuss somehow different subjects, and you should read them in any order. I highly recommend “The Pragmatic Programmer” to be on the bookshelf of every programmer.

Rating: 9 out of 10

Buy now The Pragmatic Programmer: From Journeyman to Master

This entry was posted on Thursday, January 18th, 2007 at 9:52 am and is filed under Book Reviews, Programming, Andrew Hunt, David Thomas . You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.