Dated but still useful; many ideas continue to apply today.

Key takeaways?
- orthogonality/ownership in teams
- one source of truth/model, everything else is a view — including schemas/source (codegen)
- pub/sub is a useful paradigm
- prototyping is important
- automation (try git commit hooks)

I have listened to this book. I have enjoyed every chapter of this book. Good insights!

A very insightful read. I look at my projects differently after reading this. It doesn't focus on a particular language, but rather teaches principles.

The beautiful thing about a book like The Pragmatic Programmer is that it sparks ideas when you read it. Can you do something more efficiently? Can you do it more elegantly? Can you make the computer do the work instead?

I like to think that I already ask myself those questions all the time. Nevertheless, I found myself reading a page or two and then having to stop because I was having a great idea and needed to write it down. I filled six sheets of letter-size paper with dense, cryptic notes. That's six pages of Great Ideas about software. Many of them had absolutely nothing to do with whatever I was reading in The Pragmatic Programmer at the time. The ideas bubbled up from the bottom of my brain like swamp gas.

The experience was as effervescent as it sounds. And completely invigorating. I ended the day with a finished book, those six pages of notes, and a whole new enthusiasm for my software projects. I should read these non-language-specific programming books more often!

I've loved the "broken windows" theory from the Software Entropy section in the first chapter since I read the excerpt online years ago. I've still never heard a better explanation of what happens when code quality and clarity starts to deteriorate. The message is clear: don't let problematic code sit and rot. It's not going to get better on its own.

I love the emphasis on DRY ("Don't Repeat Yourself") and the use of simple, elegant tools like domain-specific languages and plain text.

Another real stand-out for me was the Tracer Bullets concept from the second chapter. It's a wonderfully visual metaphor for building enough of a software system so that you can demonstrate its functionality completely from one end to the other (i.e. multiple pieces of a system all working together, but supporting a minimal number of features). What I love most about a tracer bullet system: you will probably end up with something you can demonstrate to non-programmers! In my experience, that's a huge benefit.

There's a large amount of ground covered and nothing is covered in depth. Which is great. I appreciate the low page count and Hunt and Thomas supply examples to make each concept clear. It's an information-rich and idea-rich book. You could do a lot worse than to simply follow all of its avenues and master them. Much, much worse.

This book has bold advices for good code. I see them repeated in many courses and in my internship.

I wish I've read this book 10 years ago!.

The book is a must read for aspiring programmers, the earlier you do it in your career, the merier fruits you will reap. The book distills years of experience for you to contemplate and reflect upon. At some points I said "Aha! So that's how you call this, or describe that", referring to concepts I know or believe in but I always was unable to explain.

It's an eye-opener and fun to read. The use of metaphors and examples is spot-on and make things really stick to mind.

این کتاب رو اولین بار یکی از دوستام بهم معرفی کرد. فک کنم اواخر ۸۸ بود. همون موقع چند فصل رو خوندم و همیشه کتاب روی دستکاپم بود و یه فصل رندم میخوندم. ولی هیچوقت از سر تا ته نخوندمش. اصلا حسم به کتاب این نبود. این دفعه گفتم بابا بذار یه بار از سر تا تهشو بخونم شاید یه چیزی جا مونده باشه. ولی همین بارم خودش کلی طول کشید.

نکات کتاب چند دسته‌اند. بعضی‌ها رو با عقل سلیم هم میشه فهمید. مثلا کد خوب بزنید! :))
بعضی نکات واقعا شاید دقیق و درست نباشن. این نکته که کتاب مال ۲۰ سال پیشه رو نباید فراموش کرد. همین نکته هم باعث میشه که خیلی از مفاهیم شبیه سی‌آی سی‌دی اصلا جزوی از داستان نباشن.
یه سری نکات هم به نظرم خیلی ساده به نظر میان. بعد از مدت‌ها تجربه تازه میفهمی منظورشون چیه. یعنی وقتی بار اول میخونی میگی که چی... ولی بعد از ده سال دوباره که بخونی تازه میفهمی که چی بود داستان

خود مثال‌های کتاب بعضا برام روی اعصاب بود. ولی در کل اون منظوری که نویسنده مد نظرش بود رو میرسوند.

در کل کتابهایی که میان اینطوری نکته و راهنمای موفقیت میگن برام عجیبن. چون همیشه حسم اینه که موفقیت راهنمای پخت نداره. بیشتر راهنمای خراب کردن داره! ولی با این حال نکات مهمی هست که بعضا ما فراموش میکنیم و این کتابمم همون ها رو پوشش میده.

کل نکات کتاب رو اینجا میتونید ببینید. همینطور هایلایت هم کردم. پس تو هایلایت ها هم میتونید قسمت خوبیشو ببینید

Tip #1, pg. xxi: Care About Your Craft
Why spend your life developing software unless you care about doing it well?

Tip #2, pg. xxi: Think! About Your Work
Turn off the autopilot and take control. Constantly critique and appraise your work.

Tip #3, pg. 2: You Have Agency
It’s your life. Grab hold of it and make it what you want.

Tip #4, pg. 4: Provide Options, Don’t Make Lame Excuses
Instead of excuses, provide options. Don’t say it can’t be done; explain what can be done.

Tip #5, pg. 7: Don’t Live with Broken Windows
Fix bad designs, wrong decisions, and poor code when you see them.

Tip #6, pg. 9: Be a Catalyst for Change
You can’t force change on people. Instead, show them how the future might be and help them participate in creating it.

Tip #7, pg. 10: Remember the Big Picture
Don’t get so engrossed in the details that you forget to check what’s happening around you.

Tip #8, pg. 12: Make Quality a Requirements Issue
Involve your users in determining the project’s real quality requirements.

Tip #9, pg. 15: Invest Regularly in Your Knowledge Portfolio
Make learning a habit.

Tip #10, pg. 17: Critically Analyze What You Read and Hear
Don’t be swayed by vendors, media hype, or dogma. Analyze information in terms of you and your project.

Tip #11, pg. 20: English is Just Another Programming Language
Treat English as Just Another Programming Language. Write documents as you would write code: honor the DRY principle, ETC, automation, and so on.

Tip #12, pg. 22: It’s Both What You Say and the Way You Say It
There’s no point in having great ideas if you don’t communicate them effectively.

Tip #13, pg. 23: Build Documentation In, Don’t Bolt It On
Documentation created separately from code is less likely to be correct and up to date.

Tip #14, pg. 28: Good Design Is Easier to Change Than Bad Design
A thing is well designed if it adapts to the people who use it. For code, that means it must adapt by changing.

Tip #15, pg. 31: DRY—Don't Repeat Yourself
Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

Tip #16, pg. 38: Make It Easy to Reuse
If it’s easy to reuse, people will. Create an environment that supports reuse.

Tip #17, pg. 40: Eliminate Effects Between Unrelated Things
Design components that are self-contained, independent, and have a single, well-defined purpose.

Tip #18, pg. 48: There Are No Final Decisions
No decision is cast in stone. Instead, consider each as being written in the sand at the beach, and plan for change.

Tip #19, pg. 49: Forgo Following Fads
Neal Ford says, “Yesterday’s Best Practice Becomes Tomorrow’s Antipattern.” Choose architectures based on fundamentals, not fashion.

Tip #20, pg. 51: Use Tracer Bullets to Find the Target
Tracer bullets let you home in on your target by trying things and seeing how close they land.

Tip #21, pg. 57: Prototype to Learn
Prototyping is a learning experience. Its value lies not in the code you produce, but in the lessons you learn.

Tip #22, pg. 60: Program Close to the Problem Domain
Design and code in the language of the problem domain.

Tip #23, pg. 66: Estimate to Avoid Surprises
Estimate before you start. You’ll spot potential problems up front.

Tip #24, pg. 70: Iterate the Schedule with the Code
Use experience you gain as you implement to refine the project time scales.

Tip #25, pg. 75: Keep Knowledge in Plain Text
Plain text won’t become obsolete. It helps leverage your work and simplifies debugging and testing.

Tip #26, pg. 79: Use the Power of Command Shells
Use the shell when graphical user interfaces don’t cut it.

Tip #27, pg. 81: Achieve Editor Fluency
An editor is your most important tool. Know how to make it do what you need, quickly and accurately.

Tip #28, pg. 85: Always Use Version Control
Version control is a time machine for your work; you can go back.

Tip #29, pg. 89: Fix the Problem, Not the Blame
It doesn’t really matter whether the bug is your fault or someone else’s—it is still your problem, and it still needs to be fixed.

Tip #30, pg. 89: Don’t Panic
This is true for galactic hitchhikers and for developers.

Tip #31, pg. 91: Failing Test Before Fixing Code
Create a focussed test that reveals the bug before you try fixing it.

Tip #32, pg. 92: Read the Damn Error Message
Most exceptions tell both what failed and where it failed. If you’re lucky you might even get parameter values.

Tip #33, pg. 95: “select” Isn't Broken
It is rare to find a bug in the OS or the compiler, or even a third-party product or library. The bug is most likely in the application.

Tip #34, pg. 96: Don’t Assume It—Prove It
Prove your assumptions in the actual environment—with real data and boundary conditions.

Tip #35, pg. 98: Learn a Text Manipulation Language
You spend a large part of each day working with text. Why not have the computer do some of it for you?

Tip #36, pg. 102: You Can’t Write Perfect Software
Software can’t be perfect. Protect your code and users from the inevitable errors.

Tip #37, pg. 107: Design with Contracts
Use contracts to document and verify that code does no more and no less than it claims to do.

Tip #38, pg. 113: Crash Early
A dead program normally does a lot less damage than a crippled one.

Tip #39, pg. 115: Use Assertions to Prevent the Impossible
If it can’t happen, use assertions to ensure that it won’t. Assertions validate your assumptions. Use them to protect your code from an uncertain world.

Tip #40, pg. 118: Finish What You Start
Where possible, the function or object that allocates a resource should be responsible for deallocating it.

Tip #41, pg. 121: Act Locally
Keep the scope of mutable variables and open resources short and easily visible.

Tip #42, pg. 126: Take Small Steps—Always
Small steps always; check the feedback; and adjust before proceeding.

Tip #43, pg. 127: Avoid Fortune-Telling
Only look ahead as far as you can see.

Tip #44, pg. 131: Decoupled Code Is Easier to Change
Coupling ties things together, so that it’s harder to change just one thing.

Tip #45, pg. 132: Tell, Don’t Ask
Don’t get values from an object, transform them, and then stick them back. Make the object do the work.

Tip #46, pg. 134: Don’t Chain Method Calls
Try not to have more than one dot when you access something.

Tip #47, pg. 136: Avoid Global Data
It’s like adding an extra parameter to every method.

Tip #48, pg. 136: If It’s Important Enough To Be Global, Wrap It in an API
…but only if you really, really want it to be global.

Tip #49, pg. 149: Programming Is About Code, But Programs Are About Data
All programs transform data, converting an input into an output. Start designing using transformations.

Tip #50, pg. 153: Don’t Hoard State; Pass It Around
Don’t hang on to data within a function or module. Take one down and pass it around.

Tip #51, pg. 161: Don't Pay Inheritance Tax
Consider alternatives that better fit your needs, such as interfaces, delegation, or mixins

Tip #52, pg. 162: Prefer Interfaces to Express Polymorphism
Interfaces make polymorphism explicit without the coupling introduced by inheritance.

Tip #53, pg. 163: Delegate to Services: Has-A Trumps Is-A
Don’t inherit from services: contain them.

Tip #54, pg. 165: Use Mixins to Share Functionality
Mixins add functionality to classes without the inheritance tax. Combine with interfaces for painless polymorphism.

Tip #55, pg. 166: Parameterize Your App Using External Configuratio
When code relies on values that may change after the application has gone live, keep thse values external to the app. When you application will run in different environments, and potentially for different customers, keep the environment and customer specific values outside the app.

Tip #56, pg. 171: Analyze Workflow to Improve Concurrency
Exploit concurrency in your user’s workflow.

Tip #57, pg. 174: Shared State Is Incorrect State
Shared state opens a large can of worms that can often only be fixed by rebooting.

Tip #58, pg. 180: Random Failures Are Often Concurrency Issues
Variations in timing and context can expose concurrency bugs, but in inconsistent and irreproducible ways.

Tip #59, pg. 182: Use Actors For Concurrency Without Shared State
Use Actors to manage concurrent state without explicit synchronization.

Tip #60, pg. 189: Use Blackboards to Coordinate Workflow
Use blackboards to coordinate disparate facts and agents, while maintaining independence and isolation among participants.

Tip #61, pg. 194: Listen to Your Inner Lizard
When it feels like your code is pushing back, it’s really your subconscious trying to tell you something’s wrong.

Tip #62, pg. 200: Don’t Program by Coincidence
Rely only on reliable things. Beware of accidental complexity, and don’t confuse a happy coincidence with a purposeful plan.

Tip #63, pg. 207: Estimate the Order of Your Algorithms
Get a feel for how long things are likely to take before you write code.

Tip #64, pg. 208: Test Your Estimates
Mathematical analysis of algorithms doesn’t tell you everything. Try timing your code in its target environment.

Tip #65, pg. 212: Refactor Early, Refactor Often
Just as you might weed and rearrange a garden, rewrite, rework, and re-architect code when it needs it. Fix the root of the problem.

Tip #66, pg. 214: Testing Is Not About Finding Bugs
A test is a perspective into your code, and gives you feedback about its design, api, and coupling.

Tip #67, pg. 216: A Test Is the First User of Your Code
Use its feedback to guide what you do.

Tip #68, pg. 218: Build End-To-End, Not Top-Down or Bottom Up
Build small pieces of end-to-end functionality, learning about the problem as you go.

Tip #69, pg. 221: Design to Test
Start thinking about testing before you write a line of code.

Tip #70, pg. 223: Test Your Software, or Your Users Will
Test ruthlessly. Don’t make your users find bugs for you.

Tip #71, pg. 224: Use Property-Based Tests to Validate Your Assumptions
Property-based tests will try things you never thought to try, and exercise your code in ways is wasn’t meant to be used.

Tip #72, pg. 234: Keep It Simple and Minimize Attack Surfaces
Complex code creates a breeding ground for bugs and opportunities for attackers to exploit.

Tip #73, pg. 235: Apply Security Patches Quickly
Attackers deploy exploits as quick as they can, you have to be quicker.

Tip #74, pg. 242: Name Well; Rename When Needed
Name to express your intent to readers, and rename as soon as that intent shifts.

Tip #75, pg. 244: No One Knows Exactly What They Want
They might know a general direction, but they won’t know the twists and turns.

Tip #76, pg. 245: Programmers Help People Understand What They Want
Software development is an act of co-creation between users and programmers.

Tip #77, pg. 246: Requirements Are Learned in a Feedback Loop
Understanding requirements requires exploration and feedback, so the consequences of decisions can be used to refine the initial ideas.

Tip #78, pg. 247: Work with a User to Think Like a User
It’s the best way to gain insight into how the system will really be used.

Tip #79, pg. 248: Policy Is Metadata
Don’t hardcode policy into a system; instead express it as metadata used by the system.

Tip #80, pg. 251: Use a Project Glossary
Create and maintain a single source of all the specific terms and vocabulary for a project.

Tip #81, pg. 254: Don’t Think Outside the Box—Find the Box
When faced with an impossible problem, identify the real constraints. Ask yourself: “Does it have to be done this way? Does it have to be done at all?”

Tip #82, pg. 259: Don't Go into the Code Alone
Programming can be difficult and demanding. Take a friend with you.

Tip #83, pg. 259: Agile Is Not a Noun; Agile Is How You Do Things
Agile is an adjective: it’s how you do something.

Tip #84, pg. 264: Maintain Small Stable Teams
Teams should be small and stable, where everyone trusts each other and depends on each other.

Tip #85, pg. 266: Schedule It to Make It Happen
If you don’t schedule it, it’s not going to happen. Schedule reflection, experimentation, learning and skills improvement.

Tip #86, pg. 268: Organize Fully Functional Team
Organize Around Functionality, Not Job Function. Don’t separate UI/UX designers from coders, frontend from backend, testers from data modelers, design from deployment. Build teams so you can build code end-to-end, incrementally and iteratively.

Tip #87, pg. 271: Do What Works, Not What’s Fashionable
Don’t adopt a development method or technique just because other companies are doing it. Adopt what works for your team, in your context.

Tip #88, pg. 273: Deliver When Users Need It
Don’t wait weeks or months to deliver just because your process demands it.

Tip #89, pg. 274: Use Version Control to Drive Builds, Tests, and Releases
Use commits or pushes to trigger builds, tests, releases. Use a version control tag to deploy to production.

Tip #90, pg. 275: Test Early, Test Often, Test Automatically
Tests that run with every build are much more effective than test plans that sit on a shelf.

Tip #91, pg. 275: Coding Ain’t Done ’Til All the Tests Run
’Nuff said.

Tip #92, pg. 277: Use Saboteurs to Test Your Testing
Introduce bugs on purpose in a separate copy of the source to verify that testing will catch them.

Tip #93, pg. 278: Test State Coverage, Not Code Coverage
Identify and test significant program states. Testing just lines of code isn’t enough.

Tip #94, pg. 278: Find Bugs Once
Once a human tester finds a bug, it should be the last time a human tester finds that bug. Automatic tests should check for it from then on.

Tip #95, pg. 279: Don't Use Manual Procedures
A computer will execute the same instructions, in the same order, time after time.

Tip #96, pg. 281: Delight Users, Don’t Just Deliver Code
Develop solutions that produce business value for your users and delight them every day.

Tip #97, pg. 282: Sign Your Work
Artisans of an earlier age were proud to sign their work. You should be, too.

Tip #98, pg. 286: First, Do No Harm
Failure is inevitable. Make sure no one will suffer because of it.

Tip #99, pg. 287: Don’t Enable Scumbags
Because you risk becoming one, too.

Tip #100, pg. 287: It’s Your Life. Share it. Celebrate it. Build it. AND HAVE FUN!
Enjoy this amazing life we have, and do great things.

This is essentially a self-help guide for programmers, the kind of book that enumerates the habits of Good and Happy People and makes you feel slightly guilty about not practicing most of them, but probably won't result in you forsaking your evil ways and stepping on the path toward Nirvana. Hunt and Thomas are friendly but occasionally annoying gurus. Their cloying metaphors (boiled frogs, etc) and kitsch jokes are offputting, and some of their advice borders on insult. One assumes that when they devote a whole section to interpersonal communication that they are targetting the particularly closeted and uncouth breed of computer geek recently emerged from the dark and brutish cave of high school, struggling to make headway in a world full of messy, inconsistent, emotional people who don't even know how to reverse grep an Apache log.

That said, I think there are nuggets of good advice for everyone all over the book. Programming, like reading and writing, is ultimately a private, personal activity, and to be honest, most of us software engineers were that closeted high school nerd at some point, and draw upon that focused, single-minded persona when we do things like coding, so there are lessons to be learned from taking a step back occasionally and examining the craft, as Hunt and Thomas do. They are, as I said, occasionally infuriating, but even their silly aphorisms and mantras are usually memorable (what software engineer isn't constantly trying to stay DRY?). I've no doubt I'll be flipping through it again in the future, especially when I feel like I've hit a wall, fell in a rut, or found myself exploiting tired and hackneyed idioms that don't do the English language any justice.

There's probably several reasons I didn't find the book THAT good:
- most of the advice and techniques I've read elsewhere. Perhaps the book has been so influential that it's contents have already proliferated software engineering common knowledge or maybe I'm just well informed?
- I listened to the audiobook and some of format didn't translate that well. You might ask but "what kind of idiot reads an audiobook version of a programming book" and you would largely be right. But I would also respond "Why would they make it an audiobook if it didn't translate well? "

So overall, I give it a 3 because I felt like I didn't learn anything substantial and most of it seemed like programmer common sense.

Cada tip q incluye es super valioso y útil en la carrera de cualquier desarrollador/a, varias cosas se van aprendiendo con la experiencia, pero es interesante conocerlo de antes. Con haber leído sólo algunos de los tips e incorporarlos al día a día profesional, vas a mejorar con seguridad tus habilidades

This is a good first read for fresh grads coming into the industry. The book touches many important topics in the realm of software development. A non-exhaustive list would include: how to behave professionally; how to write good code; find and use the right tools; how to work with others; and last but not least, how to manage software development projects.

As you may have guessed, this amount of subjects can not be covered in depth in a 300 pages book. As a result, the book can only provide an overview of what it means to be a professional software developer, but does not necessarily give you a clear path on how to get there. That would require a lot of learning, practices and experience. So, please don't expect to become a "master" after reading this book.

On another note, the book was published nearly 2 decades ago but the majority of contents are still relevant today. I guess it's like they say: something never change..

This was a great book for programmers to read. It had a lot of very general, yet very useful advice for programmers. I loved the broken window theory of programming. Malcolm Gladwell argues the same theory cured New York's crime wave in the 90's in  Blink