The Pragmatic Programmer Reference

A comprehensive reference for pragmatic software development principles based on "The Pragmatic Programmer" by David Thomas and Andrew Hunt. This skill provides timeless advice for becoming a better developer.

When This Skill Activates

This skill automatically activates when you:

• Discuss software development best practices
• Need debugging strategies
• Consider code duplication (DRY)
• Think about tooling and automation
• Discuss project estimation or planning
• Review development workflows

Core Philosophy

"Care about your craft." "Think about your work."

Pragmatic programmers:

• Take responsibility for their career and work
• Don't make excuses—provide options
• Are agents of change, not victims of circumstance
• Continuously learn and adapt

Quick Reference

Foundational Principles

Principle	Summary
DRY - Don't Repeat Yourself	Every piece of knowledge has a single representation
Orthogonality	Keep things independent and decoupled
Reversibility	Make decisions reversible; avoid lock-in
Tracer Bullets	Get feedback fast with end-to-end skeleton
Prototypes	Learn before committing; throw away prototypes
Domain Languages	Program close to the problem domain
Estimating	Learn to give accurate estimates

Practical Techniques

Practice	Summary
The Power of Plain Text	Keep knowledge in accessible format
Shell Games	Master the command line
Debugging	Fix the problem, not the blame
Text Manipulation	Learn text processing tools
Code Generators	Write code that writes code
Design by Contract	Define rights and responsibilities
Assertive Programming	If it can't happen, use assertions
Decoupling	Minimize dependencies between modules
Refactoring	Improve code continuously
Testing	Test early, test often, test automatically
Automation	Don't use manual procedures

The Pragmatic Tips

Key tips from the book:

1. Care About Your Craft - Why spend your life developing software unless you care?
2. Think! About Your Work - Turn off autopilot and take control
3. Provide Options, Don't Make Excuses - Don't say it can't be done; explain what can be done
4. Don't Live with Broken Windows - Fix bad designs and wrong decisions when you see them
5. Be a Catalyst for Change - Show people the future and help them participate
6. Remember the Big Picture - Don't get so focused you forget what you're doing
7. Make Quality a Requirements Issue - Get users involved in determining quality
8. Invest Regularly in Your Knowledge Portfolio - Make learning a habit
9. Critically Analyze What You Read and Hear - Don't be swayed by vendors or media hype
10. It's Both What You Say and How You Say It - Communication matters

The Knowledge Portfolio

Treat your knowledge like a financial portfolio:

• Invest regularly - Learn something new routinely
• Diversify - Know many different technologies
• Manage risk - Balance safe tech with high-risk/high-reward
• Buy low, sell high - Learn emerging tech before it becomes mainstream
• Review and rebalance - Reassess periodically

Suggestions:

• Learn a new language every year
• Read a technical book each month
• Read non-technical books too
• Take classes
• Participate in local user groups
• Experiment with different environments
• Stay current (newsletters, blogs, conferences)

Communication

• Know what you want to say
• Know your audience
• Choose the right moment
• Choose a style
• Make it look good
• Involve your audience
• Be a listener
• Get back to people
• Documentation is part of the project, not after

Language Translation Notes

Examples use generic pseudocode. Adapt to your language:

• PHP: class, function, ->, type hints
• JavaScript/TypeScript: class, arrow functions, .
• Python: class, def, ., type hints
• Java/C#: Direct mapping with access modifiers

---

Based on concepts from "The Pragmatic Programmer: Your Journey to Mastery" by David Thomas and Andrew Hunt.