The Pragmatic Programmer: Classic developer handbook is retooled for the 21st century
Twenty years is a long time in the world of software development, as technologies come and go and best practices are usurped.
That unrelenting pace of change makes it difficult for programming books to stay relevant, even when they're as treasured as The Pragmatic Programmer, a seminal book that introduced a generation to software development in the late 1990s.
Now the classic book has been updated for a modern audience, revised to account for the myriad ways programming has changed in the past two decades, while preserving evergreen advice.
Authors Andrew Hunt and David Thomas say that, while in some respects the software development world of the 1990s is completely alien, in others it remains the same.
"First of all, obviously the computing landscape has changed technically, so some of the things we wrote about as examples in the first version are now considered at best quaint and at worst 'What on earth were you thinking?'. So we've had to refresh some of those technologies," says Thomas.
"But it's deeper than that, the role of the developer has changed dramatically. We're now a profession that is changing the world, far more so than it was 20 years ago.
"Things like Twitter and Facebook are helping people rebel against dictatorships but also helping people terrorize other people. There's a big, big range of things that developers have a hand in that they didn't used to.
"One of the things we were keen to put into the book was more about the importance of responsibility and considering the impact of what you're doing."
Other alterations were more an acknowledgement of how processes and approaches to building software have changed.
"When the first edition of The Pragmatic Programmer came out we talked about how you need to have a build machine," says Hunt.
"The vision around 1999 was this was a spare PC sitting in the corner that builds for you.
"The world today is very different, that can typically be done right in the cloud, you just push your source code and it builds off in the cloud. You can very easily and cheaply have continuous integration and continuous deployment running in the cloud somewhere, all driven from your version-control system.
"The parts aren't new but using it in that way really changes things. It's a different approach, it's a way of going about it and it gives you all sorts of interesting abilities that maybe you didn't have in the old days."
Roughly one-third of the topics in the book are brand new, while the majority of the rest of the book has been rewritten. Hunt and Thomas say all the changes were made with a view to making topics clearer and more relevant.
The new topics include advice on handling concurrency on the plethora of parallel computing hardware that exists today, as well as the rise of agile development practices, and increased usage of functional programming idioms.
"Concurrency is a no-brainer," says Thomas.
"My current computer has 12 cores in it and back in 2000 the idea that your computer could do 12 things at the same time was just laughable. Whereas nowadays it's a fact of life, so concurrency clearly is a way it's going to be.
"Functional programming is slightly more subtle and part of it is due to concurrency. If you are using a concurrent system you have a lot of trouble with trying to keep all of your state consistent because if two or more things can be modified in your data at the same time, then they're going to corrupt it.
"There are techniques for doing that but they're really hard and very error-prone. If you switch to functional programming a lot of those problems go away because typically data is immutable and instead of you changing some data somewhere you copy it. That tends to eliminate many of the errors you get with concurrency."
Hunt added that they also focused far more on security in this edition as today it's "something you have to bake in from the beginning".
Another major difference is the book no longer includes the resources section at the rear, as the authors feel readers are better served by the wealth of constantly updated reference information available online.
The approach taken by Hunt and Thomas in the book remains unchanged, however, with a focus on providing clear explanations that cut through buzzwords and clarify technical jargon.
One notable change for the authors was how easy it was to identify which issues were important, something they said was far simpler in the updated book than it was originally due to having 20 years of feedback in-person at conferences and online.
Most of all, Hunt and Thomas want to see programmers taking pride in their work, closing the book by telling readers that as pragmatic programmers we should "do a job we can be proud of".