Plato Was the First Backend Engineer
Plato’s theory of forms sounds like the most useless idea in philosophy until you’ve written enough code, and then it sounds like the only idea. The claim: the particular things we see — this chair, that circle drawn in sand — are imperfect copies of perfect, unchanging abstractions. The Form of Chair, the Form of Circle, living in some realm more real than the physical one. Every philosophy class presents this as charming nonsense. Every good abstraction layer you’ve ever written is a vote that Plato was onto something.
Here’s the connection. When you design a good interface, you’re doing exactly what Plato described. You’re separating the eternal pattern from the messy particulars. PaymentMethod is a Form. Card, bank transfer, stablecoin transfer — grubby instances, each with its own failures and edge cases and 3am surprises. The interface is the idea of the thing, clean and unchanging. The implementations are the shadows it casts into the dirty physical world of actual networks and actual money. Good engineers think in Forms without knowing it.
And the famous objection to Plato — where do these Forms even live, show me the Form of Chair — gets answered the moment you write software, because we build the Form’s realm on purpose. The abstraction doesn’t live in any one implementation. It lives in the type signature, the interface, the contract every implementation must satisfy. It’s realer than any concrete class in the sense that matters: it outlives them. Swap every implementation and the Form persists. Plato’s heaven of Forms is just a well-factored codebase, and we’re the gods who maintain it. Underpaid gods, but still.
But here’s where I part with the naive reading, and where the idea earns its keep instead of just being clever. Plato thought the Forms were primary and the particulars degraded copies — the abstraction came first and reality was a smudged photocopy. Every engineer who’s tried to design the perfect abstraction up front, before touching one concrete case, has learned the expensive way that this is backwards. The good abstraction is discovered from the particulars, not imposed on them. You implement three real payment methods, suffer their differences, and only then does the right interface reveal itself. Reach for the Form too early and you get a beautiful abstraction that fits nothing — a Form with no true instances, which is just a fantasy with a type signature.
So the deep lesson is dialectical, and it’s the actual craft. Forms and particulars need each other. Abstraction without grounding is astrology for programmers — elegant, self-consistent, attached to nothing. Particulars without abstraction is ten thousand special cases and a codebase no one can hold in their head. The skill — maybe the whole skill of senior engineering — is moving correctly between the two: extracting the Form when enough particulars have taught you its true shape, and not one case sooner.
Plato got the metaphysics exactly inverted and the intuition exactly right. There is a realm of clean eternal patterns above the mess. We just don’t find it by looking up at heaven. We build it, one hard-won abstraction at a time, by staring at the mess until the pattern underneath stops hiding. Then someone refactors it in a year and the Form ascends back to heaven. Such is the cycle.
One of a series of essays. I’m Prajjwal Chittori. prajjwalchittori.com.