We live in a dark void where there are no clear and praised examples of good software
What is your go-to example of good code? Do you think of the C++ standard template library? Do you think about the virtually bug-free code in TeX, the typesetting system by Donald Knuth? Do you think about the Apollo 11 code, that is, the code that took astronauts to the moon?
When we finally come across examples of good software, we judge them harshly. We denigrate some for not being clever enough. Others we judge as not being realistic situations, and we classify them as toy examples. We discard some as merely simple, as if simplicity wasn’t something we strive for every day. We forget all the effort behind our best successes in the grind to reduce complexity. We forget to ask how it got to be so simple. We fear complexity and yet wear it as a badge of honour.
The same happened in architecture when modern architects started to look down on constructions that were objectively good for the occupants. They began to care more about the impression they gave and less about how well they served those who were to dwell inside. We slowly pushed aside good examples of houses and offices in favour of novelty and expression.
The remaining bastion of purpose-validated construction seems to be agricultural and industrial buildings. We make them safe and productive, aiming for minimal upfront investment and low maintenance costs. They are not traditionally beautiful due to their need to produce goods being prioritised over the comfort of their workers. Still, even the most mundane industrial plant has a sense of honesty and wholeness that is missing from so many of modern architecture’s multifarious creations.
Many years from now, I hope future generations of programmers can look back on old code and pick the good from the bad. I want them to have the wisdom to tell what makes a good codebase good. I hope they discern better than those who disdain the simple and uncomplicated solutions that offer instant readability over clever layers of flexibility. The situation we presently find ourselves in feels like the school of modern architecture, where we expect enterprise-level solutions at all levels. Otherwise, they are looked upon with suspicion.
One day, I hope those building up their complexity will see how the rule of scale shows they were building too large a language in one layer. I hope they find a way to extract themselves from the treadmill of fighting back against inherent complexity caused by putting all the different levels of abstraction in the same layer of their project.
Until that day, we are limited to writing good code despite these abnormal ideals. We can push back and claim we’re not smart enough to review their code to avoid the creeping complexity and unnecessary future-proofing. Or just point people to TeX.