Sym - 一个用 Java 实现的现代化社区平台 • 源码注册

Pipe - 小而美的开源博客平台 • 体验皮肤
Solo - 一个用 Java 实现的博客系统,为你或你的团队创建个博客吧! • 源码下载
Wide - 一个基于 Web 的 Go 语言 IDE • 教程试用

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