97 Things Every Programmer Should Know

Welcome to the home page for the 97 Things Every Programmer Should Know
project, pearls of wisdom for programmers collected from leading practitioners. You can read through the Edited Contributions
, browse Contributions in Progress
, view the list of current Contributors
, and also learn How to Become a Contributor
. If you would simply like to comment on a contribution, please also read How to Become a Contributor
as some of it applies to you.

There is no overarching narrative: The collection is intended
simply to contain multiple and varied perspectives on what it is that
contributors to the project feel programmers should know. This can be
anything from code-focused advice to culture, from algorithm usage to
agile thinking, from implementation know-how to professionalism, from
style to substance, etc.

The deadline for having something considered for inclusion in
the the book form of the project is 16th October 2009. Following that,
97 contributions will be picked from the Edited Contributions
and published in O'Reilly's 97 Things
series, which already includes 97 Things Every Software Architect Should Know
(also see the 97 Things Every Software Architect Should Know homepage
) and 97 Things Every Project Manager Should Know
. You can find out more about the series and the 97 Things Every Programmer Should Know
project in this InfoQ article

The 97 chosen for the book will be the ones considered not only
to be the best individually, but also the ones that fit best together.
Every contributor whose contribution goes into the book will be fully
acknowledged in the book and will get a complementary copy of the book
when it is published. The contributions for the site are being edited
by Kevlin Henney
, who will also be listed as the editor of the published book.

  1. Fulfill Your Ambitions with Open Source
    by Richard Monson-Haefel

  2. Comment Only What the Code Cannot Say
    by Kevlin Henney

  3. Restrict Mutability of State
    by Kevlin Henney

  4. Speed Kills
    by Uncle Bob

  5. Encapsulate Behavior, not Just State
    by Einar Landre

  6. Only the Code Tells the Truth
    by Peter Sommerlad

  7. Interfaces Should Reveal Intention
    by Einar Landre

  8. Inter-Process Communication Affects Application Response Time
    by Randy Stafford

  9. Test for Required Behavior, not Incidental Behavior
    by Kevlin Henney

  10. Test Precisely and Concretely
    by Kevlin Henney

  11. Verbose Logging Will Disturb your Sleep
    by Johannes Brodwall

  12. The Road to Performance Is Littered with Dirty Code Bombs
    by Kirk Pepperdine

  13. Keep the Build Clean
    by Johannes Brodwall

  14. Use Aggregate Objects to Reduce Coupling
    by Einar Landre

  15. WET Dilutes Performance Bottlenecks
    by Kirk Pepperdine

  16. Testing Is the Engineering Rigor of Software Development
    by Neal Ford

  17. Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly
    by Scott Meyers

  18. Don't Just Learn the Language, Understand its Culture
    by Anders Norås

  19. Small!
    by Uncle Bob

  20. Don't Nail Your Program into the Upright Position
    by Verity Stob

  21. You Gotta Care about the Code
    by Pete Goodliffe

  22. Know Your Next Commit
    by Dan Bergh Johnsson

  23. The Professional Programmer
    by Uncle Bob

  24. The Three Laws of Test-Driven Development
    by Uncle Bob

  25. Programmers Who Write Tests Get More Time to Program
    by Johannes Brodwall

  26. The Single Responsibility Principle
    by Uncle Bob

  27. The Longevity of Interim Solutions
    by Klaus Marquardt

  28. Prefer Domain-Specific Types to Primitive Types
    by Einar Landre

  29. Distinguish Business Exceptions from Technical
    by Dan Bergh Johnsson

  30. Don't Ignore that Error!
    by Pete Goodliffe

  31. The Boy Scout Rule
    by Uncle Bob

  32. A Comment on Comments
    by Cal Evans

  33. Don't Touch that Code!
    by Cal Evans

  34. Own (and Refactor) the Build
    by Steve Berczuk

  35. Deploy Early and Often
    by Steve Berczuk

  36. Understand Principles behind Practices
    by Steve Berczuk

  37. Acknowledge (and Learn from) Failures
    by Steve Berczuk

  38. Hard Work Does not Pay off
    by Olve Maudal

  39. Continuous Refactoring
    by Michael Hunger

  40. Scoping Methods
    by Michael Hunger

  41. Improve Code by Removing It
    by Pete Goodliffe

  42. Learn to Estimate
    by Giovanni Asproni

  43. Domain-Specific Languages
    by Michael Hunger

  44. Learn Foreign Languages
    by Klaus Marquardt

  45. Check Your Code First before Looking to Blame Others
    by Allan Kelly

  46. Two Wrongs Can Make a Right (and Are Difficult to Fix)
    by Allan Kelly

  47. Floating-point Numbers Aren't Real
    by Chuck Allison

  48. The Linker Is not a Magical Program
    by Walter Bright

  49. Beware the Share
    by Udi Dahan

  50. Consider the Hardware
    by Jason P Sage

  51. Data Type Tips
    by Jason P Sage

  52. Reinvent the Wheel Often
    by Jason P Sage

  53. Improved Testability Leads to Better Design
    by George Brooke

  54. From Requirements to Tables to Code and Tests
    by George Brooke

  55. Put the Mouse Down and Step Away from the Keyboard
    by BurkHufnagel

  56. Expect the Unexpected
    by Pete Goodliffe

  57. Continuous Learning
    by Clint Shank

  58. Don't Be Cute with Your Test Data
    by Rod Begbie

  59. Choose Your Tools with Care
    by Giovanni Asproni

  60. Decouple that UI
    by George Brooke

  61. Know Your Limits
    by Greg Colvin

  62. Do Lots of Deliberate Practice
    by Jon Jagger

  63. Code Is Hard to Read
    by Dave Anderson

  64. Simple Is not Simplistic
    by Giovanni Asproni

  65. Missing Opportunities for Polymorphism
    by Kirk Pepperdine

  66. Code in the Language of the Domain
    by Dan North

  67. Make the Invisible More Visible
    by Jon Jagger

  68. Ask "What Would the User Do?" (You Are not the User)
    by Giles Colborne

  69. Balance Duplication, Disruption, and Paralysis
    by Johannes Brodwall

  70. Methods Matter
    by Matthias Merdes

  71. The Golden Rule of API Design
    by Michael Feathers

  72. Don't Rely on"Magic Happens Here"
    by AlanGriffiths

  73. Prevent Errors
    by Giles Colborne

  74. Write Small Functions Using Examples
    by Keith Braithwaite

  75. Reuse Implies Coupling
    by Klaus Marquardt

  76. Hands on in All Phases
    by Klaus Marquardt

  77. Implicit Dependencies Are also Dependencies
    by Klaus Marquardt

  78. How to Access Patterns
    by Klaus Marquardt

  79. Code Layout Matters
    by Steve Freeman

  80. One Binary
    by Steve Freeman

  81. Beauty Is in Simplicity
    by Jørn Ølmheim

  82. Integrate Early and Often
    by Gerard Meszaros

  83. Write Tests for People
    by Gerard Meszaros

  84. Know Your IDE
    by Heinz Kabutz

  85. Structure over Function
    by Peter Sommerlad

  86. Message Passing Leads to Better Scalability in Parallel Systems
    by Russel Winder

  87. Know Well More than Two Programming Languages
    by Russel Winder

  88. Read the Humanities
    by Keith Braithwaite

  89. Code Is Design
    by Ryan Brush

  90. The Guru Myth
    by Ryan Brush

  91. Learn to Say "Hello, World"
    by Thomas Guest

  92. Don't Reinvent the Wheel
    by Kai Tödter

  93. Take Advantage of Code Analysis Tools
    by Sarah Mount

  94. Install Me
    by Marcus Baker

  95. How to Use a Bug Tracker
    by Matt Doar

  96. Use the Right Algorithm and Data Structure
    by JC van Winkel

  97. Who Will Test the Tests Themselves?
    by Filip van Laenen

  98. Write a Test that Prints PASSED
    by Kevin Kilzer

  99. There Is No Such Thing as Self-Documenting Code
    by Carroll Robinson

  100. Convenience Is not an -ility
    by Gregor Hohpe

  101. First Write, Second Copy, Third Refactor
    by Mario Fusco

  102. Display Courage, Commitment, and Humility
    by Ed Sykes

  103. A Message to the Future
    by Linda Rising

  104. Don't Repeat Yourself
    by Steve Smith

  105. Use the Same Tools in a Team
    by Kai Tödter

  106. Step Back and Automate, Automate, Automate
    by Cay Horstmann

  107. Declarative over Imperative
    by Christian Horsdal

  108. There Is No Right or Wrong
    by Mike Nereson

  109. Apply Functional Programming Principles
    by Edward Garson

  110. Talk about the Trade-offs
    by Michael Harmer