“The Pragmatic Programmer: From Journeyman to Master” by Andy Hunt and Dave Thomas was published in 1999. It retains the status of one of the most well-respected works on the subject of programming craft. Despite numerous recommendations from colleagues and endorsements by the tech celebrities, I’d been procrastinating on this title for many years until finally giving in and reading it this January. While commonly commended for its practical advice, I would be surprised if “The Pragmatic Programmer” could teach anything new to an experienced developer from 2017. Instead, our industry-wide fascination with this book feels largely ideological, which motivated me to explore its context in better detail.
To provide some perspective, the first (and only) edition of “The Pragmatic Programmer” was released when Google was just one year old and Wikipedia didn’t exist. There was no StackOverflow, no GitHub (no SourceForge either). The authors recommend newsgroups for staying in touch with the industry news. Those, I imagine, were sprawling with discussions on Java 1.2, XML and what we now call Web 1.0. Even the big dynamic languages revolution (in large part, led by Hunt and Thomas) was yet to happen. I can go on and on, but the point is, the tech ecosystem was very different.
All things considered, the book didn’t age badly. While the sections on CORBA, CVS, and other hot technology of the late 90’s are obviously outdated (though, archaeologically appealing), most chapters are general enough to hold up even 18 years after. However, there remains a gray area of opinionated advice that now sounds controversial, if not biased.
Among the five listed traits of a Pragmatic Programmer, three (inquisitive, realistic, and a critical thinker) are desirable for any knowledge worker, so the other two immediately stand out: “early adopter/fast adopter” and a “Jack of all trades.” I’d speculate that, in 2017, not too many people would associate pragmatism with either of the two. In the hype-infused post-GitHub tech world, an early adopter is akin to a venture investor, while specialization is typical even within a seemingly narrow domain (e.g., web development).
In a 2010 interview, Hunt defines the opposite of “pragmatic” as “dogmatic.” I find this odd, because, while promoting open-mindedness, the book remains heavily opinionated: “always design for concurrency,” “always use source code control,” “the best format for storing knowledge persistently is plain text,” etc. While some of these are agreeable, they’re tactically sprinkled with more questionable statements on the use of assertions, metaprogramming, and code generation. The now-famous DRY principle is introduced as a postulate and used as a basis for the authors’ strong pro-automation and anti-IDE stance throughout the book. Later, in what now appears as a failed attempt to predict a future trend, the authors dedicate an entire section to the benefits of Design by contract and ways to adopt it while using Java.
I see the true strength of “The Pragmatic Programmer” in the bits of practical advice on writing code and debugging programs. These don’t usually feel imposed and, thanks to the simple language, are easy to grasp. Section 6.1, “Programming by coincidence” is probably my favorite in the entire book. I’ve already quoted it in this blog, but I’d argue that the discussed issue has only gotten more prominent with the proliferation of resources like StackOverflow.
Unlike the 10x Developer — another mythical figure of the industry, the Pragmatic Programmer’s mastery isn’t intrinsic. The title suggests that, by following the authors’ advice, one can cease being “a worker who is reliable but not outstanding” (a journeyman) and become a champion of their craft. A noble dream, yet, the goal remains transcendent, and the steps to be taken are vague and rely on intuition and personal judgment.
I like to think that the book has gained its popularity partly due to the crafting metaphor. “Know your tools and pick the right one for the job,” tells us the cover illustration, and I believe this is how people usually interpret “The Pragmatic Programmer” as a whole. “Care for your craft” is the Hunt’s and Thomas’s consistent leitmotif, and that is something I can support.
One hundred years from now, our engineering may seem as archaic as the techniques used by medieval cathedral builders seem to today’s civil engineers, while our craftsmanship will still be honored.
— Andy Hunt, Dave Thomas, “The Pragmatic Programmer”
P.S. I’m curious why there hasn’t been a second edition of “The Pragmatic Programmer.” In the 2000’s, Hunt and Thomas wrote “Programming Ruby,” co-authored “The Agile Manifesto,” and became known as advocates for high-level dynamically typed languages. I wonder if some of the “pragmatic” ideals became orthogonal to their evolved beliefs. Although I’m afraid, this is left as an exercise for the reader (unless someone dares to ask the authors).