I was six years old when I realized computers would listen to me. Not because I was some prodigy. Because I was tired of being tech support for my sisters.

My dad would buy games at Egghead Software. You remember Egghead? He'd come home with Space Quest or Commander Keen or whatever caught his eye that week. He'd pop in the floppy, update this .bat file that listed every game we owned. You'd type a number. The machine would obey. Game would launch like a portal. Magic. Until my dad got too busy with work.

Then every time my sisters wanted to play something, they'd come find me. "Shaun, I want to play this one." "Shaun, how do I start this?"

Over. And over. And over. And I had other things to do. Like be six.

So I watched him. Really watched him. How he opened the file. How he added the lines. How the numbers connected to the games. My brain clicked. I can do this. And when I changed something myself and the computer listened? That was it. The computer didn't argue. It didn't ignore me. It just did what I told it to do. And maybe most importantly? It saved me from my sisters asking me every five minutes.

That computer was everything you'd remember from 1990 if you were there. Beige. Always beige. Humming on the desk like a tiny engine. DOS prompt blinking at you like a dare. And those clicky IBM keyboards. The ones with real travel. You could feel every keystroke. Hear it echo through the room. Made you feel like you were doing something important even when you were just typing "DIR" to see what files you had.

There was that smell too. You know the one. Warm dust and plastic. That CRT smell after it's been running for hours. I didn't know terms like "syntax" or "variables" or any of that academic stuff. I just knew: change this, get that. Break this, fix it. Cause and effect. That was enough.

DOS batch files were simple. A few lines. Nothing fancy. But I wanted to make real software. That's when I found QBasic. My dad owned his own business. So did my grandpa. My uncle too. They were all in tech. And I wanted to be like them. Start my own company. Build real programs. So at ten years old, I'd write office software in QBasic and save it to a floppy disk. That satisfying click-clack of sliding it into the drive. The whirring sound as it wrote. Then I'd mail it to my grandpa.

Because branding mattered, right? So I'd decorate my programs like this:

-=-=-= THiS PRoGRaM =-=-=-
-=-=-= SHauN'S oFFiCe TooLS =-=-=-

Professional as hell. He'd send them back stripped clean. All my cool formatting removed. I was crushed. I didn't understand why he'd ruin it. My way was better. More eye catching. More... I don't know. Cool?

But that was my first lesson in professionalism: what I thought looked awesome didn't matter if the person using it thought it looked like a mess. I didn't fully get the lesson then. I was annoyed. But it stuck with me.

I lived for the hours when everyone else was asleep. Because that's when the phone line was mine. You younger folks don't know the struggle. One phone line for the whole house. You want to go online? You better hope nobody needs to make a call. I remember AOL 2.0, but AOL 3.0 was where it all opened up for me. Chat rooms. People making tools. Hacking apps. Scrollers that would spam chat messages over and over. Auto-clickers. Beautiful chaos. And I wanted to make them too.

I started with Visual Basic using a strategy called Sendkeys. It's exactly what it sounds like. You tell the computer to type specific keys at specific intervals. Press this. Wait. Click here. Wait three seconds. Type this word. Press Enter. It was slow. Super fragile. If you moved your mouse even a little, the whole thing would break because it was just blindly pressing keys wherever the cursor happened to be. But when it worked? Man, it felt like hacking the Matrix.

One of my first programs was called Sneakers Scroller. Named after my dog, Sneakers. Not the movie, though the irony isn't lost on me. It would scroll chat messages. Simple stuff. But people at my school actually used it. There was this one guy who'd see me in the hallway and yell "AoHell!" I'd have to tell him, "Dude, I didn't make AoHell." But he thought what I made was just as cool as AoHell. And that made me feel amazing. I just wish the bullies back then thought I was as cool as AoHell..

The programs had names. Fate Ultra. Madcow. Havok. Those were the legends. My stuff was way simpler. But it was mine. And people used it. That mattered.

Here's the thing nobody talks about: coding when you're that young is isolating. Nobody my age cared about this stuff. They were playing outside or watching TV or doing normal kid things. I was sitting in front of a screen at 2 AM trying to figure out why my program kept crashing. Sometimes it felt lonely. Like I was the only one in the world doing this.

I'd find readme files for software and just read them front to back. That's how I learned. Because there weren't a ton of books back then. Or maybe my dad just didn't take me to get them. I can't quite remember. But I'd read those readme files like they were instruction manuals for another universe.

Side note: Those .HLP files made in RoboHelp? You'd click "Help" and basically enter a time warp. By the time the window appeared, you'd aged five years and Windows 95 had been released.

But slowly, the isolation turned into something else. I started making software that other people could use. Winamp skins. Chat tools. Programs to teach people the basics of coding. And people would email me. "This helped me write my first script." "I didn't understand loops until I watched your tutorial." "Thank you for making this free." And suddenly I wasn't alone anymore. I was connected. I was useful. That feeling kept me going.

I had two friends who shaped how I think about code. Chris was my weekend escape. Every weekend, I'd sleep over at his house. We'd stay up until 4 or 5 AM just creating. We'd make hacking apps. Design graphics in Photoshop 3.0. Make ridiculous movies with his camera or in 3D Movie Maker. (Which I still go back to sometimes because nostalgia is a hell of a drug.) There was no structure. No plan. Just two kids with too much caffeine and an endless supply of ideas. Pure creative chaos. I loved every second of it.

James was different. A few years older than me. More serious. More professional. And he taught me something I still struggle with today: the importance of taking breaks. I'd want to code for three days straight. Barely eat. Barely sleep. Just grind until I solved the problem or passed out. And I'd wonder why James was so much better than me when he wasn't coding 24/7.

It's because he'd work hard for a few hours, then stop. Play You Don't Know Jack or one of those party games. Go do something else. Clear his head. Then he'd come back and solve in twenty minutes what I'd been stuck on for six hours. Because he'd been thinking about it while relaxing. Working through it in the background. I was just getting more stressed and more stuck. I still have to remind myself to take breaks. It doesn't come naturally to me.

James also made a Visual Basic module called phoenix.bas for AOL 4.0. It was huge in the "Progz" scene. Instead of Sendkeys typing blindly, phoenix.bas would find the AOL window, locate specific elements like the \AOLListbox, set the text all at once, then press the send button. Way faster. Way more reliable. I'd modify his code and send it back to him. "Hey, what if we added this function?" "I think this could be faster if we did it this way." It was the first time I felt like I was contributing to something bigger than just my own projects. And I learned a ton from him.

James also introduced me to Greg.

Greg was in his thirties. A typical computer guy from that era. Cussed constantly. Thought he was smarter than everyone. To be fair, he probably was. But he knew computers were the future. And for some reason, he wanted to teach me. He'd take me to these... I don't even know what to call them. Swap meets for tech? Computer conventions? Picture this: big tents filled with folding tables. People selling software, hardware, random computer parts, cables, monitors, you name it. Chaotic. Some of it definitely sketchy. Burned CDs with handwritten labels. Floppy disks in ziplock bags.

I was eleven years old. And it was the most exciting thing I'd ever seen.

I didn't feel alone anymore. There were hundreds of people like me. People who understood this world. People who cared about clock speeds and RAM and what operating system you were running. With my 9600 baud modem at home, it took forever to download anything. This was instant. And there were people I could trade software with. Share ideas with. It was the first time my eyes were really opened about the serious potential of being in this field. What it could do for me.

I had business cards printed up at home: Dr. Bonk Software (Because Dr's are smartest people out there). Specialized Screen Savers. Business Software. Games. I'd walk around trying to make deals with strangers. "I can build you a website." "I can make custom software for your business." Most people just smiled politely and kept walking. But some didn't.

And that's when Greg taught me the most important lesson: The people with money didn't care about code. They cared about what the code could do for them. I could build the coolest, most technically impressive program in the world. But if it didn't solve their problem? They didn't care.

Greg would coach me: "Stop talking about how you built it. Tell them what it does for them. Why they need it. What it fixes."

That shifted everything for me.

I went from being a script kiddie making programs I thought were cool to actually thinking about users. About needs. About solving real problems for real people. Because if I could make money doing this, I could keep coding. I could build more things. I could do this forever.

Greg was kind of an asshole, honestly. But he changed how I thought about this entire field.

By my late teens, I'd shifted from just making tools to teaching people how to make their own. I started Tutorial-Haven. One of the first free video tutorial sites on the web. We covered everything: Photoshop, PHP, Flash, HTML, CSS, Adobe Premiere, Audition, Daz Bryce 5.5, Cubase SX 3.0, Myspace designs. Later we added user-submitted tutorials too.

Video tutorials weren't common back then. I don't even remember what screen recording software I used. But I knew text-based learning was backwards for this stuff. Why would someone read 400 pages about Premiere Pro when I could teach them the basics in 20 or 30 minutes? I wanted to make knowledge accessible. Spread it out there. Build a community. The entire site was free. No option to pay. No donate button. We just wanted people to learn.

I actually found my first video tutorial from Tutorial-Haven recently. I'm going to include it here because honestly, it's kind of surreal to see.

And they did. People would submit their own tutorials. I'd see them create things way more creative than anything I could come up with. (I've never felt like I'm as creative as I'd like to be, honestly.) They'd tell me stories. About landing their first PHP job because the tutorials made it approachable instead of overwhelming. About finally being able to edit their film project because they couldn't afford to hire someone. About how reading books for days at a time made them bored, but our tutorials gave them "homework." A project to actually build and show the community. Books rarely did that. They'd teach you syntax and theory but wouldn't give you something to make.

The community kept me going. Seeing people make things that were more creative than I could do. Hearing people talk about how they wanted to work on a film project but couldn't afford someone to help them edit it, and the tutorials made it possible. People starting a PHP job after finding them more accessible this way because they would get too bored reading for days at a time. Seeing people grow past me in certain areas. That was the best part.

I eventually sold the site. But some of the people who submitted tutorials back then? I still talk to them today.

All of this from age six to now taught me two things that shape everything I do:

Problem solving. Everything is a system. Everything can be debugged. If it's broken, there's a reason. And if there's a reason, there's a solution.

Persistence. Things break. Code fails. You hit walls. And you keep going anyway.

I bring that to everything. Not just coding. Life. Figuring out how to travel with severe stomach issues. Teaching my kids how to budget. Building my own software because I think every app I use is missing something. It's all problem solving. It's all persistence.

I don't know all the technical terms. I might not be able to recite Big O notation on command. But I can look at code and tell you it's inefficient. I can feel where the slowdown is.

Take something simple

Say we need to check whether a value exists in an array. You could write it like this:

function findValue(arr: number[], target: number): boolean {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) return true;
  }
  return false;
}

// But if you call this repeatedly in a loop:
for (let item of bigList) {
  if (findValue(smallArray, item)) {
    // do something
  }
}

That's a nested loop. It runs the same check over and over again. I might not remember the formal term for it. But I know it's slow as hell. If bigList has 1000 items and smallArray has 100 items, you're doing 100,000 checks.

A better way?

const smallSet = new Set(smallArray);

for (let item of bigList) {
  if (smallSet.has(item)) {
    // do something
  }
}

One conversion upfront, instant lookups after. I might not quote you the complexity formula, but I'll still reach for the faster solution.

Because sometimes intuition beats vocabulary.

That's what being self taught gives you. Curiosity. The need to figure things out yourself because there's no syllabus telling you what to learn next. It has downsides. I miss context sometimes. I'll understand a concept but not know what it's called. But I wouldn't trade it.

I think so. Yeah. He'd be proud I'm still here. Still building. Still curious about everything.

I've had massive ups and downs. Times when I couldn't code at all. Times when I felt like I'd lost everything I used to know. Times when I thought I'd never be as good as my twelve year old self learning C and building CGI scripts. But I came back. And I'm happy.

I'm not the kid who thought he'd invent the next operating system. I'm something better: A grown coder who still carries wonder. Someone who sees every piece of software and thinks "I could make this better." Someone who will fight a bug at 3 AM like it personally insulted my family. I'm a good problem solver. A quick developer. Someone my younger self would recognize.

Because at six years old, I learned something most people don't: When you can control the machine, you can change your world. And I'm still doing that. Worn keyboard and all.