The Pragmatic Programmer: From Journeyman to Master

Some of the authors' nuggets of pragmatism are concrete, and the path to their implementation is clear. They advise readers to learn one text editor, for example, and use it for everything. They also recommend the use of version-tracking software for even the smallest projects, and promote the merits of learning regular expression syntax and a text-manipulation language. Other (perhaps more valuable) advice is more light-hearted. In the debugging section, it is noted that, "if you see hoof prints think horses, not zebras." That is, suspect everything, but start looking for problems in the most obvious places. There are recommendations for making estimates of time and expense, and for integrating testing into the development process. You'll want a copy of The Pragmatic Programmer for two reasons: it displays your own accumulated wisdom more cleanly than you ever bothered to state it, and it introduces you to methods of work that you may not yet have considered. Working programmers will enjoy this book. --David Wall

Topics covered: A useful approach to software design and construction that allows for efficient, profitable development of high-quality products. Elements of the approach include specification development, customer relations, team management, design practices, development tools, and testing procedures. This approach is presented with the help of anecdotes and technical problems.

Product Description

If I'm putting together a project, it's the authors of this book that I want. . . . And failing that I'd settle for people who've read their book." -- Ward Cunningham

Straight from the programming trenches, The Pragmatic Programmer cuts through the increasing specialization and technicalities of modern software development to examine the core process--taking a requirement and producing working, maintainable code that delights its users. It covers topics ranging from personal responsibility and career development to architectural techniques for keeping your code flexible and easy to adapt and reuse. Read this book, and you'll learn how to

• Fight software rot;
• Avoid the trap of duplicating knowledge;
• Write flexible, dynamic, and adaptable code;
• Avoid programming by coincidence;
• Bullet-proof your code with contracts, assertions, and exceptions;
• Capture real requirements;
• Test ruthlessly and effectively;
• Delight your users;
• Build teams of pragmatic programmers; and
• Make your developments more precise with automation.

Written as a series of self-contained sections and filled with entertaining anecdotes, thoughtful examples, and interesting analogies, The Pragmatic Programmer illustrates the best practices and major pitfalls of many different aspects of software development. Whether you're a new coder, an experienced programmer, or a manager responsible for software projects, use these lessons daily, and you'll quickly see improvements in personal productivity, accuracy, and job satisfaction. You'll learn skills and develop habits and attitudes that form the foundation for long-term success in your career. You'll become a Pragmatic Programmer.

Hunt and Thomas vastly exceeded my expectations. This book is never dry, often humorous, and always educational. They don't always say what you expect them to say (e.g., about commenting code), and I didn't always agree with them, but every sentence is full of thoughtful analysis.

One of the best features is their incredibly practical advice -- while yes, this book does teach philosophy and encourages thought, it also provides many immediately-implementable suggestions.

If you aren't a programmer with 10 years experience, buy it anyway -- it is not just for experienced programmers. While you will absorb less of the book, there is still enough to learn, and it's a great book to keep and re-read.

The book includes a pull-out card of the pithy sayings the authors use to sum up each section. Perhaps my mind just doesn't work the way theirs does, but I didn't find their summations to be helpful all the time -- I found myself frequently having to flip back to the section to remember what a particular phrase meant. But it's still useful.


This book will show you how to save time by spending it   February 10, 2000
Charles Ashbacher (Marion, Iowa United States(cashbacher@yahoo.com))
42 out of 45 found this review helpful

As a programmer, I like to think of myself as pragmatic. Programming is the most precise discipline there is and justifies the cynical joke, "How many character changes does it take to turn `success' into `failure'? Answer: Only one if you are a programmer." However, pragmatic is a very subjective word, so the obvious question that any reader interested in this book would ask is, "So what criteria do the authors use to define a pragmatic programmer?"
In listing the criteria and explaining their reasoning, the authors show their depth of understanding of what is both right and wrong with the current state of the development art. Every keystroke or mouse click that we perform has a consequence, not only today, but in the future. When performing them, we should always be looking ahead to the future, whether that be thinking about how the code will be maintained, how the users will respond to what they find or how your current skill set is expanding or contracting. This eye on the future is the primary theme of the book.
The tips are kept simple, which is effective and is consistent with the secondary theme of the book. Complex systems are what we build, but in totality we cannot comprehend them. Only by breaking a project down into manageable parts can we hope to interact with it in an effective manner. Furthermore, the inertia against changes is much less severe when they are small and simple. Whether it be Ockham's razor, Einstein's statement about the simplicity of theories or simply reciting the KISS (Keep It Simple Stupid) mantra, reducing complexity is effective.
Some very good analogies are used to explain the principles, with my favorite being the broken window tale. The basic story is simple, abandoned buildings or automobiles on the street remain untouched until a window is broken. Left unrepaired, this sends a message that the object is fair game so within a very short time, vandals destroy the rest. The same thing happens in software development. Once a subpar feature is passed as acceptable, the signal to everyone is clear, and the quality of the remaining work suffers.
Granted, most of us in development are severely time challenged and have little to spare to either read or perform code clean ups. However, this is a book where the interest paid over the short and long term will dominate the initial investment. Applying even a few of these principles will help reduce the load in the future as you begin spending less time in all phases of the software cycle. It takes approximately a one percent increase in efficiency to save a half hour a week. This is a book that should be read by all programmers, especially those who wish to control their own destiny.


An enjoyable read--makes you _think_ about how you work   February 1, 2001
M. Murphree (Oak Park, MI USA)
20 out of 21 found this review helpful

When I first came across this book, I'd been a professional programmer for four years. In that time I adopted certain habits, styles of coding, that just seemed to make sense. But this book brought those techniques into sharp, formal relief. It showed me why they were right, and, in some cases, why I hadn't taken them far enough.

After reading this book I understood my craft better. I learned to think not just about the work itself, but the assumptions I had made in diving in to it. I learned to think about and improve my approaches to the work. I was able help the team breath more quality into our software.

It's a year later, and I've purchased a copy of this book for each member in my development team, paid for from our training budget. I was desparate for them to understand the idea of 'writing shy code' (a.k.a. separation of concerns), and of fixing 'broken windows' (don't let defects go! fix them before they accumulate) among other practices of experienced programmers.

This book delivers a powerful dose of common sense for anyone who creates and successfully delivers software for a living. As a bonus, you get a pull-out sheet of the authors' tips and tricks. You won't regret adding this book to your library.


Absolutely life changing.   May 3, 2004
Danilo Gurovich (Northridge, CA United States)
20 out of 23 found this review helpful

For the last year in two different companies I have been evangelizing many of the concepts in "Pragmatic Programmer", but had a hard time validating my thoughts to the more skeptical people in our group.

That's over now. "Pragmatic Programmer" has given me not only the ammunition I need to wage war against some of the more Philistine ideas that I must deal with, it has added to my thoughts and made me a better leader, better communicator and a much, much better developer. Any book that tells you to step away from the keyboard before you begin is good, but this book is a masterpiece because it tells you WHY you should take a step back.

Every chapter is a gem and stands alone, but taken together with the references and extremely well-written explanations, it almosts reads like a novel. I felt guilty putting it down!

If you are serious about software, serious about becoming a real craftsman and a leader in your field, then this book needs to be on your shelf, dog-eared and used.


A modern classic   April 15, 2004
David Astle (GameDev.net)
15 out of 15 found this review helpful

A friend of mine recommended this book to me a year ago and I finally got around to reading it. Not only do I wish I had taken him up on his recommendation immediately, I wish that I had read it years earlier. The book's subtitle "from journeyman to master" really sums it up nicely.

The book contains practical advice from experienced programmers that will help you become a more effective software developer. Unlike many books which dogmatically preach a specific methodology, this book focuses on (not-so-)common sense practices that are simple yet effective, as well as highlighting potential pitfalls to be avoided. Many of them can be applied to your own development process without requiring radical changes, while others will require team- or project-wide changes. Fortunately the nature of the recommended practices is such that you don't have to adopt all of them to be effective. You can pick and choose which ones are most appropriate and gradually incorporate them into your development process.

The range of topics covered is fairly broad, but the important themes are writing easy-to-maintain, reusable code, identifying and adjusting requirements quickly and effectively, managing large projects, and avoiding bad habits and developing good attitudes. Although I don't absolutely agree with everything the authors present, the justification they provide is thought stimulating and will probably change how you do things even if you don't consciously decide to adopt any of their practices.

I found the exercises (and their accompanying solutions) scattered throughout the book to be extremely useful in internalizing the principles being taught, as well as gauging how well I approach problem-solving. I'd highly recommend working through them as you read the book.

Finally, it's worth mentioning how enjoyable this book is to read. The authors' sense of humor and sprinkling of anecdotes make this an easy read without in any way detracting from the content.

If you're a brand new programmer, you probably won't appreciate many of the ideas presented in this book, but come back after you have a year or two of experience. Successful, experienced programmers will find that this book confirms many of the things you're already doing, while providing a lot of useful ideas to become even better. Even if you're not a programmer, but manage or otherwise work with programming teams, you'll find a lot of helpful information here. If there were one book I could require all of my coworkers to read, this would be it.