The Tower of Babel

In the biblical story of Babel, humanity united to build a tower so tall it would reach the heavens. This was, of course, blasphemy. The divine punishment was to break apart the people, who were working in harmony in the same language, and scatter them to separate places with incompatible languages. In a sense, though, punishment is the wrong word; it was a strategic action. The reason the builders were separated was because they were too powerful together. Their shared language and shared effort made them powerful enough to challenge the gods.

In the early days of computers, everything was just written in the machine language of the machine you ran it on. In a way, there was no meaningful difference between your code and anyone else's; it was all just instructions in one place. Later on, when we invented the first programming languages, it was often still necessary to modify the code to make it work on your computer. Source code in those days was shared, not because of any ideological attachment to open source, just because it was more practical. The idea of distributing binaries hadn't really been invented.

I can only imagine what it was like in the early days of Unix. Multiple people collaborating on a single machine for the first time, modifying each others' code, building the universe from the inside, making up the rules as they went. Back then there was no part of the system that was off limits, no part that wasn't yours. When Doug McIlroy came up with the idea for pipes, Ken Thompson wrote them into a bunch of major utilities that evening, and the next day Unix had pipes, simple as that. Who today can come up with a new idea and implement it in their favourite software that evening? How did we lose that power?

At some point our work fractured, like the tribes of Babel, into thousands of different individual efforts, each isolated from the others. People lost the ability or the desire to modify each others' code, and just wrote their own code around or on top of it. And with that we lost the ability to go middle-out: to make the whole system better by solving problems from end to end. Instead of fixing our mistakes, we built on top of them over and over again, constructing something much less like a tower than a rubbish dump. The fact that we are still using the same metaphors, the same systems, the same tools that were invented in the 70s at Bell Labs is at once a testament to their vision and a condemnation of our own.

And the worst thing is, this is all computing's fault. The transcendent part of computer science is universal computation: you can make a computer out of anything that passes a fairly low bar of complexity, and that computer can do anything that any other computer can do. I can make a computer out of transistors, sure, but also out of cogs, steam valves, or a mechanical loom. It really doesn't matter what the materials are; once you cross that threshold you're in for the whole thing.

The dark and terrible consequence of this is that if your current computing environment sucks, instead of fixing it, you can just build a new computer out of it. Remember, anything complex enough can be a computer, and that's equally true of knitting as it is of a crappy programming language, framework or operating system. You don't need to fix it, you can just build on top of it.

But by going so often to this well, we have babelised ourselves. Each of these sub-environments we have built exists in its own universe, separate from the others. Today it's commonplace, even expected, that if you are working with some external code you treat it as a black box; if it doesn't work the way you expect, don't change it, just build a layer on top of it. But we're smothered in layers, divided by them, isolated by them. If we ever hope to return to those halcyon days, to build our Tower of Babel that can challenge the gods, we need to come together again.