
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required. Learn more
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.

Follow the Authors
OK
The Pragmatic Programmer: From Journeyman to Master 1st Edition
There is a newer edition of this item:
- ISBN-109780201616224
- ISBN-13978-0201616224
- Edition1st
- PublisherAddison-Wesley Professional
- Publication dateOctober 30, 1999
- LanguageEnglish
- Dimensions9.2 x 7.4 x 0.9 inches
- Print length352 pages
Customers who viewed this item also viewed
From the Publisher
Editorial Reviews
Amazon.com Review
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.
From the Publisher
Simply put, this book tells you how to program in a way that you can follow. You wouldn't think that that would be a hard thing to do, but it is. Why? For one thing, not all programming books are written by programmers. Many are compiled by language designers, or the journalists who work with them to promote their creations. Those books tell you how to talk in a programming language---which is certainly important, but that is only a small part of what a programmer does.
What does a programmer do besides talk in programming language? Well, that is a deeper issue. Most programmers would have trouble explaining what they do. Programming is a job filled with details, and keeping track of those details requires focus. Hours drift by and the code appears. You look up and there are all of those statements. If you don't think carefully, you might think that programming is just typing statements in a programming language. You would be wrong, of course, but you wouldn't be able to tell by looking around the programming section of the bookstore.
In The Pragmatic Programmer Dave and Andy tell us how to program in a way that we can follow. How did they get so smart? Aren't they just as focused on details as other programmers? The answer is that they paid attention to what they were doing while they were doing it---and then they tried to do it better.
Imagine that you are sitting in a meeting. Maybe you are thinking that the meeting could go on forever and that you would rather be programming. Dave and Andy would be thinking about why they were having the meeting, and wondering if there is something else they could do that would take the place of the meeting, and deciding if that something could be automated so that the work of the meeting just happens in the future. Then they would do it.
That is just the way Dave and Andy think. That meeting wasn't something keeping them from programming. It was programming. And it was programming that could be improved. I know they think this way because it is tip number two: Think About Your Work.
So imagine that these guys are thinking this way for a few years. Pretty soon they would have a collection of solutions. Now imagine them using their solutions in their work for a few more years, and discarding the ones that are too hard or don't always produce results. Well, that approach just about defines pragmatic. Now imagine them taking a year or two more to write their solutions down. You might think, That information would be a gold mine. And you would be right.
The authors tell us how they program. And they tell us in a way that we can follow. But there is more to this second statement than you might think. Let me explain.
The authors have been careful to avoid proposing a theory of software development. This is fortunate, because if they had they would be obliged to warp each chapter to defend their theory. Such warping is the tradition in, say, the physical sciences, where theories eventually become laws or are quietly discarded. Programming on the other hand has few (if any) laws. So programming advice shaped around wanna-be laws may sound good in writing, but it fails to satisfy in practice. This is what goes wrong with so many methodology books.
I've studied this problem for a dozen years and found the most promise in a device called a pattern language. In short, a pattern is a solution, and a pattern language is a system of solutions that reinforce each other. A whole community has formed around the search for these systems.
This book is more than a collection of tips. It is a pattern language in sheep's clothing. I say that because each tip is drawn from experience, told as concrete advice, and related to others to form a system. These are the characteristics that allow us to learn and follow a pattern language. They work the same way here.
You can follow the advice in this book because it is concrete. You won't find vague abstractions. Dave and Andy write directly for you, as if each tip was a vital strategy for energizing your programming career. They make it simple, they tell a story, they use a light touch, and then they follow that up with answers to questions that will come up when you try.
And there is more. After you read ten or fifteen tips you will begin to see an extra dimension to the work. We sometimes call it QWAN, short for the quality without a name. The book has a philosophy that will ooze into your consciousness and mix with your own. It doesn't preach. It just tells what works. But in the telling more comes through. That's the beauty of the book: It embodies its philosophy, and it does so unpretentiously.
So here it is: an easy to read---and use---book about the whole practice of programming. I've gone on and on about why it works. You probably only care that it does work. It does. You will see. --Ward Cunningham
From the Author
* Pragmatic Project Automation (0974514039)
* Pragmatic Unit Testing in C# with Nunit (0974514020)
* Pragmatic Unit testing in Java with Junit (0974514012)
* Pragmatic Version Control Using CVS (0974514004)
* Programming Ruby 2nd Edition (0974514055)
From the Inside Flap
This book will help you become a better programmer.
It doesn't matter whether you are a lone developer, a member of a large project team, or a consultant working with many clients at once. This book will help you, as an individual, to do better work. This book isn't theoretical---we concentrate on practical topics, on using your experience to make more informed decisions. The word pragmatic comes from the Latin pragmaticus--"skilled in business"--which itself is derived from a Greek word meaning "to do." This is a book about doing.
Programming is a craft. At its simplest, it comes down to getting a computer to do what you want it to do (or what your user wants it to do). As a programmer, you are part listener, part advisor, part interpreter, and part dictator. You try to capture elusive requirements and find a way of expressing them so that a mere machine can do them justice. You try to document your work so that others can understand it, and you try to engineer your work so that others can build on it. What's more, you try to do all this against the relentless ticking of the project clock. You work small miracles every day.
It's a difficult job.
There are many people offering you help. Tool vendors tout the miracles their products perform. Methodology gurus promise that their techniques guarantee results. Everyone claims that their programming language is the best, and every operating system is the answer to all conceivable ills.
Of course, none of this is true. There are no easy answers. There is no such thing as a best solution, be it a tool, a language, or an operating system. There can only be systems that are more appropriate in a particular set of circumstances.
This is where pragmatism comes in. You shouldn't be wedded to any particular technology, but have a broad enough background and experience base to allow you to choose good solutions in particular situations. Your background stems from an understanding of the basic principles of computer science, and your experience comes from a wide range of practical projects. Theory and practice combine to make you strong.
You adjust your approach to suit the current circumstances and environment. You judge the relative importance of all the factors affecting a project and use your experience to produce appropriate solutions. And you do this continuously as the work progresses. Pragmatic Programmers get the job done, and do it well.
Who Should Read This Book?
This book is aimed at people who want to become more effective and more productive programmers. Perhaps you feel frustrated that you don't seem to be achieving your potential. Perhaps you look at colleagues who seem to be using tools to make themselves more productive than you. Maybe your current job uses older technologies, and you want to know how newer ideas can be applied to what you do.
We don't pretend to have all (or even most) of the answers, nor are all of our ideas applicable in all situations. All we can say is that if you follow our approach, you'll gain experience rapidly, your productivity will increase, and you'll have a better understanding of the entire development process. And you'll write better software.
What Makes a Pragmatic Programmer?
Each developer is unique, with individual strengths and weaknesses, preferences and dislikes. Over time, each will craft his or her own personal environment. That environment will reflect the programmer's individuality just as forcefully as his or her hobbies, clothing, or haircut. However, if you're a Pragmatic Programmer, you'll share many of the following characteristics:
Early adopter/fast adapter. You have an instinct for technologies and techniques, and you love trying things out. When given something new, you can grasp it quickly and integrate it with the rest of your knowledge. Your confidence is born of experience. Inquisitive. You tend to ask questions. That's neat---how did you do that? Did you have problems with that library? What's this BeOS I've heard about? How are symbolic links implemented? You are a pack rat for little facts, each of which may affect some decision years from now. Critical thinker. You rarely take things as given without first getting the facts. When colleagues say "because that's the way it's done," or a vendor promises the solution to all your problems, you smell a challenge. Realistic. You try to understand the underlying nature of each problem you face. This realism gives you a good feel for how difficult things are, and how long things will take. Understanding for yourself that a process should be difficult or will take a while to complete gives you the stamina to keep at it. Jack of all trades. You try hard to be familiar with a broad range of technologies and environments, and you work to keep abreast of new developments. Although your current job may require you to be a specialist, you will always be able to move on to new areas and new challenges.
We've left the most basic characteristics until last. All Pragmatic Programmers share them. They're basic enough to state as tips:
Care About Your Craft
We feel that there is no point in developing software unless you care about doing it well.
Think! About Your Work
In order to be a Pragmatic Programmer, we're challenging you to think about what you're doing while you're doing it. This isn't a one-time audit of current practices---it's an ongoing critical appraisal of every decision you make, every day, and on every development. Never run on auto-pilot. Constantly be thinking, critiquing your work in real time. The old IBM corporate motto, THINK!, is the Pragmatic Programmer's mantra.
If this sounds like hard work to you, then you're exhibiting the realistic characteristic. This is going to take up some of your valuable time---time that is probably already under tremendous pressure. The reward is a more active involvement with a job you love, a feeling of mastery over an increasing range of subjects, and pleasure in a feeling of continuous improvement. Over the long term, your time investment will be repaid as you and your team become more efficient, write code that's easier to maintain, and spend less time in meetings. Individual Pragmatists, Large Teams
Some people feel that there is no room for individuality on large teams or complex projects. "Software construction is an engineering discipline," they say, "that breaks down if individual team members make decisions for themselves."
We disagree.
The construction of software should be an engineering discipline. However, this doesn't preclude individual craftsmanship. Think about the large cathedrals built in Europe during the Middle Ages. Each took thousands of person-years of effort, spread over many decades. Lessons learned were passed down to the next set of builders, who advanced the state of structural engineering with their accomplishments. But the carpenters, stonecutters, carvers, and glass workers were all craftspeople, interpreting the engineering requirements to produce a whole that transcended the purely mechanical side of the construction. It was their belief in their individual contributions that sustained the projects: We who cut mere stones must always be envisioning cathedrals.
--- Quarry worker's creed
Within the overall structure of a project there is always room for individuality and craftsmanship. This is particularly true given the current state of software engineering. One hundred years from now, our engineering may seem as archaic as the techniques used by medieval cathedral builders seem to today's civil engineers, while our craftsmanship will still be honored. It's a Continuous Process
A tourist visiting England's Eton College asked the gardener how he got the lawns so perfect. "That's easy," he replied, "You just brush off the dew every morning, mow them every other day, and roll them once a week."
"Is that all?" asked the tourist.
"Absolutely," replied the gardener. "Do that for 500 years and you'll have a nice lawn, too."
Great lawns need small amounts of daily care, and so do great programmers. Management consultants like to drop the word kaizen in conversations. "Kaizen" is a Japanese term that captures the concept of continuously making many small improvements. It was considered to be one of the main reasons for the dramatic gains in productivity and quality in Japanese manufacturing and was widely copied throughout the world. Kaizen applies to individuals, too. Every day, work to refine the skills you have and to add new tools to your repertoire. Unlike the Eton lawns, you'll start seeing results in a matter of days. Over the years, you'll be amazed at how your experience has blossomed and your skills have grown. How the Book Is Organized
This book is written as a collection of short sections. Each section is self-contained, and addresses a particular topic. You'll find numerous cross references, which help put each topic in context. Feel free to read the sections in any order---this isn't a book you need to read front-to-back.
Occasionally you'll come across a box labeled Tip nn (such as Tip 1, "Care About Your Craft" on xix). As well as emphasizing points in the text, we feel the tips have a life of their own---we live by them daily. You'll find a summary of all the tips on a pull-out card inside the back cover.
Appendix A contains a set of resources: the book's bibliography, a list of URLs to Web resources, and a list of recommended periodicals, books, and professional organizations. Throughout the book you'll find references to the bibliography and to the list of URLs.
We've included exercises and challenges where appropriate. Exercises normally have relatively straightforward answers, while the challenges are more open-ended. To give you an idea of our thinking, we've included our answers to the exercises in Appendix B, but very few have a single correct solution. The challenges might form the basis of group discussions or essay work in advanced programming courses.
020161622XP04062001
From the Back Cover
What others in the trenches say about The Pragmatic Programmer...
&;The cool thing about this book is that it&;s great for keeping the programming process fresh. The book helps you to continue to grow and clearly comes from people who have been there.&;
         &;Kent Beck, author of Extreme Programming Explained: Embrace Change&;I found this book to be a great mix of solid advice and wonderful analogies!&;
         &;Martin Fowler, author of Refactoring and UML Distilled&;I would buy a copy, read it twice, then tell all my colleagues to run out and grab a copy. This is a book I would never loan because I would worry about it being lost.&;
         &;Kevin Ruland, Management Science, MSG-Logistics&;The wisdom and practical experience of the authors is obvious. The topics presented are relevant and useful.... By far its greatest strength for me has been the outstanding analogies&;tracer bullets, broken windows, and the fabulous helicopter-based explanation of the need for orthogonality, especially in a crisis situation. I have little doubt that this book will eventually become an excellent source of useful information for journeymen programmers and expert mentors alike.&;
         &;John Lakos, author of Large-Scale C++ Software Design&;This is the sort of book I will buy a dozen copies of when it comes out so I can give it to my clients.&;
         &;Eric Vought, Software Engineer&;Most modern books on software development fail to cover the basics of what makes a great software developer, instead spending their time on syntax or technology where in reality the greatest leverage possible for any software team is in having talented developers who really know their craft well. An excellent book.&;
         &;Pete McBreen, Independent Consultant&;Since reading this book, I have implemented many of the practical suggestions and tips it contains. Across the board, they have saved my company time and money while helping me get my job done quicker! This should be a desktop reference for everyone who works with code for a living.&;
         &;Jared Richardson, Senior Software Developer, iRenaissance, Inc.&;I would like to see this issued to every new employee at my company....&;
         &;Chris Cleeland, Senior Software Engineer, Object Computing, Inc.&;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 CunninghamStraight 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.
About the Author
Andy Hunt is an avid woodworker and musician, but, curiously, he is more in demand as a consultant. He has worked in telecommunications, banking, financial services, and utilities, as well as in more exotic fields, such as medical imaging, graphic arts, and Internet services. Andy specializes in blending tried-and-true techniques with leading-edge technologies, creating novel--but practical--solutions. Andy owns his own consulting business in Raleigh, North Carolina.
Dave Thomas likes to fly single-engine airplanes and pays for his habit by finding elegant solutions to difficult problems, consulting in areas as diverse as aerospace, banking, financial services, telecommunications, travel and transport, and the Internet. Before moving to the United States in 1994, Dave founded an ISO9001-certified English software company that delivered sophisticated, custom software projects throughout the world. Dave is now an independent consultant based in Dallas, Texas.
020161622XAB04062001
Excerpt. © Reprinted by permission. All rights reserved.
This book will help you become a better programmer.
It doesn't matter whether you are a lone developer, a member of a large project team, or a consultant working with many clients at once. This book will help you, as an individual, to do better work. This book isn't theoretical---we concentrate on practical topics, on using your experience to make more informed decisions. The word pragmatic comes from the Latin pragmaticus--"skilled in business"--which itself is derived from a Greek word meaning "to do." This is a book about doing.
Programming is a craft. At its simplest, it comes down to getting a computer to do what you want it to do (or what your user wants it to do). As a programmer, you are part listener, part advisor, part interpreter, and part dictator. You try to capture elusive requirements and find a way of expressing them so that a mere machine can do them justice. You try to document your work so that others can understand it, and you try to engineer your work so that others can build on it. What's more, you try to do all this against the relentless ticking of the project clock. You work small miracles every day.
It's a difficult job.
There are many people offering you help. Tool vendors tout the miracles their products perform. Methodology gurus promise that their techniques guarantee results. Everyone claims that their programming language is the best, and every operating system is the answer to all conceivable ills.
Of course, none of this is true. There are no easy answers. There is no such thing as a best solution, be it a tool, a language, or an operating system. There can only be systems that are more appropriate in a particular set of circumstances.
This is where pragmatism comes in. You shouldn't be wedded to any particular technology, but have a broad enough background and experience base to allow you to choose good solutions in particular situations. Your background stems from an understanding of the basic principles of computer science, and your experience comes from a wide range of practical projects. Theory and practice combine to make you strong.
You adjust your approach to suit the current circumstances and environment. You judge the relative importance of all the factors affecting a project and use your experience to produce appropriate solutions. And you do this continuously as the work progresses. Pragmatic Programmers get the job done, and do it well.
Who Should Read This Book?
This book is aimed at people who want to become more effective and more productive programmers. Perhaps you feel frustrated that you don't seem to be achieving your potential. Perhaps you look at colleagues who seem to be using tools to make themselves more productive than you. Maybe your current job uses older technologies, and you want to know how newer ideas can be applied to what you do.
We don't pretend to have all (or even most) of the answers, nor are all of our ideas applicable in all situations. All we can say is that if you follow our approach, you'll gain experience rapidly, your productivity will increase, and you'll have a better understanding of the entire development process. And you'll write better software.
Product details
- ASIN : 020161622X
- Publisher : Addison-Wesley Professional; 1st edition (October 30, 1999)
- Language : English
- Paperback : 352 pages
- ISBN-10 : 9780201616224
- ISBN-13 : 978-0201616224
- Item Weight : 1.33 pounds
- Dimensions : 9.2 x 7.4 x 0.9 inches
- Best Sellers Rank: #441,066 in Books (See Top 100 in Books)
- #316 in Computer Programming Languages
- #496 in Microsoft Programming (Books)
- #1,613 in Computer Software (Books)
- Customer Reviews:
About the authors
Andy Hunt is a writer of books on software development and chill scifi. Hunt co-authored the seminal text "The Pragmatic Programmer," the popular "Pragmatic Thinking & Learning", award-winning "Practices of an Agile Developer", a half-dozen other books and many articles. Andy was one of the 17 original authors of the Agile Manifesto. He and co-author Dave Thomas founded the Pragmatic Bookshelf publishing house, specializing in books for for software developers, testers, and managers.
I'm a programmer, and now I'm an accidental publisher.
I wrote The Pragmatic Programmer with Andy Hunt at the end of the '90s, and that experience opened a new world for us. We discovered a love of writing that complemented our love of learning new things.
I'm one of the authors of the Agile Manifesto, and I'm probably responsible for bringing Ruby to attention of Western developers with the book Programming Ruby. I was one of the first adopters of Rails, and helped spread the word with the book Agile Web Development with Rails.
I enjoy speaking at conferences, running public and private training. But most of all, I love coding.
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on Amazon-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
There are many classics, like "The C Programming Language," or Knuth's "The Art of Computer Programming" series. Then there are modern classics, such as "Design Patterns," and more recently "Learn Python the Hard Way." But this book excels them all in several ways.
The programming world has long-lacked a normal approach to itself for outsiders. This is why so many programmers are self-taught. We work in a budding field that still hasn't come of age. If the authors continue to revise and improve this work, I would go so far as to say this might the _the_ classic for introducing practical-minded outsiders to the befuddling world of computer programming.
I've always been a geek at heart, but my interests expanded easily past computers to things I can understand better. I found programming books verbose and filled with not enough "why" answers, except when those "why" answers served as rationalization for the author imposing their bias and subjective understanding of various problems onto your entire view of computer science.
The Pragmatic Programmer does not do this. It assumes you are intelligent and can think for yourself about problems, and need help solving them, but not necessarily to be told _how_ to solve them. So much of "teaching" software development is just faulty teachers trying to impose implicit software paradigms on incomplete problems and expecting you, the learner, to be not only satisfied with the completeness of their answer, but to understand why they picked the particular subjective approach that they did.
In truth, this happens in all fields, but it gets especially religious in the field of computer programming. Most people apply the reverse of the sour-grapes fable from Aesop to their own programs. In other words, "My programming grapes are so juicy and sweet that everyone else's in comparison taste quite sour."
Programmers love to take the religious experience of making a computer do something and assume that they should be all-powerful just because they figured out an effective, repeatable way to solve a problem. News flash: There are 1000 ways to tell a computer to do the same thing in 1000 different programming languages. The real test is not whether your software works, but if it works well enough given the constraints you faced in creating it.
So few people understand this and think it's just about the code. It's not about the code, it's about problem solving, and not just formal problem solving, but real-world and practical problem solving. What problem does your software solve, and does it solve it the most effective way you can think of? If you've been frustrated by the approach of most software books, you should give this one a try.
Thomas and Hunt present content that is useful for everyone from the novice to the expert. They organize their advice into approximately 46 topics that cover a wide range of programming best practices. The tips build on each other throughout and are loosely categorized so that tips on similar themes are grouped together. To get the most out of it, I suggest reading the whole book, or at least sizeable sections, beginning to end to clearly see how they integrate. However, because there are so many tips, integrating them all at once initially may be difficult. It’s easy to bite off more than you can chew here, so perhaps a good starting point is to begin with the tips that are most relevant for you and branch out from there. A couple of sections resonated strongly with me:
1) A useful practice that I operate by and push my developers to operate by is refactoring (Chapter 6 – “While You Are Coding”, p. 184). This book provides a framework for the appropriate mindset to take on how to handle and maintain a code base. In refactoring, you don’t relate the software so much to a construction project but to creating and maintaining a garden – code is dynamic and its environment is ever changing. You’ll need to adapt and adjust code as the project moves along, and developers need to operate from the mindset that they’ll need to change things and adapt their code as they proceed.
2) Another practice that I follow extensively is Design by Contract (Chapter 4 – “Pragmatic Paranoia”, p. 109), or the idea that you build/structure elements to a defined contract. This could be a contract between systems, classes, or even functions. I use this approach with both my local developers and external developers, and this book gives a good framework and guidelines on how applications and classes need to work. For example, I can define a contract for how a base class and its subclasses need to work and interact, and then work with a developer to provide the specific implementation for that class. I also use this approach for APIs when coordinating with an external team to handle an exchange of data.
I’m a software architect and developer with over 20 years of industry experience across a number of languages and systems, and I’ve completed hundreds of projects both individually and with technical and cross-disciplinary teams of varying sizes. Most of the subjects covered in this book are best practices I look for or insist on establishing on my projects to ensure work moves along smoothly during development. This book covers the spectrum – it’s equally useful to me, my project managers and developers, and those just getting into our industry. It’s a solid book to return to every once in a while to make sure you’re in alignment with best practices. I highly recommend it to both new and experienced developers. I hope it helps you as much as it’s helped me.
But if it is for you, you'll be glad you gave it a chance. I usually peruse negative reviews before I make a book purchase. They don't always sway me away from making a purchase and this is one case where I'm very grateful they didn't. Your milage may vary. If you're unsure, checkout the "Look Inside" feature. If that doesn't tilt the scale one way or the other, you might try your local library's copy before committing to a purchase if you think you may lean more to the negative reviews side of the aisle. I actually purchased this book in January of 2018 and read a little past "Tracer Bullets" which really resonated with be. Then I got busy with other things and "The Pragmatic Programmer" sat on the shelf for awhile. Well, I've taken it up again and am going through it slowly, savoring every bit. My thanks and appreciation to the authors, Andrew Hunt and David Thomas! Excellent book!
As far as the "...common sense tips...etc." from the negative review excerpt above, you can gain all that "common sense" the hard way (unless it just intrinsically dwells in you), or you can let this book put you on the trail and enjoy the journey with some great insights.
This book will always hold a prominent place on my computer science bookshelf. If I had known how much I would love programming in the beginning, this is a book I wish would have crossed my path much sooner. Thanks again Andrew Hunt and David Thomas!
Top reviews from other countries

I learnt few things
Not very comprehensive



