The Pragmatic Programmer

"From Journeyman to Master"

Rating

★★★★☆

Authors

Andrew Hunt & David Thomas

Pages

352

Genres

Technology

Tags

programming, software engineering

Links

Amazon, Goodreads

Status

Done

Published in 1999, it is considered somewhat of a classic in software engineering. And rightfully so. Some common programming references were coined by this book, which include “broken windows”, “a good programmer doesn’t blame her tools”, “tracer bullets”, “refactor early and refactor often”, “abstractions live longer than details”, “design to test” and “test early, test often, test automatically”.

I’ve read the book a couple of years ago and remember wishing I’d done so earlier in my career. It would have been more helpful back then in order to build a good foundation of proven practices and general code hygiene from the start on. Still, I’ve learned and reflected on the points made in the book and recommend it to any programmer.

The authors present gems of advice and proven practices in the form of well-packaged digestible chapters. Here is the table of contents:

• Part 1. A Pragmatic Philosophy
  • 1. The Cat Ate My Source Code
  • 2. Software Entropy
  • 3. Stone Soup and Boiled Frogs
  • 4. Good enough soup
  • 5. Your Knowledge Portfolio
  • 6. Communicate
• Part 2. A Pragmatic Approach
  • 7. The Evils of Duplication
  • 8. Orthogonality
  • 9. Reversibility
  • 10. Tracer Bullets
  • 11. Prototypes and Post-it Notes
  • 12. Domain Languages
  • 13. Estimating
• Part 3. The Basic Tools
  • 14. The Power of Plain Text
  • 15. Shell Games
  • 16. Power Editing
  • 17. Source Code Control
  • 18. Debugging
  • 19. Text Manipulation
  • 20. Code Generators
• Part 4. A Pragmatic Paranoia
  • 21. Design by Contract
  • 22. Dead Programs Tell No Lies
  • 23. Assertive Programming
  • 24. When to Use Exceptions
  • 25. How to Balance Resources
• Part 5. Bend or Break
  • 26. Decoupling and the Law of Demeter
  • 27. Metaprogramming
  • 28. Temporal Coupling
  • 29. It’s Just a View
  • 30. Blackboards
• Part 6. While you are coding
  • 31. Program by Coincidence
  • 32. Algorithm Speed
  • 33. Refactoring
  • 34. Code That’s Easy to Test
  • 35. Evil Wizards
• Part 7. Before the project
  • 36. The Requirements Pit
  • 37. Solving Impossible Puzzles
  • 38. Not Until You’re Ready
  • 39. The Specification Trap
  • 40. Circles and Arrows
• Part 8. Pragmatic Projects
  • 41. Pragmatic Teams
  • 42. Ubiquitous Automation
  • 43. Ruthless testing
  • 44. It’s All Writing
  • 45. Great Expectations