The Pragmatic Programmer: From Journeyman to Master

The Pragmatic Programmer: From Journeyman to Master
The Pragmatic Programmer: From Journeyman to Master

The Pragmatic Programmer: From Journeyman to Master is good reading for all developers and good addition to Ship it! A Practical Guide to Successful Software Projects. The Pragmatic Programmer is about developers everyday work and provides solutions and ideas about how to solve problems we may face more than once.

The book covers also tools and strategies we may want to use to be more productive. Also we have to upgrade our mindset a little bit to have attitude that let’s us be better programmers. All these suggestion together – if we follow them – help us work more productively and avoid frustration and calamity caused by our work today.

Pragmatic programmers are not evangelists or some other type of highly biased radicals who stick to their favourite tools and techniques and ignore the other options they have. Pragmatic programmers use all the tools they can to make a better job and they continuously develop their skills. They are proud programmers who take all the responsibility of their work.

Excerpt from Amazon

Programmers are craftspeople trained to use a certain set of tools (editors, object managers, version trackers) to generate a certain kind of product (programs) that will operate in some environment (operating systems on hardware assemblies). Like any other craft, computer programming has spawned a body of wisdom, most of which isn’t taught at universities or in certification classes. Most programmers arrive at the so-called tricks of the trade over time, through independent experimentation. In The Pragmatic Programmer, Andrew Hunt and David Thomas codify many of the truths they’ve discovered during their respective careers as designers of software and writers of code.

Table of contents

  • FOREWORD
  • PREFACE
  • 1 A PRAGMATIC PHILOSOPHY
    • 1. The Cat Ate My Source Code
    • 2. Software Entropy
    • 3. Stone Soup and Boiled Frogs
    • 4. Good-Enough Software
    • 5. Your Knowledge Portfolio
    • 6. Communicate!
  • 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
  • 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
  • 4 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
  • 5 BEND, OR BREAK
    • 26. Decoupling and the Law of Demeter
    • 27. Metaprogramming
    • 28. Temporal Coupling
    • 29. It’s Just a View
    • 30. Blackboards
  • 6 WHILE YOU ARE CODING
    • 31. Programming by Coincidence
    • 32. Algorithm Speed
    • 33. Refactoring
    • 34. Code That’s Easy to Test
    • 35. Evil Wizards
  • 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
  • 8 PRAGMATIC PROJECTS
    • 41. Pragmatic Teams
    • 42. Ubiquitous Automation
    • 43. Ruthless Testing
    • 44. It’s All Writing
    • 45. Great Expectations
    • 46. Pride and Prejudice
  • Appendices
    • A RESOURCES
    • B ANSWERS TO EXERCISES
    • INDEX


Leave a Reply

Your email address will not be published. Required fields are marked *