I did not get into technology for a career. I got into it because I wanted to know how things worked. And in the early 90s, if you were a kid with a computer, the things you wanted to understand were games.

Type "Open Door"

If you grew up on Sierra games, you know the drill. King's Quest. Space Quest. Police Quest. Leisure Suit Larry, if your parents weren't paying attention. These games didn't hand you anything. You typed commands into a parser and hoped the game understood you.

"Look at tree." "Climb tree." "Take egg."

That parser was brutal. It wanted exact words in an exact order. Type the wrong verb and you got nothing. Type the right verb at the wrong time and you died. Sierra loved killing you.

Here's the thing nobody realized at the time: that parser was teaching us syntax. It was teaching us that computers are literal. That the machine does exactly what you tell it, not what you meant. That precision matters and vagueness fails.

That is programming. That is the whole job. The parser was a compiler with a sense of humor.

Before the Game Even Started

Sierra games taught you more before you ever saw the title screen. To play a DOS game in the early 90s, you had to earn it.

You edited CONFIG.SYS and AUTOEXEC.BAT by hand. You learned the difference between conventional memory, extended memory, and expanded memory because Space Quest IV would not run without enough of the right kind. You made boot disks. You figured out IRQ settings so your Sound Blaster would make noise. You memorized DOS commands because there was no other way to move around your own machine.

None of that felt like learning. It felt like the price of admission. But it built something real: a mental model of how a computer actually works. Files, memory, drivers, hardware. You knew what was under the hood because you had to reach in and touch it just to play a game.

Then Came the BBS

Somewhere in there, I set up a BBS in my house. One phone line, a modem, and a piece of software that turned my computer into a place other people could visit.

If you never experienced a BBS, here is the short version. People dialed your phone number with their modem. One at a time, because you had one line. They left messages, played door games, uploaded and downloaded files.

TradeWars 2002 was the big one for me. If you know, you know. A space trading game rendered entirely in ANSI text, played in daily turns, one caller at a time. You hauled cargo between ports, built up your ship, planted colonies, and schemed against everyone else on the board. Somebody would blow up your fighters overnight and you would spend the whole school day plotting revenge. Alliances formed. Alliances got betrayed. All of it playing out over weeks on a single phone line in my house.

Running the TradeWars game was its own education too. As the sysop I managed the game settings, reset the universe when it got stale, and watched how a handful of rules could create an entire economy and a social scene around it. That is systems thinking. I just thought it was fun.

Running a BBS meant you were not just a user anymore. You were the operator. You configured the software. You managed the file areas. You dealt with the kid who kept tying up the line. You learned what happens when your system goes down and people notice.

That was my first taste of running infrastructure. I did not know to call it that. But it was the same job I do today, just smaller. Something you built, that other people depend on, that has to work.

Why That Era Made Programmers

The early 90s had a specific magic to it, and it was not nostalgia. It was friction.

Computers back then were transparent by necessity. There was no app store. There was no "it just works." Everything you did required understanding a layer below the thing you actually wanted. Playing a game required understanding DOS. Running a BBS required understanding modems and serial ports. Copying a game from a friend required understanding disks and file systems.

The gap between "using a computer" and "programming a computer" was tiny. You were already in the terminal. You were already editing config files. Writing a batch file was a small step. Writing a QBasic program was one more. The machine invited you in because it had no way to keep you out.

Games were the motivation. Curiosity was the fuel. Friction was the teacher.

What's Out There for Kids Today

So here is the question I get, usually from parents: computers are sealed boxes now, phones even more so, so where does a kid get that same experience?

The good news is the on-ramps still exist. They just look different.

Minecraft is the BBS of this generation. Kids run their own servers. They install mods. They write command blocks and redstone logic, which is genuinely circuit design whether they know it or not. A kid managing a Minecraft server for their friends is doing exactly what I did with my BBS. Infrastructure, users, uptime, drama and all.

Roblox is where kids ship products. Say what you want about the platform, but kids are building actual games in Lua, publishing them, and watching real people play them. That feedback loop of build, ship, see people use it, fix what broke, is the whole job compressed into something a ten-year-old can do.

Scratch is the new QBasic. Drag-and-drop blocks instead of typed syntax, which purists complain about, and the purists are wrong. It teaches logic, loops, events, and variables. The syntax can come later. The thinking is the hard part.

Raspberry Pi is the new bare machine. Forty bucks gets a kid a computer that is transparent again. Linux, a terminal, GPIO pins you can wire things to. It brings back the friction on purpose, and friction is where the learning lives.

And AI is the new parser. Kids today are learning to talk to machines through prompts the way we learned through "look at tree." The lesson is the same one Sierra taught us: be precise, understand what the machine actually did, and don't trust output you can't explain. AI can generate code faster than any of us ever typed it. Someone still has to understand what got built. That was true in 1992 and it is more true now.

The Fundamentals Didn't Change

The frameworks change every couple of years. The fundamentals do not. What made a kid into a programmer in 1992 is the same thing that does it in 2026: curiosity, a machine that lets you poke at it, and something you care about enough to fight through the frustration.

For me it was a Sierra parser that killed me a hundred times and a phone line that tied up the house every night. For a kid today it might be a Minecraft server or a Raspberry Pi in a shoebox.

The tools are different. The discovery is the same. Give a kid a machine, give them a reason to care, and get out of the way. The only way to learn is to try.