My favorite1 ancient school of philosophy was the Stoics. Stoicism has enjoyed a resurgence in popularity recently, and deservedly so - many of their teachings about ethics, particularly their beliefs about happiness, have stood the test of time. If you pick up one of those new pop psychology books on happiness, it will probably tell you a lot of stuff the Stoics figured out two thousand years ago: happiness comes not from getting what you want but from appreciating what you have, live in the moment, realize everything changes, etcetera. Here is a great TED talk about modern research bearing out Stoic principals.

But I want to talk about the Stoics sage. The sage was someone who has obtained perfect wisdom. The sage lives in a constant state of tranquility, consistent with nature, and always acts virtuously. Obviously, no such person exists, and the Stoics admitted as much (they thought Socrates got pretty close). The sage acted as an ideal, one we always work towards knowing we will never reach it.

Practical application: You are sitting in a coffee shop, peacefully drinking your coffee and reading the paper, when someone walks past you on their way out the door and says “Your shoes look like garbage, you idiot.” OK - you probably want to tell this person to shove it and then throw your coffee on them. But you resist those urges and consider what the sage would do. They would consider the insult as the barking of a poorly trained dog - meaningless noise from something that doesn’t know better. It wouldn’t bother them one bit. Certainly a more positive outcome, right?

So I thought: what would a developer-sage look like? Can we construct an ideal model that we can try to become?

Behold: the ancient hoodie

Here are some of the characteristics of the developer-sage:

  1. Digs deep into the “why” of things to find the real problems. Then, tries to solve the problems, by writing code if it makes sense. Sometimes it doesn’t. Understands that some problems can’t be solved by code.
  2. Understands the limits of the mind and that the practice of software development is often a practice in minimizing the load on one’s brain.
  3. Does not over-represent their level of expertise or knowledge. Readily admits mistakes.
  4. Provides accurate status updates. If the sage says they are 90% done, and they have been working on the task for 9 days, they will be finished tomorrow. They will never says “It’s done except for writing the test cases” because they know the test cases are part of the task and they always write them first anyway :)
  5. Can effectively communicate complicated technical concepts to less technical people. Uses good metaphors. Never stoops to dazzling others with buzzwords or abstraction to avoid answering a hard question.
  6. If they are in a leadership position, understands the influence and authority they have over junior members of the team. Can review someone’s code and make them feel good about it.
  7. Is shameless - embraces honest feedback even if it is painful.
  8. Places greater value on knowing general principals than minutia of programming languages. Know that “10 years of experience with X” doesn’t mean much.
  9. Considers code to be community property.
  10. Does his work in such a way that he is replaceable. Considers “tribal knowledge” to be a problem.

Next time you are about to write a lazy commit message, ask yourself, what would lion-hoodie guy do?

1 Favorite as in, who’s teachings I find most applicable to my daily life. The coolest ancient school of philosophy was, of course, the Cynics, who thought everyone was full of shit and told them as much. Truly punk rock philosophers, complete with living in the streets. I’ll never be cool enough to be a Cynic.