I was given a Commodore 64 when I was six years old. It was on this machine that I first learned to program, writing in Commodore BASIC v2.0. There was no fancy IDE, no syntax highlighting — just a blinking cursor on a blue screen and a thick spiral-bound manual.

BASIC on the C64 was bare-bones. It didn't even have dedicated commands for the machine's legendary SID sound chip or its sprite graphics. If you wanted to do anything interesting, you had to learn PEEK and POKE — reading and writing directly to hardware memory addresses. It was a crash course in how computers actually worked at the lowest level, and it hooked me completely.

One of my first real programs was a math quiz that would flash the screen and play sounds through the SID chip when you got an answer right. Building it, I didn't just learn to code — I taught myself math and algebra in the process. I had to understand the problems well enough to program them, and the immediate feedback loop of getting a correct answer rewarded with lights and sound kept me pushing further. Programming became my way of learning everything else.

I spent countless hours typing in programs from magazines, debugging them line by line, and eventually writing my own. It was the beginning of everything.

After the C64, I was given an Intel 8086 PC. This was the original IBM PC architecture — the grandfather of every x86 machine that followed. Mine came without a math coprocessor, which I later tracked down and added myself. That little 8087 chip unlocked floating-point math and opened the door to more serious programming.

The jump from the C64's 6510 processor to the 8086 was enormous. Suddenly I was dealing with MS-DOS — and I lived through nearly every version of it. DOS 3.x, 4.x, 5.x, and eventually 6.22 (or was it 6.12? The versions blur together after a while). I remember AUTOEXEC.BAT and CONFIG.SYS, the art of squeezing every last byte out of conventional memory with HIMEM.SYS and EMM386 just to get a game to run. And I remember Windows when it was just a program you launched from DOS — you'd type WIN at the C:\> prompt and watch it load on top of DOS, not replacing it.

Batch files, DELTREE, MEMMAKER, the joy of a clean boot disk — DOS was where I learned that an operating system was just software, and software could be understood and controlled.

IRQ Conflicts & DIP Switches

This was all pre-Plug and Play. Every piece of hardware you put into a computer — sound cards, modems, serial ports, CD-ROM controllers — had DIP switches or jumpers on the board that you had to manually set to select an IRQ (Interrupt Request) line. If two devices shared the same IRQ, they'd conflict, and one or both would simply stop working. No helpful error messages. No auto-detection. Just silence from your Sound Blaster and a lot of head-scratching.

I remember my Dad bringing home The 7th Guest and The 11th Hour — cutting-edge CD-ROM games that pushed hardware to its absolute limits. He spent hours tuning AUTOEXEC.BAT and CONFIG.SYS just to get the game to stream video properly from the CD-ROM drive. Getting the right combination of memory managers, CD-ROM drivers, and sound card settings loaded in the right order with enough conventional memory left over was an art form. You'd create multiple boot configurations, each one hand-tuned for a specific game or application. It was frustrating, it was tedious, and when it finally worked, it felt like you'd accomplished something genuinely difficult — because you had.

The fundamentals I'd learned poking around the Commodore's memory map translated directly — understanding registers, memory addresses, and how software talks to hardware. But DOS took it further: now you had to understand how hardware talks to other hardware, and referee the conflicts yourself.

It was on the 8086 that I had my first encounter with copy protection. Some commercial software came on floppy diskettes that were formatted beyond the standard 1.44MB, with extra sectors that a normal DISKCOPY command would simply ignore. The standard tools couldn't duplicate them — which was the whole point. So naturally, I wrote my own. My little program read the floppy block by block at the hardware level, faithfully copying every sector — including the ones that weren't supposed to be there. It was less about the copies and more about the puzzle: the disk says I can't, but the hardware says I can. That tension between what software forbids and what's physically possible was irresistible to a kid who'd grown up with PEEK and POKE.

My next machine was an Intel 286, and with it came Borland Turbo C. But it wasn't Turbo C alone that pushed me to learn the language — it was a piece of hardware I found laying around in our garage.

The BIGMouth card was a telephony board that came with a C SDK (Software Development Kit). If I wanted to make it do anything, I had to learn C. So I did. Pointers, memory allocation, structs — it was a different world from the line-numbered simplicity of BASIC. But the power was intoxicating. C let me write software that was fast, that could talk directly to hardware, and that could be compiled into real executable programs. The BIGMouth card and its SDK became both my motivation and my classroom — and ultimately the foundation for Sanity's Edge.

Sanity's Edge was a Voice Bulletin Board System (VBBS) that I created with my father. The BIGMouth card I'd found in our garage — the same one whose C SDK had driven me to learn the language — became the heart of the system. My dad and I dove into the SDK together, figured out how to control the telephony hardware, and built a complete system that could answer the phone and provide callers with private and public message areas — all through voice interaction.

This was the intersection of telephony and computing, years before the Internet made such things commonplace. It was programmed entirely in C on the 286, father and son learning together by building.

At its peak, Sanity's Edge had over a hundred members, many of whom were paying subscribers. For a teenager working out of his house with his dad, this was an incredible experience. It taught me that you could build something real, something people would actually use and pay for, armed with nothing but a compiler and determination.

I caught the tail end of the Bulletin Board System era. In 1994, there were an estimated 60,000 BBSes in the United States alone, serving some 17 million users. You'd dial in with your modem, hear that beautiful handshake screech, and land on a text-based system where you could read messages, download files, and chat with other users — one phone line at a time.

BBSes were local. You knew the sysops. You'd see the same regulars. There was a sense of community that's hard to describe to anyone who didn't live through it. And then the Internet arrived, and by late 1994 to early 1995, the BBS world began its rapid decline. The web browser offered something BBSes couldn't — a window to the entire world, not just your local area code.

Having built Sanity's Edge, I understood both sides of that transition intimately.

Computer Renaissance

While still in high school, I landed a job at Computer Renaissance, a store that bought, refurbished, and resold used PCs. I became the Test To Buy manager — when someone walked in wanting to sell their old computer, it was my job to check out all the gear, make sure everything worked, and determine what the company should offer for it. Then we'd fix it up, wipe it clean, install a fresh OS, and sell it to someone else.

My school had a program where if your job was in your career path, they'd let you out early to go work — counting it as an elective credit. So while other kids were sitting in class, I was elbows-deep in hardware, diagnosing bad capacitors and swapping RAM. Not a bad deal.

Infohaus — Florida's First Internet Coffeehouse

My dad had a hookup. His friends Nik and Mason owned Infohaus — the first Internet coffeehouse in the state of Florida. They needed a systems administrator, and my dad got me the gig. I was about 17 years old, and it was my first real IT job.

Infohaus was where I went from hobbyist to professional. I maintained the systems that let customers walk in off the street, sit down with a cup of coffee, and browse this new thing called the World Wide Web. I ended up working there part-time for years, even while holding other jobs with more hours. It was too interesting to leave.

My family was the 3rd customer of IntNet.net (Intelligence Network Online), one of Tampa Bay's first dial-up Internet Service Providers. This was a UNIX-based dialup ISP, and what you got when you connected was not a web browser — it was a shell prompt.

From that command line, the early Internet unfolded before me:

• IRC (Internet Relay Chat) — real-time chat rooms connecting people around the world, born from a Finnish university project in 1988
• Gopher — a menu-driven system for navigating information, launched in 1991 at the University of Minnesota, and briefly a serious rival to the World Wide Web
• Finger — a protocol for looking up information about users on remote systems

IRC was a world unto itself. I remember joining massive servers with thousands of people online at once and experiencing netsplits — that surreal moment when the network would fracture, half the users would vanish, and channels would suddenly go quiet before everything reconnected in a flood of join messages. I spent time in channels like #teen, where the universal greeting was the endless scroll of "a/s/l?" (age/sex/location) — the original social media icebreaker, years before anyone had a profile page.

There were no graphics. No mouse clicks. Just a blinking cursor and the knowledge that the entire connected world was reachable through a few keystrokes. It was raw, it was powerful, and it was thrilling.

My desk was covered in Post-it notes scrawled with IP addresses. DNS existed in theory — it had been invented in 1983 — but in practice, most people on early consumer shell accounts didn't have name resolution readily configured, especially once you started cobbling together your own SLIP or SLiRP connections. If you wanted to reach a server, you needed to know its number. So you'd collect IP addresses the way people today collect bookmarks, jotting them down on scraps of paper and sticky notes scattered across your workspace. telnet 128.174.5.49 meant something. You remembered your favorite servers the way you remembered phone numbers.

A shell account was fine for text-based tools, but I wanted more. I wanted a real TCP/IP connection — the kind that would let me run graphical applications on my own computer. The problem was that full SLIP or PPP accounts were significantly more expensive than basic shell access.

So I figured out how to hack my way there:

1. SLIP (Serial Line Internet Protocol) — the first step. SLIP let you establish a basic TCP/IP connection over a serial/modem line, turning your PC into a real node on the Internet rather than a dumb terminal.
2. SLiRP — the clever workaround. SLiRP was a program you could run on the remote shell account that emulated a SLIP/PPP connection without the ISP having to set one up for you. It let you convert a cheap shell account into a real network connection. Written by Danny Gasparovski, it was a lifeline for countless early adopters on tight budgets.
3. PPP (Point-to-Point Protocol) — the proper solution. PPP was the successor to SLIP with error correction and authentication. Eventually ISPs offered PPP connections directly, and the era of shell-account hacking gave way to proper dial-up.

Each step was a revelation. The moment my PC had a real IP address and could reach the Internet directly, everything changed.

Once I had a working PPP connection, I needed a web browser. I bought Netscape in a Box at my local computer store — a real, physical, shrink-wrapped software box sitting on a retail shelf. This was how you got software in the mid-1990s.

The retail boxed versions of Netscape sold for about $40 and came on floppy disks (and later CDs), along with a period of phone support. Netscape Navigator was the browser of the era — it had over 80% market share at its peak before Microsoft's Internet Explorer began the browser wars.

Loading up Netscape for the first time on my own computer, on my own Internet connection that I'd cobbled together from a shell account through SLiRP to PPP — that was a defining moment. The World Wide Web opened up in full color on my screen, and the text-only world of Gopher and IRC suddenly had a new dimension. I was no longer just connected to the Internet. I was browsing it.

Years later, on September 23rd, 2002, I launched Orbital Grooves Radio (OGR) — a 24/7 community-funded Internet radio station broadcasting live electronic dance music. It was one of the first Internet radio stations to broadcast using the SHOUTcast format, and later one of the first to use Nullsoft's NSV format for simultaneous audio and video streaming at low bitrates.

OGR began life as DanceBBS Radio. DanceBBS was a community that sponsored the station in its early days when it was being hobbled together by volunteers. The station was later renamed to Orbital Grooves Radio as it grew into its own identity.

The Relay System

In the early 2000s, bandwidth was expensive. A single SHOUTcast server might only support 5 listeners before the connection was saturated. So I wrote custom software that solved this problem through distributed architecture: community members would set up their own small relay servers, each mirroring the main station's stream and adding more listener capacity to the network. This grassroots approach let OGR scale far beyond what any single server could handle. We ran like this for years.

The Scale

OGR grew to nearly 1 million lines of code — all self-written. The platform included:

• A complete DJ management and scheduling system with 12 two-hour daily timeslots
• An automated broadcast tool (OGR.Connect) that guided DJs through going live
• A relay server management system aggregating listener counts across multiple servers
• Real-time dynamic image generation for listener statistics
• A community forum, chat system, and DJ profiles
• A slot auction system for premium broadcast times
• The Simul-Cast network — a federation of Internet radio stations sharing broadcast timeslots

At its height, over 531 DJs participated in the station. The monthly operating cost was roughly $150, covered entirely by community donations. It was proof that passionate people with modems and a shared love of music could build something remarkable without corporate backing.

When Apple added Internet radio station listings to iTunes, Orbital Grooves Radio was among the first 50 stations listed. This was before podcasts, before Spotify, before streaming was something anyone took for granted. Being listed on iTunes meant that anyone in the world with a copy of the software could tune in with a single click.

For a community-run station operating on donated bandwidth with relay servers hosted in volunteers' living rooms, this was a surreal achievement. We were listed alongside major broadcasters, holding our own with nothing but code, community, and sheer stubbornness.

From a Commodore 64 to a shell prompt on IntNet.net to building one of the first Internet radio stations — I lived through the entire arc of the personal computing and Internet revolution. Not as a spectator, but as a participant.

Every step built on the last. BASIC taught me logic. C taught me power. A phone board SDK taught me that hardware and software could combine to create something people wanted. A shell account taught me that the world was connected. And SHOUTcast taught me that if you wrote enough code and rallied enough people, you could broadcast to the planet from your bedroom.

The Internet wasn't always slick and polished. In the beginning, it was duct tape and determination. And honestly? That's when it was the most exciting.