The app on the dev environment is produced, and the app on prod is developed. So who the hell decided to call these two environments development and production?
The factory story..
Actually, the word was just there, and it was confused from day one. In 1956, Herbert D. Benington, in his paper Production of Large Computer Programs, used "production" for writing the SAGE programs. The same year, at General Motors, the first operating system for the IBM 704 "ran production", meaning it ran real jobs. One word, two opposite meanings, in the same year.
Then, in 1968, R. W. Bemer suggested General Electric build a "software factory". Once you call it a factory, the rest of the dictionary comes with it: production, pipeline, operations, release. And it's the second meaning that stuck, straight from the factory floor. In a factory, the production line isn't where things are designed or tested. It's the line making units that leave the building and reach real customers. So "production" never really meant the act of making. It meant making for the market.
And "development" doesn't fit any better. Develop comes from Old French desveloper: to unwrap. Same root as envelop, just the opposite. You develop a photo, you unwrap the image hidden in the film. So developing isn't building. It's unwrapping something that's still taking its shape. Which, honestly, describes prod just as well as dev.
So here we are. Two words, both borrowed, both blurry, and we put them on every namespace, every branch, every dashboard we own.
Let's get philosophical a little
Anyway, why did anyone split one environment into these two main ones? Why environments at all? A good name has to be self-describing. dev and prod are ok, but something still seems off..
At first, it seems like there was only one environment. In the 1950s, test jobs and real jobs ran on the same mainframe, fighting over the same scarce hours. By the 70s and 80s, companies that could afford it had a separate machine just for testing. So should we call dev test?
Think about that shared mainframe for a second. Your half-finished program and the company's payroll, in the same queue, on the same machine, touching the same tapes. One bad test run and it's not just your job that fails. It's everyone's paycheck. Somebody, somewhere, had that bad day.
So the reason that forced the split seems to be the blast radius of failure. Ok. But then why development and production? Let's flash back to the words. Develop is to unwrap: the thing is still being opened, still inside, only the team can see it. Produce comes from Latin producere: to lead forth, to bring something from behind into the open. So dev is in and prod is out. And out there, in front of everyone, is exactly where a failure hits the hardest. The words weren't that wrong after all. They just never said why.
As time passed, the factory production line was replaced by something else..
For a while, software actually had something like a real production line. You finished the app, pressed it onto floppy disks, then CDs, then DVDs, put it in a box and shipped it. Then the internet grew up, and the boxes disappeared. Nobody ships an app anymore. We serve it. The production line turned into a server: an nginx or an HAProxy sitting on a public IP, handing the app out to whoever asks. That public-facing door is what we call the production environment today. Not the place where things are made, but the place where they are served.
The boxes are gone, but we kept the split. Dev and prod, on every cloud, in every company, in every pipeline. But somewhere between the CDs and the public IP, we lost the reason. And when you lose the reason, all that's left is the name.
Think about what a bug meant in the CD days. It was pressed into thousands of copies, sitting in thousands of homes. You couldn't take it back. Nobody was going to collect the old CDs from every customer. You shipped a patch on another CD and prayed. Today? git revert, redeploy, done in minutes. The blast radius of a bad release went from forever to one rollback.
So if prod isn't a production line anymore, what is it? It's the place that's live: out in front of people, served, happening right now. And dev? It's a sandbox: still inside, still wrapped, safe to break. Honestly, sandbox and live say more about why they exist than dev and prod ever did.
Why did it all matter anyway?
Because a good name documents itself. When a name tells you why a thing exists, nobody has to ask, nobody has to look it up, and nobody has to translate it in their head. Less noise, fewer questions, no extra translation between what you read and what you mean.
So should we all rename to sandbox and live tomorrow? No. dev and prod are the defaults. They're in every tool, every tutorial, every label selector and every engineer's muscle memory. You can't force the whole world to switch words, and changing a culture takes real effort. And honestly, the old words aren't completely wrong. Dev is still in. Prod is still out.
And maybe there's something nice about keeping them. Every time you type prod, it reminds you that the microservice you're maintaining right now has a factory in its family tree, not just a VM or a container. A production line, a box with a CD in it, a customer waiting on the other side.
So keep dev and prod. Just know what they mean.
References
- Herbert D. Benington, Production of Large Computer Programs (1956 symposium paper)
- Software Preservation Group, Operating Systems at Conception (GM-NAA I/O on the IBM 704)
- Software Factories (on R. W. Bemer's 1968 proposal)
- Preproduction Deploys: Cloud-Native Integration Testing (on physically separate test and production environments)
- Etymonline, develop
- Wiktionary, produce
Top comments (0)