The Pragmatic Programmer Review and an Interview With Andy Hunt

Rarely does a book come along that irrevocably reshapes the landscape of software development. Works such as Design Patterns by the Gang of Four or The Mythical Man-Month by Fred Brooks have become staples of the industry and are understood reading requirements for mastery of software development. The Pragmatic Programmer is one of these great books and has grown more applicable since its original release in 1999.

You may also like: Should I Read Books as a Software Developer?

In this review, we will look at both the original The Pragmatic Programmer and the updated 20th Anniversary Edition and delve into why every software developer — regardless of experience level or programming language — should read this book. Also, we will get the opinion of one of the book's authors, Andy Hunt, about the decisions that went into the new edition and where he sees the software industry heading over the next few years.

The Original

While many software books focus on the intricacies of specific languages or idiosyncrasies of specific problems, The Pragmatic Programmer centers on how to effectively use software to solve problems. As the subtitle — From journeyman to master — implies, the book contains information to pragmatically grow as the developer; not just how to be a good programmer, but also how to solve the difficult problems that surround coding, such as:

• Making accurate but flexible estimates.
• Not repeating yourself (the Do not Repeat Yourself, or DRY principle).
• How to institute change when others are hesitant.
• How to combat stagnancy as a developer.

In addition to the wealth of information that Andy Hunt and Dave Thomas provide in their seminal work, The Pragmatic Programmer also contains numerous entertaining and enlightening stories. Although many software books follow a more formal writing style, Andy and Dave forgo this approach and speak to the reader as a fellow developer. Instead of memorizing principles and points, the reader is treated as a colleague — one who has the same problems as the authors and has seen many of the same, repeating problems.

The Pragmatic Programmer: 20th Anniversary Edition

While the original work is still prevalent today, Andy and Dave have revised the original edition and created another masterpiece — The 20th Anniversary Edition.

The term edition is used lightly here, as the new book is not simply a rehash of the original (i.e., some added chapters or updated examples). This 20th Anniversary Edition is a modernization of the original, which includes:

• A hardcover to ensure it lasts (a great improvement, as the reader, will likely take it everywhere he or she writes software and will probably loan it out more than once).
• The same tone as the original — with some of the same, foundational stories — but with the vernacular and context that developers in 2019 are used to hearing every day at work.
• 30 new tips, including those on ethics and how to please users.
• More pronounced themes — such as Easy to Change — that are essential in the fast-moving, ever-evolving software development world we live in.

Verdict

Many books claim to be a must-read or silver bullet for software development woes, but The Pragmatic Programmer: 20th Anniversary Edition is truly a must-read and stands tall with works like Design Patterns and The Mythical Man-Month. Its effectiveness is so pronounced because it does not claim to be a silver bullet. Instead, it is simply a collection of Andy and Dave's experiences that resonate so well with so many developers.

Both and Andy and Dave have created such an effective work because they have been diligent in capturing so many of the problems that we all face as developers — those that are difficult to describe and put a finger on — and have combined decades of expertise to suggest useful solutions to these problems.

While the book has a Manufacturer's Suggested Retail Price (MSRP) of $49.99, it can be found many places for much less, including (all prices current for the time of writing):

• Amazon ($30).
• InformIT ($40—often has sales that may beat the Amazon price).

For the price, the value of this book far outweighs its cost. The interested reader can find free chapters and samples of the book on The Pragmatic Programmer website. Regardless of which format or store, simply read this book from front to back cover. It is far-and-away worth both the time and the money.

Interview With Andy Hunt

I was also given the privilege of connecting with one of The Pragmatic Programmer authors, Andy Hunt, and asked him a few questions about the new edition of the book and software development in general:

The newest edition marks a special milestone: 20 years since the original was published. Why a 20th-anniversary edition, as opposed to a 10th or 25th-anniversary edition? Was there something specific that occurred after 20 years, or was it simply time for an update?

Dave and I had been discussing the possibility of an update for a while, but the timing just wasn't right. We were each busy with other projects and life in general. But as the even number of "20" rolled around, things just sort of worked out. We got a reprint request from Pearson/Addison-Wesley, and started talking about maybe doing more than just a reprint. The rest, as they say, is history...

Easy to Change appears to be an overarching theme in the new edition that was not as prevalent in the first edition. How much was this addition due to changes in the software industry over the last 20 years and how much was due to changes in you as programmers over the same time?

I think the theme was there in the original, just not as pronounced. Certainly, over the last 20 years, the pace of change has escalated dramatically and will continue to do so. Today you are experiencing the the slowest pace of change you'll experience in your life. It seems to be monotonically increasing. I think we've changed as programmers. I am far more concerned with issues of software longevity: cost of maintenance over time, reliance on dependencies, potential vulnerabilities, and striving for the simplest thing. As we say in the book, "rely only on reliable things." I think 20 years have taught us that many things we take for granted aren't nearly as reliable as we might hope. For example, don't import things like the infamous "left pad." Write the damn seven lines of code yourself.

A recurring theme in both the original and new edition is conscientiousness and continuous personal evaluation. This is reminiscent of the story behind Design Patterns, where the Gang of Four were self-aware enough to recognize the patterns they were using and catalog them. What are some things that professional programmers should pay special attention to every day?

You should always be learning. It's a worthwhile exercise to ask yourself what you plan on learning today and recap and evaluate what you learned today. They are often different things. Pay attention to that which you find difficult. As in music or sports, don't just practice what you're good at deliberately work on the difficult parts until they aren't difficult anymore.

The Postface of the new edition is striking because it focuses on ethics—a topic rarely touched on in software books. Was there a particular event that motivated you to add this Postface to the new edition?

Not personally. But any casual follower of the news will find ample cause to become alarmed ;) I think the striking power of a simple, social, phone app got our attention. A moderately simple bit of software can be used to topple governments, influence elections, cause spikes in preventable diseases by spreading misinformation, even change the nature of courtship and relationships. That's pretty powerful stuff when you think about it, which we probably don't by default.

How important is a solid moral foundation for professional programmers?

Because of our influence over every aspect of people's lives, I think it's become critical. And "moral" has become a tricky word, unfortunately. It's not about jamming your own beliefs down someone else's throat, it's about treating everyone else with the same respect, courtesy, professionalism that you expect. If you wouldn't be comfortable using the software you're writing — or having it used on you — then maybe you shouldn't be writing it.

In both editions, you mention the importance of reading — not just technical books, but also non-technical books—to build a knowledge portfolio. What is your favorite non-technical book? What makes that book a personal staple?

I'm going to with a genre, rather than a specific book: science fiction. One of the most important things you need to realize is the importance of context. Novels help take you out of your normal context and see the world through different eyes. For example, imagine explaining violence against immigrants to an extraterrestrial culture: "well these people hate those people because they were born on the wrong side of an imaginary line on the planet." Sounds pretty stupid when you look at that way, doesn't it?

In the new edition, you included snippets using some effective, but not-so-popular languages, like Elixir. What language would you suggest professionals learn for fun?

I would disagree that Elixir is "not popular." I'd characterize it as "not mainstream," perhaps. I think the key is to learn a language that's very different from what you already know and are comfortable with. Get out of your comfort zone!

What new programming language features or paradigms do you think we will see become common over the next decade?

Better handling of compatibility and breaking changes. Rust has a good model in this area. The problem is that we cannot continue to afford to maintain every bit of software constantly—the sheer volume will crush us. I've got (literally) 30-year old shell scripts that still work as expected. In more modern languages, as little as 6-12 months can mean your code no longer works with the latest updates.

Where do you see the software industry headed in the next decade?

My crystal ball is in the shop this week, getting polished. As always, I think a lot of super-hyped technologies will stumble and do a face-plant, and be replaced with something simpler (for example, in the multi-container orchestration space). We might start to see more AI assist, but AI will not be the panacea that SciFi has portrayed. At worst, it could look like "Clippy," the cringe-worthy assistant from Microsoft back in the day. Overall, more features and capabilities will become commodity items, available as a library or a service, and less that has to be crafted by hand. We've come a long way in that regard and I expect the trend to continue.

What skills and knowledge would you suggest programmers learn to be effective when these changes occur?

Learn quickly. More importantly, unlearn quickly. Be willing to let go of "but I've always done it this way," because next week that will change. Let someone/something else do it if it's cheaper, more reliable, or they have more resources to devote it. For instance, in the book, we discuss using a 3rd party authentication service. Authentication is a huge, complex area. Unless it's part of your core product/competency, you are probably better off deferring to some else for whom it is a core business. They will do a better job of it. So, learn to let go.

I am not associated with the Pragmatic Bookshelf or the Pragmatic Programmer in any way and have reviewed the book and interviewed the author without any compensation (financial or otherwise). All views and opinions are mine alone.

Further Reading

5 Spring Framework Books Experienced Java Developers Should Read

List of the Top DevOps Blogs and Books to Read for 2019

Five Must-Read Statistics Books to Become a Successful Data Analyst