David Thomas, Andrew Hunt: The Pragmatic Programmer (20th Anniversary Edition)

David Thomas, Andrew Hunt: The Pragmatic Programmer (20th Anniversary Edition)

David Thomas, Andrew Hunt
Foreword: Saron Yitbarek
The Pragmatic Programmer, 20th Anniversary Edition: Your Journey to Mastery

2nd Edition
2019, xxii 321 pp., Hardcover
Addison-Wesley
ISBN: 978-0-13-595705-9



The Pragmatic Programmer is inasmuch a technical book as it is a philosophical one. The authors, David Thomas and Andrew Hunt, describe a way of being, that of the „Pragmatic Programmer“ which is based on professionalism, pride in one’s own work, self-improvement, intellectual curiosity, critical thinking, common sense and competency. There are very few software engineering books I would recommend without restraints to every software developer – this is one of them.


Structure

The book is structured in nine chapters which in turn are each subdivided into several topics. The 53 topics are short, spanning in their majority on at most a handful pages. At the end of the topics the reader finds cross references to other related topics followed often by so called „challenges“ and/or exercises. A possible solution to the exercises can be found in the second appendix at the end of the book. The topics are independent of one another and can be read more or less in any order. Since some later topics reference ideas from earlier ones this is not always advisable though. The 100 tips which are spread throughout the text and also listed on a detachable leaflet at the end of the book are the distilled essence of The Pragmatic Programmer philosophy.

Content

The book starts by describing the essence of a „Pragmatic Programmer“ (chapter one titled A Pragmatic Philosophy): a pragmatic programmer can but be a responsible one, one for whom quality is of paramount importance and who is aware of both the big picture and of his or her shortcomings. Continuous improvement and incessant learning are also markers of this ideal type.

The second chapter (A Pragmatic Approach) sets the cornerstones of the pragmatic programmer’s approach: avoiding duplication, flexibility, learning through prototyping, iterating over tasks in order to better understand and estimate them. While the first chapter was more about values and principles the second one becomes more technical.

The third one (The Basic Tools) is in a certain sense about the basics of programming: manipulating text, versioning of files, competent usage of the text manipulation tools (i.e. the IDE or editor), debugging and the proficient usage of the shell.

But a pragmatic programmer cannot be too trusting neither in himself nor in others the authors warn the reader (this is dealt with in chapter 4 called Pragmatic Paranoia). Everybody makes mistakes, it pays off to know how and when to check things. Design by Contract and managing of resources are some of the topics covered by this chapter.

Chapter five (Bend, or Break) is about writing flexible code: for example, tight coupling is bad, as is global data and it should be clear that inheritance comes with a price. A relatively large portion of this chapter is dedicated to the idea of code as a series of transformations (topic called Transforming Programming).

Concurrency, dealt with in the sixth chapter (called, well, Concurrency), is described as a tricky thing, sharing state is prone to errors, which is why the authors suggest not to share it (through usage of so called „actors“).

Chapter seven – the longest one of the book – called quite generically While You Are Coding, talks about trusting your instincts, understanding your own code (i.e. not to „program by coincidence“ as the authors call it), testing, refactoring, security, naming conventions and about choosing the proper algorithm for the task at hand.

After having written about the general philosophy and the general approach of a pragmatic programmer and after having discussed tooling, flexibility, concurrency and coding practices, the time is ripe for going one step further: in chapter eight (Before the Project) and chapter nine (Pragmatic Projects) the authors discuss how pragmatic programmers and „pragmatic teams“ can deal with the challenges of team work and complex endeavors. Thomas and Hunt write about requirements elicitation, pair programming, agility, automatization and about the ultimate goal of the project: making the customers happy.

Discussion

David Thomas and Andrew Hunt steer the reader in The Pragmatic Programmer through a plethora of topics relevant for a software developers‘ approach to his daily duties, his professional evolution and also, in some measure, to his approach to life in general. The topics range from such simple things as naming conventions and versioning of files to considerations about concurrency, working in teams and requirements elicitation. One could argue that with so much breadth there cannot be much space left for depth. Such an argument, albeit correct, would miss the point of the book. The authors set out to describe what they call a „Pragmatic Philosophy“ and a „Pragmatic Approach“ which is based on professionalism, pride in one’s own work, self-improvement, intellectual curiosity, critical thinking, common sense and competency. Deepening and broadening one’s own knowledge are accordingly an ongoing task and the book can only act as a guide.

As if to demonstrate the effects of one of their suggestions for becoming better, which is to learn at least a new programming language every year (p. 15), the authors use code snippets in many languages for their examples. Ruby, Clojure, Python, Java are but a few of the ones used. The text proves to be a very enjoyable read and the general layout of the book shows care and consideration for esthetical aspects. The authors managed to create with The Pragmatic Programmer a very good compendium of the topics relevant for software developers nowadays containing very pragmatic advice. There are very few software engineering books I would recommend without restraints to every software developer – this is one of them.


About the Authors

David Thomas (born in 1956) is a software consultant and speaker who lives in the USA. He holds a Bachelor of Science degree from the Imperial College London and has started his career as a consultant in 1976.

Andrew Hunt (born 1964) is besides being a software consultant and speaker also a musician and a novel writer.

Thomas and Hunt are probably most well known for their book The Pragmatic Programmer (first edition in 1999, second one in 2019). In the year 2000 Hunt and Thomas founded the publishing company The Pragmatic Programmers. Thomas, as well as Hunt, are among the seventeen initial signatories of the Manifesto for Agile Software Development. They are both prolific authors having written several books together and various ones individually and/or together with other authors.

Selected Works (written all together by Thomas and Hunt):

  • 1999. The Pragmatic Programmer: From Journeyman to Master. Addison-Wesley.
  • 2001. Programming Ruby: The Pragmatic Programmer’s Guide. Addison-Wesley.
  • 2003. Pragmatic Version Control with CVS. Pragmatic Bookshelf.
  • 2004. Pragmatic Unit Testing: In C# With NUnit. Pragmatic Bookshelf.
  • 2019. The Pragmatic Programmer, 20th Anniversary Edition: Journey to Mastery. Addison-Wesley.

Sources: The information about David Thomas is taken from his LinkedIn-Account. The information about Andrew Hunt is taken from his self-presentation on his personal website. Data about their works as provided by the Library of Congress. Retrieval date: 23.04.2021.


Folgende Rezensionen könnten Sie ebenfalls interessieren:

Petre Sora

Petre Soras Interessen sind vielfältig und befinden sich an der Schnittstelle zwischen Mensch und Informationstechnologie. Als studierter Psychologe und Software Engineer war er sechs Jahre als Java-Entwickler in mehreren Unternehmen tätig. Mit der Gründung der Rezensionsplattform nososo hat er sich entschieden eigene Wege zu gehen.

Schreibe einen Kommentar