97 Journey Every Programmer should Accomplish

Birat Rai
4 min readSep 20, 2017


“A journey of a thousand miles begins with a single step.”

~ Lao Tzu

Life is a journey, not a destination”, programming is also a journey, not an end product. As we begin this journey from a novice programmer towards more accomplished professional, we learn through our mistakes, practice and programming enlightenment.

This is an effort to make traversing of this journey in sweet small steps. I have tried to learn and share 97 Things Every Programmer Should Know into byte sizes.

I am making a promise to my self, to learn the pearls of wisdom discussed in the book each day until my 97th day. Hope you can add few hours for the “10,000-Hour Rule” and accompany in this programming pilgrimage.

Below are the 97 programming path to attain the nirvāṇa.

“Do or Do Not. There is No Try” ~ Yoda
  1. Act with Prudence ~ Edward Garson
  2. Apply Functional Programming Principles ~ Edward Garson
  3. Ask, “What Would the User Do?” (You Are Not the User) ~ Giles Colborne
  4. Automate Your Coding Standard~ Filip van Laenen
  5. Beauty Is in Simplicity ~ Jørn Ølmheim
  6. Before You Refactor ~ Rajith Attapattu
  7. Beware the Share ~Udi Dahan
  8. The Boy Scout Rule ~Robert C. Martin (Uncle Bob)
  9. Check Your Code First Before Looking to Blame Others~Allan Kelly
  10. Choose Your Tools with Care ~ Giovanni Asproni
  11. Code in the Language of the Domain ~Dan North
  12. Code Is Design ~ Ryan Brush
  13. Code Layout Matters ~ Steve Freeman
  14. Code Reviews ~Mattias Karlsson
  15. Coding with Reason ~ Yechiel Kimchi
  16. A Comment on Comments ~ Cal Evans
  17. Comment Only What the Code Cannot Say ~ Kevlin Henney
  18. Continuous Learning ~ Clint Shank
  19. Convenience Is Not an -ility ~ Gregor Hohpe
  20. Deploy Early and Often ~ Steve Berczuk
  21. Distinguish Business Exceptions from Technical ~Dan Bergh Johnsson
  22. Do Lots of Deliberate Practice ~Jon Jagger
  23. Domain-Specific Languages ~ Michael Hunger
  24. Don’t Be Afraid to Break Things ~ Mike Lewis
  25. Don’t Be Cute with Your Test Data ~ Rod Begbie
  26. Don’t Ignore That Error! ~ Pete Goodliffe
  27. Don’t Just Learn the Language, Understand Its Culture ~Anders Norås
  28. Don’t Nail Your Program into the Upright Position ~Verity Stob
  29. Don’t Rely on “Magic Happens Here” ~ Alan Griffiths
  30. Don’t Repeat Yourself ~ Steve Smith
  31. Don’t Touch That Code! ~ Cal Evans
  32. Encapsulate Behavior, Not Just State ~ Einar Landre
  33. Floating-Point Numbers Aren’t Real ~Chuck Allison
  34. Fulfill Your Ambitions with Open Source ~ Richard Monson-Haefel
  35. The Golden Rule of API Design ~Michael Feathers
  36. The Guru Myth ~Ryan Brush
  37. Hard Work Does Not Pay Off ~Olve Maudal
  38. How to Use a Bug Tracker ~ Matt Doar
  39. Improve Code by Removing It ~Pete Goodliffe
  40. Install Me ~ Marcus Baker
  41. Interprocess Communication Affects Application Response Time ~Randy Stafford
  42. Keep the Build Clean ~Johannes Brodwall
  43. Know How to Use Command-Line Tools ~Carroll Robinson
  44. Know Well More Than Two Programming Languages ~Russel Winder
  45. Know Your IDE ~Heinz Kabutz
  46. Know Your Limits ~ Greg Colvin
  47. Know Your Next Commit ~Dan Bergh Johnsson
  48. Large, Interconnected Data Belongs to a Database ~Diomidis Spinellis
  49. Learn Foreign Languages ~Klaus Marquardt
  50. Learn to Estimate ~ Giovanni Asproni
  51. Learn to Say, “Hello, World” ~ Thomas Guest
  52. Let Your Project Speak for Itself ~ Daniel Lindner
  53. The Linker Is Not a Magical Program ~Walter Bright
  54. The Longevity of Interim Solutions ~Klaus Marquardt
  55. Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly ~ Scott Meyers
  56. Make the Invisible More Visible ~Jon Jagger
  57. Message Passing Leads to Better Scalability in Parallel Systems ~Russel Winder
  58. A Message to the Future ~Linda Rising
  59. Missing Opportunities for Polymorphism ~ Kirk Pepperdine
  60. News of the Weird: Testers Are Your Friends ~Burk Hufnagel
  61. One Binary ~ Steve Freeman
  62. Only the Code Tells the Truth ~ Peter Sommerlad
  63. Own (and Refactor) the Build ~Steve Berczuk
  64. Pair Program and Feel the Flow ~Gudny Hauknes, Kari Røssland, and Ann Katrin Gagnat
  65. Prefer Domain-Specific Types to Primitive Types ~Einar Landre
  66. Prevent Errors ~Giles Colborne
  67. The Professional Programmer ~ Robert C. Martin (Uncle Bob)
  68. Put Everything Under Version Control ~Diomidis Spinellis
  69. Put the Mouse Down and Step Away from the Keyboard ~Burk Hufnagel
  70. Read Code ~Karianne Berg
  71. Read the Humanities ~Keith Braithwaite
  72. Reinvent the Wheel Often ~Jason P. Sage
  73. Resist the Temptation of the Singleton ~Sam Saariste
  74. The Road to Performance Is Littered with Dirty Code Bombs ~Kirk Pepperdine
  75. Simplicity Comes from Reduction ~Paul W. Homer
  76. The Single Responsibility Principle ~Robert C. Martin (Uncle Bob)
  77. Start from Yes ~Alex Miller
  78. Step Back and Automate, Automate, Automate ~Cay Horstmann
  79. Take Advantage of Code Analysis Tools ~Sarah Mount
  80. Test for Required Behavior, Not Incidental Behavior ~Kevlin Henney
  81. Test Precisely and Concretely ~Kevlin Henney
  82. Test While You Sleep (and over Weekends) ~Rajith Attapattu
  83. Testing Is the Engineering Rigor of Software Development ~ Neal Ford
  84. Thinking in States ~Niclas Nilsson
  85. Two Heads Are Often Better Than One ~Adrian Wible
  86. Two Wrongs Can Make a Right (and Are Difficult to Fix) ~Allan Kelly
  87. Ubuntu Coding for Your Friends ~Aslam Khan
  88. The Unix Tools Are Your Friends ~Diomidis Spinellis
  89. Use the Right Algorithm and Data Structure ~Jan Christiaan “JC” van Winkel
  90. Verbose Logging Will Disturb Your Sleep ~Johannes Brodwall
  91. WET Dilutes Performance Bottlenecks ~ Kirk Pepperdine
  92. When Programmers and Testers Collaborate ~Janet Gregory
  93. Write Code As If You Had to Support It for the Rest of Your Life ~Yuriy Zubarev
  94. Write Small Functions Using Examples ~Keith Braithwaite
  95. Write Tests for People ~ Gerard Meszaros
  96. You Gotta Care About the Code ~ Pete Goodliffe
  97. Your Customers Do Not Mean What They Say ~Nate Jackson