A couple weeks ago, Jeremy mentioned that John Flatness, the lead developer on Omeka at CHNM, likes to measure his productivity by the number of lines of code that he deletes in a day. This is fascinating, and, in a practical sense, deeply wise. But it also points at a fundamental question about programming:
Are programmers fundamentally creators or mitigators of complexity?
On the one hand, code is complexity – any formalization of process, no matter how simple, is always more complex than no process at all. Programmers exist to produce these expressions of process.
But process is problematic. Code is fundamentally volatile, and always on the cusp of incomprehensibility. How many lines of code are you really able to meaningfully hold in your head at once? Maybe lines of code is a bad metric. What’s the most complex intellectual apparatus that you’re able to “compile” in your mind and manipulate as a mirror of the codebase as you work? When I work, I imagine a vast physical structure, hanging in a black void – a bundle of tubing that wires up a constellation of colored nodes. But only so much complexity can be booted into working memory – sooner or later the stack overflows, things fall apart, and I loose control. The code spills over into a chaos that I’m not smart enough to master.
Programming is distilled complexity, but complexity is also a programmer’s great foe. The programmer is in the business of system-making, of creating a fresh, brand-new, whirring little mechanism out of nothing. But the programmer’s real objective, in the hoary thick of the codebase, is often to destroy complexity, to achieve the dream of a Perfect System.
What’s the Perfect System? It’s the completely intuitive, infinitely maintainable, and inevitable expression of what we intend. I use “inevitable” in the poetic sense of the concept. We dream of being conduits for applications that unfold themselves, line by line, to form sublime and un-refactorable codebases, final executions that can’t be changed without being degraded.
Of course, we always build fallen systems. They have bugs. They compromise. What’s the closest we can imagine, though? I immediately think of concise, direct implementations of clever algorithms. Really, though, this is an asymptotic thought – the closest thing I can imagine to Perfect System is an infinitely small system. Take the limit of that sentiment, though, and the closest imaginable thing to the Perfect System is no system at all.
Freud thinks of life as a circular movement that loops from a state of non-life before birth back to a state of non-life after death. Forward movement along that line (everything we do as living things, essentially) is overdetermined – it’s both a move away from nothingness and towards nothingness. We quest through life, climbing further and further from away from the horrible nullness of not being alive, but always dreaming of a final discharge of all the chaos and anxiety of the world, a return to the original state of zero-entropy.
Programming is much the same, I think – death is the black, empty vim buffer, and we strike outward from the void. We fill the screen, striving upwards and away towards an embodiment of purity and sustainability that only exists in the absence of code, in the non-system, in deleting all the lines.