The Gospel of Evan: a not true dao of development

These are a few meditations– parables, precepts– I’m collecting– snipping, stealing– to capture the vague & provisional learnings I’ve had working in the software industry. It’s a “gospel” because, well, everyone is either preaching or selling you snake-oil– lean into it, write your own gospel, what’s the worst that could happen?

  1. Have a mission.

  2. Respect & learn from your ancestors.

  3. Aim for utmost minimalism at your public interface. Aim for minimalism in everything, especially this one.

  4. Learn to design both bottom-up and top-down, and when which is more appropriate.

  5. Stateless > Stateful, but at EOD someone has to own that state. Who/what it is matters. Related to Tesler’s law.

  6. Algorithms > Micro-optimizations, but this is easy to forget because…

  7. … It’s hard to visualize the whole scope of the algorithm or system. Use (& build your own!) tools which increase observability.

  8. Keep digging until you find the small kernel which makes the entire thing work. Wind and time may have scattered it far & wide.

  9. DRY, yes, but it’s ok to repeat yourself a couple times until you’re sure it’s the same. When you have three examples of the same thing, try extracting the same part, & pay attention to naming in this extraction. Do the names fit? Why/why not? Just because it has the same shape doesn’t mean it has the same semantics.

  10. Usually there is an underlying logic to even the worst code. Understanding that veiled intent may be the key to not repeating its mistakes. There may not be tho! Look for naming consistency & authorial drift. If you’re pretty sure there isn’t, rewrite that crap ASAP.

  11. Getting shot in the foot is the best way to learn someone is holding a foot-gun. Maintenance is a great way to learn. Prefer shooting yourself to other people, if possible.

  12. HN & StackOverflow are not great resources for learning about systems. Work on a variety of different code bases & types of systems.

  13. Learn a Lisp. There are other ways to get the same thing, but in one fell stroke you can:

    a. Get a better understanding of code-as-data-as-code

    b. Learn how wonderful true in-editor REPL, bottom-up development is

    c. Be able to read a ton of foundational CS papers in their source language

    It’s also very rare to see long functions in Lisp code — this is the kindof minimalism I’m striving for.

  14. Naming is, of course, the most important thing. But why is it important? So the reader and writer— you and your reviewer, you and future you— can be as sure as possible you are sharing the right metaphors. It’s always dialectic.

  15. Software is communal. Introducing a new paradigm involves education, and you should consider trade-offs inherent in whether the new paradigm will sufficiently supplant the old. Consistency and coherence have to be balanced against the need to have the newest & shiniest.

  16. Programming is an aesthetic act. You are an extravagantly well-paid artist. Have fun with it! Make it beautiful. Or don’t! It’s your art.

  17. Don’t be an asshole. It’s hard not to get attached to ones’ art. So far, tho, only humans maintain code.

  18. We’re always choosing the metaphors we live by, & our career is writing executable metaphors. We need a more and better variety of them, ideally compatible ones, a whole society of functional metaphors. We employ the industrial ones too often— builder, adaptor, factory. We need more pre/post-industrial ones— they’re more powerful. The company is named “Oracle” for a reason.

  19. Try to maximize optionality. (h/t Heinz von Foerster, Nassim Taleb)

  20. Code the shortest path thru the hardest problem first.