REVIEW - The Pragmatic Programmer - 20th Anniversary Edition

Title:

The Pragmatic Programmer - 20th Anniversary Edition

Author:

David Thomas, Andrew Hunt

ISBN:

9780135957059

Publisher:

Addison-Wesley Professional (2019)

Pages:

352pp

Reviewer:

Ian Bruntlett

Reviewed:

July 2020

Rating:

★★★★☆

Verdict: A classic.

Physically this is a beautiful book that will endure much use. Split into 9 chapters, 53 topics and 100 tips (with a tear-out tips reference card) it is an impressive piece of work. A short Bibliography is provided. Also, some chapters have exercises and challenges for the reader – with possible answers to the exercises at the back of the book.

According to the Preface, one third of topics in this second edition are new and the majority of the rest have been re-written – either partially or totally. Also, ‘Kaizen’, the Japanese term that captures the concept of continually making many small improvements is introduced.

The ‘Pragmatic Philosophy’ chapter presents the authors philosophy regarding software development – taking responsibility for your career and the consequences of your actions; technical debt; being a catalyst for change; trade-offs in quality; and managing your knowledge portfolio; and finishes off covering different types of communication and, how to do it well.

The ‘Pragmatic Approach’ chapter builds on the previous chapter, but deals with issues involved in coding, backed up with example Ruby code. It boldly proclaims ‘There are certain tips and tricks that apply at all levels of software development, processes that are virtually universal, and ideas that are almost axiomatic’ and that this chapter presents them to you. It covers design principles, strategies for dealing with change, the start of projects, domain languages and estimation.

The ‘Basic Tools’ chapter builds on the programmer-as-artisan metaphor where a maker starts with a basic set of good quality tools. It is heavily biased towards the Unix way of doing things – the importance of plain text, command shells, power editing (text), version control and text manipulation languages. More universal is its recommendation of maintaining Engineering Daybooks. The Unix command line tools have been around for a long time – and, thanks to the FSF, will hopefully will be freely available for a long time.

The ‘Pragmatic Paranoia’ chapter is all about dealing with everyone’s imperfections. The first three topics (Design by Contract, Dead programs tell no lies, assertive programming) all help with the building of correct software. The ‘How to Balance Resources’ topic is all about resource management and how it interacts with scope and exceptions. The final topic ‘Don’t Outrun Your Headlights’ advocates taking small steps – to avoid taking on tasks that are impossible to estimate.

The ‘Bend or Break’ chapter is all about aiming for flexible code and avoiding the creation of fragile code. In particular it discusses decoupling, building upon this book’s Easier to Change principle. It has a tip, Avoid Global Data and I really think that the related principle Parameterise from Above should have been discussed. In the Juggling the Real World topic the ability to be responsive to external change / events covers finite state machines, the Observer pattern, Publish/Subscribe and, Reactive Programming and Streams. So there are plenty of things to learn from this chapter. The Transforming Programming topic raises command-line pipelines and the importance of approaching some problems as a case of taking input data, transforming it, and then outputting it – either at the Unix command-line or in an Elixir program using the |> operator. The Inheritance Tax topic is no fan of inheritance and discusses alternatives. I was surprised that the SOLID acronym wasn’t discussed. Finally, it looks at the role of configuration for flexibility.

The ‘Concurrency’ chapter discusses temporal coupling and the role of time in software architectures – ‘Concurrent and Parallel code used to be exotic. Now it is required’. It discusses Actors and Processes and Blackboards as potential solutions.

The ‘While You Are Coding’ chapter is a selection of 8 topics and 38 tips on coding and is packed full of useful advice. Amongst other things it covers refactoring, testing, and security.

The ‘Before the Project’ chapter discusses requirements and how developers can glean requirements for a project from the users and then build on and refine that information. It also gives advice on how to solve seemingly impossible puzzles. One topic, ‘Working Together’ advocates Pair Programming for the production of higher quality software. The final topic covers the essence of Agile software development.

The final chapter, ‘Pragmatic Projects’, is about the bigger picture and how tips from this book can be applied to a project. In its ‘Pragmatic Starter Kit’ topic it covers three critical things – Version Control, Regression Testing and automation of Building and Testing. The ‘Delight Your Users’ topic reinforces the need for developers to be exposed to many aspects of the customer’s organisation.

The Postface of this book reflects on the responsibility of software developers to have a moral compass and ask “Have I protected the user?” and “Would I use this myself?”. It then concludes with : “It’s Your Life. Share It. Celebrate it. Build it. AND HAVE FUN!”

To conclude, this is an interesting compilation of short essays on Software Development. Well worth reading.


Book cover image courtesy of Open Library.