Forty for Forty

~ Sean Nolan

I really was born at exactly the right time to ride the golden age of computing. When I was in high school and college, computers were powerful enough to impact every corner of our world, but simple enough that actual humans could still develop a connection to the metal. I surfed those years straight into the cradle of 1990s computing — classic Macintoshes, Windows 3.0 and 95, the early Internet, Linux; so much great stuff and the perfect setup for twenty years trying to solve big problems in healthcare.

And so many incredible people, most of them way smarter than me. I do a fair bit of mentoring these days, and honestly 99% of is just sharing stuff others have taught me. I’m completely serious; my problem-solving toolbox basically boils down to imagining what somebody smart I’ve known would do. And it works great!

So I thought I’d share a few particularly valuable gems here — forty lessons for the (a few more than) forty years I’ve been in the game. I present each with minimal context — not quite bumper stickers but sometimes close. Attributions are real initials; feel free to make your guesses!

  1. It’s never the operating system. (DO)
  2. You can understand any system if you start with main. (BA)
  3. Design the object model first. (UM)
  4. Good code is fun to read. (JB)
  5. Don’t spawn that thread. (CC)
  6. When you’re stuck, just look again — eventually you’ll see it. (DS)
  7. If you’re fixing the most bugs, you probably wrote the most bugs. (BS)
  8. The worst case probably isn’t that bad. (BB)
  9. Comments lie. (DS)
  10. People don’t think asynchronously. (SN)
  11. Take your annual review seriously for one hour and then stop. (PK)
  12. Aircraft carriers turn slowly, but sometimes you need one. (PN)
  13. Meetings are a waste of time. (EJ)
  14. Perception is reality. (TL)
  15. You might actually be the smartest person in the room. (KC)
  16. Code Talks. (PK)
  17. Implement a memory manager once before you die. (JL)
  18. Walkthroughs are better testing than testing. (UM)
  19. Obvious to you isn’t obvious to everyone (so speak up). (PN)
  20. Don’t be clever. (JB)
  21. Never override a no-hire. (AC)
  22. If you don’t understand the details then you don’t understand. (BG)
  23. Have a single source of truth. (SN)
  24. There’s always one more bug. (RH)
  25. If you want to be a manager, you probably shouldn’t be one. (PK)
  26. Most problems can be solved with Excel. (GE)
  27. No secret lists. (LW)
  28. Honest != a$$hole. (KC)
  29. Adding more developers won’t help. (FB)
  30. Don’t lower your bet. (DN)
  31. How hard can it be? (JL)
  32. Outsourcing costs more than it saves. (SN)
  33. SQL is smarter than you think. (BD)
  34. Write it twice. (UM)
  35. Data wins debates. (TC)
  36. After a win, always take something off the table. (RN)
  37. Make it hard to do the wrong thing. (IA)
  38. Leaky abstraction is worse than no abstraction. (UM)
  39. It has to work first. (DK)
  40. Take the win, Sean. (AM)