97 Journey Every Programmer should Accomplish

“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.

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

References:

• 97 things Every Programmer Should Know ~ Git Book
• 97 Things Every Programmer Should Know ~ Paperback