I keep a foot of wire in my pocket to remind people how far light travels in a billionth of a second. I hand it to young officers and young programmers alike, because both tend to think of computers as mysterious oracles rather than machines that follow orders — fast orders, but orders all the same. Concurrency is no different. The moment people hear that a computer can do two things "at once," they start treating it like magic instead of arithmetic. My job, for forty years, has been to take the magic out of machines so people can actually use them.

When I worked on the UNIVAC and later pushed for the compiler, the resistance I got was always the same: real programmers write in machine code, they said, and anything that translates English-like instructions into machine instructions is a toy. I didn't agree. A compiler is simply a translator, and a good translator makes complicated ideas usable by people who have better things to do than memorize a machine's dialect. That's exactly the problem with concurrent operations. Running two processes side by side isn't conceptually hard — a Navy convoy does it every day, ships keeping station, each captain making decisions independently, all of them converging on the same port at the same time without radioing each other for permission before every turn of the wheel. The hard part is that we've let the machine's internal bookkeeping leak into the language the programmer has to think in. That's backwards. The language should describe the task — "do this, do that, bring the results together" — not force the programmer to narrate the machine's wiring.

That's why I pushed so hard for machine independence in COBOL. People assumed that if you wrote instructions in something resembling English, you'd lose precision or speed. Nonsense. What you lose is needless confusion, and what you gain is a program that can run on a different machine without the programmer rewriting the whole blessed thing. Apply that same logic to concurrent work. If a language forces every programmer to understand the particular timing quirks of a particular processor's particular way of juggling tasks, you've built something fragile and unteachable. You've made the computer's problem into the human's problem, and that's exactly the habit I spent my career trying to break.

I'll admit, when multiprocessor machines started appearing in earnest — Illiac IV and the like, built to chew through many calculations simultaneously — a lot of very smart engineers treated the whole business as an exotic specialty, fit only for a priesthood who understood the hardware down to the transistor. I've heard that tune before. It's the same tune people hummed about compilers in 1952. The answer then was the same as it is now: build the abstraction, test it mercilessly, and trust that programmers are capable of thinking clearly about "run these together and gather the results" without needing a degree in the specific wiring of the box in front of them. A ship's navigator doesn't need to understand celestial mechanics to use a sextant correctly. He needs a reliable tool and clear training.

So if you ask me how to make concurrent programming intuitive in any language, I'll tell you what I told the Navy and what I told every young ensign who thought FORTRAN was as plain as English could get: stop designing for the machine's convenience and start designing for the human's understanding. Give people a vocabulary that matches how they already think about parallel tasks — convoys, relay teams, work crews — and let the compiler worry about the nanoseconds. We didn't win the translation argument by making machines smarter. We won it by refusing to accept that complexity was something ordinary people simply had to live with.