Multilingual Programming Infrastructure

"The tools we use have a profound (and devious!) influence on our thinking habits, and, therefore, on our thinking abilities."

— Edsger Dijkstra

I have a bad habit. When I get properly stuck on a problem, I stop trying to solve it and start trying to rewrite it in a different language.

Not a different natural language — a different programming one. And most of the time nothing happens, and I've wasted an afternoon. But every now and then something strange occurs: the problem doesn't get solved so much as it stops existing. It dissolves. What was a tangle of nested loops and mutable state in Python becomes, in a constraint solver, three lines of declared facts and a question mark. I didn't get smarter. I changed the shape of the container, and the water took a different form.

This experience is common enough among programmers that it's almost a cliché, and yet we've built an entire civilization of software that pretends it isn't true.

The Funnel

For most of computing's history, the stack has been a funnel.

At the top, a Cambrian profusion: hundreds of languages, each with its own theory of what a computation is. Lisp says a program is a list that can rewrite itself. Prolog says a program is a set of truths and the machine's job is to search. APL says the atom of thought is not the number but the array. Erlang says everything is a process, processes die, and the interesting question is not how to prevent death but how to supervise it. SQL says: describe what you want; the how is none of your business.

These are not syntactic variations. They are different ontologies. They carve the world at different joints.

And then, one layer down, all of it gets flattened. Compiled, transpiled, lowered into an intermediate representation, and finally into instructions for a machine that fundamentally believes in one thing only: fetch, decode, execute, repeat. The von Neumann grammar. Everything that made Prolog Prolog survives as a residue — a performance characteristic, a memory profile — but the worldview evaporates at the first translation boundary.

This was a reasonable engineering decision for seventy years. Silicon was scarce, compilers were hard, and the funnel was how you got leverage. But we should be honest about the cost: we built infrastructure that is polyglot at the surface and monolingual at the core. Many dialects, one mind.

And infrastructure has a way of becoming destiny. What is easy to build gets built. What gets built defines what the next generation thinks is normal. Within two decades, the funnel produced a world where roughly everyone codes in imperative languages with C-shaped braces, and a whole generation of very capable engineers cannot think declaratively — not because they're incapable, but because they've never had to. Grammar you don't use, you lose.

The Great Translator

Now enter the machines that talk.

Large language models are the most powerful translation devices ever constructed. They translate English into Python, Python into Rust, a rambling Slack message into a technical spec, a technical spec into a test suite. The friction of moving between languages, which was the main tax that kept the funnel narrow, is collapsing.

This should be the great multilingual moment. Finally, we can move fluidly between world-models, picking the right one for each problem, and let the machine handle the boring translation.

Except that's not what's happening, and the reason is worth staring at.

Every translation has a direction. And in this case the direction is overwhelmingly from English, through a probability distribution shaped by GitHub, into Python or TypeScript. That's the highway. Everything else is a dirt track. Ask a model to write you a Prolog solution and it will comply, politely, badly, in the manner of someone who took two semesters of a language twenty years ago. Ask it to write Python and it will write Python that is better than yours.

So the great translator is also the great homogenizer. It makes every language accessible while making one language inevitable. Not by decree, but by gradient. Water flows downhill, and the hill has been shaped by the training corpus.

I don't think this is a conspiracy. I think it's just what happens when you build a translation layer without building a preservation layer.

The Seed Vault

Farmers figured this out the hard way. Monoculture is spectacularly efficient right up until the blight arrives. The Irish potato was a single clone. The Cavendish banana is a single clone, currently being eaten alive by a fungus, exactly as its predecessor the Gros Michel was. So we built the Svalbard Global Seed Vault: a cold room in the Arctic holding a million varieties nobody currently plants, because the point of diversity is not that it's useful today. The point is that you cannot know in advance which variety will save you.

Conceptual diversity works the same way. The Guugu Yimithirr people of Queensland don't say "left" and "right" — they use absolute compass directions for everything, including which hand to hold a cup with. As a consequence, they possess a permanent, effortless sense of orientation that speakers of European languages simply do not have. Not because their brains are different. Because their grammar makes a certain kind of attention mandatory.

Programming languages do the same to us. "Let it crash" is not a technique you can port to Java. It's a grammar. You need a runtime where processes are cheap and death is expected, and once you have that, a whole class of resilience patterns becomes not just possible but obvious. Take away the grammar and the thoughts don't survive the trip.

So what would a genuinely multilingual programming infrastructure look like? Four properties come to mind:

1. No universal intermediate representation that flattens semantics. Let each language own its worldview all the way down to metal where possible. Heterogeneous runtimes, not one ring to rule them all.
2. Visible seams. When you translate between paradigms, the system should tell you what was lost. A diff of meaning, not just of syntax. Right now translation is silent, and silent loss is how monocultures form.
3. Rewarded round-trips. Translate the idea out and back, and inspect the residue. What doesn't survive the journey is exactly the thing worth knowing about.
4. Deliberate cultivation of minority languages. Not for nostalgia. As a seed vault. Fund the weird compilers. Train models on the tiny corpora. Keep the grammar alive in enough working systems that it can be revived when the blight comes.

Why It Matters

None of this is really about programming.

Infrastructure is where language stops being talk and becomes matter — pipes, protocols, defaults, the shape of the form field that will not accept your surname. It is the sediment of past thoughts and the riverbed for future ones. When we decide which languages get to survive all the way down to execution, we are deciding, quietly and mostly by accident, which thoughts our grandchildren will find easy and which will feel like swimming upstream.

We are about to hand enormous amounts of this decision to a translation machine trained on a snapshot of one moment in one corner of one culture's engineering practice.

That machine is not evil. It's just very, very good at going downhill.

Our job, then, is to keep some hills.

On the off chance you'd like to subscribe to my writing, please feel free to subscribe on twitter or use this RSS feed. Thank you.