I've said this enough times that people quote it back to me: programming is loops, sequences and decisions. Everything else is just abstraction from the truth. It sounds like a grumpy old engineer being reductive. It's actually a tool I use constantly, and it cuts deeper than it first appears.
The three primitives
Underneath every framework, language, and paradigm, a computer does only three kinds of thing. It does steps in order — a sequence. It repeats things — a loop. And it chooses between paths based on conditions — a decision. That's the entire instruction set of the universe, conceptually. Sort algorithms, neural networks, payroll systems, the browser rendering this page: all of it resolves, eventually, to sequences, loops, and decisions running very fast.
Everything we build on top — objects, functions, microservices, frameworks, the whole towering edifice — is abstraction. Layers of convenient fiction that let us think in bigger units without holding the primitives in our heads. Abstraction is wonderful. It's how we build things larger than one mind can contain. But it is, precisely, abstraction from the truth, and the gap matters.
Abstraction is a loan
Here's the part that's more than a slogan. Every abstraction is a loan against understanding. It lets you move fast now by not thinking about what's underneath — and the bill comes due the day the abstraction leaks, which it always eventually does. The ORM that generates a catastrophic query. The framework whose "magic" does something you didn't ask for. The library that's fine until the one case it wasn't designed for.
When that day comes, the only people who can fix it are the ones who can drop through the layers and see the loops, sequences, and decisions underneath. Everyone else can only file a ticket and hope. The abstraction didn't remove the complexity. It moved it somewhere you agreed not to look, and charged you interest.
Programming: loops, sequences and decisions. Everything else is just abstraction from the truth.
Why this is a manifesto idea, not just an engineering one
This connects to the whole philosophy, because the manifesto is suspicious of exactly this kind of comfortable distance. Methodology is an abstraction over working. Ceremony is an abstraction over collaborating. A milestone is an abstraction over progress. Each is useful and each, taken on faith, drifts away from the truth it was supposed to represent — until you're managing the abstraction instead of the thing.
"Go find out" is the instruction to drop through the layers. "It doesn't exist if it can't be tested" is a refusal to accept the abstraction's claim about itself without checking the substance. The scientific habit is, at root, a discipline of staying connected to the ground truth when every convenience is pulling you up into the comfortable fiction.
Stay close to the ground
I'm not arguing against abstraction. I'd get nothing done without it, and neither would you. I'm arguing for knowing it's there — for being the kind of practitioner who can use the high-level tool fluently and still drop to the primitives when it lies to you. Use the framework. Trust the abstraction. But keep a map of what's underneath, because the day it leaks, that map is the only thing that helps.
Loops, sequences, decisions. Everything else is a story we tell to make the truth easier to hold. Good stories. Just remember they're stories.
