Programming is complicated! Software stacks are deep, layered, and complex. Human cognitive abilities, time, and energy are limited. And then the central question for each programmer wrestling with this situation becomes: how can we be productive in this endlessly complex computing universe?
The answer is deceptively simple: hide complexity behind abstractions! Hide complexity behind walls of public interfaces. Layer these kinds of abstractions one onto another as a kind of stack, and you get the modern computing world. Layer upon layer. Each allows us to live in blissful ignorance and to be productive without knowing every layer that sits below or above us!
These boundaries are “epistemic,” not physical. They allow us to use the ls command without knowing anything about syscalls. They allow you to write a full-fledged Python program without ever knowing about C or CPU instruction sets—or, God forbid, assembly. They allow you to make a request and never know what is going on between the moment you send it and when you receive a nicely formatted JSON response.
And this has been the main strategy we have used to tame computing complexity all these years. A very successful recipe—just look at the world around you.
Of course, as you may guess at this point, the main enemy of this new computing order is the “leaky abstraction.” An abstraction that allows internal problems to escape into the outside world and confuse our good programmers, who stare at errors as if they were written by some alien intelligence! A sure sign that they are confronting things produced by something non-terrestrial! Strange words, never-heard-before terms—signals of new territory.
And then we are forced to acknowledge that there is a whole underworld beneath us, with its own mechanisms and complexities.
But this pattern is not unique to programming.
Scientific disciplines are exactly the same move. Physics, chemistry, biology, psychology, sociology—these aren't natural categories carved at the joints of reality. They're epistemic partitions imposed because no single human mind can reason from quarks to civilizations in one pass. A biologist studies cell signaling without solving Schrödinger's equation for every electron involved. A sociologist studies institutional behavior without modeling individual neurons. Each discipline is an abstraction layer that says, “you can reason productively at this level without understanding the level below.”
And the interfaces between disciplines work the same way as APIs. Chemistry exposes a certain contract to biology—“here’s how molecules bond, here are reaction kinetics”—and biology consumes that interface without caring about quantum mechanics. The contract is: these regularities hold at your level. Don’t look underneath unless something breaks.
The leaky abstraction problem exists in science too. That’s literally what happens at interdisciplinary boundaries. A biologist hits a problem that can't be solved with biological vocabulary alone—suddenly you need biophysics, or biochemistry. The epistemic boundary has leaked. You're forced into that same cognitive expansion across two worlds, exactly like a Python developer suddenly staring at C segfault traces.
This human way of wrestling with complexity is a hidden assumption and organizing principle of everything we build. Epistemic partitions are how complexity becomes digestible for our limited cognitive abilities. But now the big question is: what happens when those cognitive limitations are no longer the organizing principle? When they are lifted via AI?
Will we start to see entirely new type of systems and understanding emerging in a way fundamentally different from the layered abstraction model that human cognition demanded?
Top comments (0)