I'm going to take a big risk here, and date myself rather severely. Feel free to relentlessly mock me as the ancient geezer that I will probably appear to be. Also, be prepared for a rather lengthy entry; I haven't had a nice brain-dump in a long time, and I have a lot on my mind.
I started programming something like 19 years ago. I don't remember the exact point in time, but I very vividly remember the experience. Someone in the community got ahold of a bunch of Sharp Pocket Computers, reportedly from an accounting firm that was replacing them with newer hardware. I can't recall the exact model anymore, but it was a little one-line LCD display with a tiny QWERTY keyboard and a dockable dot-matrix ribbon printer. My best guess is that it was the PC-1500.
It came with a mind-bending 16KB of ROM, and the particular unit I ended up with had an expensive add-on chip that provided a matching 16KB of RAM. There were some other nifty features that I never learned how to use, too, like the ability to save out your programs onto an audio cassette tape. (Here's a blast from the past for you: the recordings sounded an awful lot like the handshake of an old dial-up modem. Not like a 56KB modem, either - think 4800.)
The Pocket Computer was basically a clunky programmable calculator. I guess what made it appealing to the accounting firm was the fact that you could write simple programs like loan amortization and have it spit out reams of receipt-like paper with tiny red, green, blue, or black numbers on it. In the early 1980s, that was pretty cool. The things ran at something like 1.3MHz, which was blazing fast for something you could run on AA batteries and carry around in your briefcase.
Anyways, apparently by the early 1990s they were falling out of fashion, and more powerful machines were readily available for the accountant on the go. So the company unloaded their stock of PC-1500s, and one of them wound up in my youthful little paws. Along with a couple other neighborhood kids who had gotten one, I set about learning the primitive dialect of BASIC that ran on the machine. Of course, about the only interesting thing we could think of to do with a computer was to make games. None of us knew enough math to even plumb the depths of the calculator functionality on the thing, and we certainly weren't interested in the piles of accounting-related examples that came in the instruction manuals.
They were, frankly, perfect for what we were doing. There was a tiny built-in speaker that you could program to generate sequences of arbitrary tones. With some practice (and lots of annoyed siblings and parents) one could figure out how to generate the precise list of frequencies necessary to play little musical snippets. The printer unit offered some simple graphical commands for doing routine accounting-ish things like drawing graphs; we quickly found ways to churn out funny stick-figure drawings and doodles. Supposedly there was a graphical mode where the 1-line LCD could be used to display rudimentary monochrome sprites, similar to the character-based "art" of many contemporary heavy-weight personal computers. While none of us ever did learn how to use that particular feature, we did come up with endlessly creative ways to use the simple built-in symbols. Nethack had nothing on our inventive reinterpretations of the @ sign.
Looking back on it, it appears that the suckers were a lot more powerful than I ever learned how to capitalize on, which is frankly kind of sad; I still have a deep fondness for the rigors of programming in an ultra-compact environment, and I would dearly love the chance to go back and max out the capabilities of one of those humble little PC-1500s. Tragically, I haven't had a working one in many years; one day the AA batteries died so I plugged in the bundled power supply... forgetting (or, perhaps being fairly young at the time, not knowing) that the mains voltage in that particular location was 240V. There was an interesting pop, a sort of burning, tortured-plastic smell, and the poor 120V power supply surrendered its ghost (or something vaguely smoky, anyways). Somehow, the voltage spike managed to carry through the power supply itself and nuked the internals of the computer, and it never worked again.
(Coincidentally, I've recently found the Arduino an interesting diversion, and it harkens back to the days when ROM was precious and RAM was downright priceless. Programming for it has been a joy in many ways, but mostly just because it reminds me of my roots. I'm currently in the process of building an electronic re-creation of one of the classic "games" that we wrote on the old PC-1500, a gem that we titled Snowball. Once that project gets some more love, I'll post more about it.)
Moving Up in the World
After cooking my beloved PC-1500, I had an insatiable itch to program things, but no outlet. I began pestering my parents to borrow their 286 laptop running the brand-spanking-new MS-DOS 5. As history buffs might recall, MS-DOS 5 was the first version to feature the QBASIC environment - which was a true triumph of hobbyist programming, and remains one of the most memorable IDEs I've ever used.
Anyways, in between waiting for my parents to finish doing "useful stuff" on their laptop, I started upgrading my skill set. Gone was the limitation of the tiny 1-line LCD screen; now I had an unimaginably huge 80x25 character screen! It was still black and white, of course, but there was so much space! Even better, there was the tantalizing possibility to enter into "graphical mode" and draw all those silly stick figures and doodles on the screen instead of waiting for an agonizing eternity for the tiny dot-matrix printer to crank them out.
This was my first introduction to the magic of "real" programming, or at least, slightly more "real" than the stuff I had done on the PC-1500. One of my crowning achievements on the Pocket Computer was to implement a text adventure game that ripped off the "Where in the World is Carmen Sandiego?" concept rather liberally. It featured a whopping two possible outcomes and a more or less play-once-throw-away linear storyline; a lot of the logic was actually charted freehand on notebook paper by my dad, and I spent the hours it took to meticulously convert the story arc into BASIC commands and peck them into the minuscule keyboard. I remember coming close to the limits of the machine's ROM at one point, because the game contained so many hard-coded text strings for all the storytelling going on.
So to get a full megabyte of RAM to play with - a million bytes! - and an 8MHz CPU was just heavenly. I think the hard drive was something in the neighborhood of 50MB, which was pure insanity in my mind. Naturally, the first thing I dreamed of doing was creating my own clone of the smash hit Commander Keen.
It was only a few weeks before I realized that Commander Keen was a bit beyond the reach of a kid poking around in QBASIC. But I refused to let that stop me. Another family favorite was the Kroz series of dungeon-crawler/puzzle games, which featured ASCII graphics and a simple top-down view. Each level of the game was a single screen - no scrolling, no fancy animation, barely even color (and that was only in the later games in the series). After my pocket computer days of playing with less-than-ASCII art, it seemed like a plausible target.
Ironically, it still hadn't occurred to me that computers were useful for things besides games. Whatever it was my parents did with the thing was a mystery to me; I just waited impatiently for my turn to make it beep and draw circles and probably crash a few times. My obsession with game programming is literally as old as my programming career itself.
Not much younger, though, is my obsession with programming languages.
Through my mother, who had taken some classes at community college while pregnant with me, and had loosely kept up with computing ever since, I heard about this magical thing called "Pascal." Apparently, it was a step closer to what the "real programmers" used. But even more mysterious - and I think it was mentioned all of twice in the span of several years - was something known simply as "C."
Somewhere along the line, on this measly little 286, my dad showed me something that proved to be a monumental discovery for my underaged little brain. He pulled up the MS-DOS EDIT program (which was, as history nerds will recall, actually a shell that disabled several of the features of the QBASIC IDE and masqueraded as a text editor) and opened up one of the .EXE files from one of the Commander Keen games.
I guess he thought I'd get a kick out of seeing all the magic symbols and alien runes and whatever else lived inside a computer program. I'm not sure he realized just how profound that experience was for me.
That kicked off a thought in the back of my young mind - one that has yet to stop casting aftershocks into my daily life. I realized, then and there, that there was something more than QBASIC behind the creation of real programs. QBASIC certainly didn't have anything like a compiler, so it didn't produce .EXEs. I knew on the spot that I just had to find out how to make my own EXEs. That was where it was at.
Of course, this led to several attempts at copying and pasting random ASCII bytes into a text file and running the "EXE" from the command line. More often than not, this would simply crash or even reboot the computer. Clearly, people didn't do this by hand; there had to be some kind of tool that did it for you.
That began a fantasy that has lasted up until this day: the dream of making my own programming tools. I couldn't quite imagine what this "real programming language" looked like, so I started inventing stuff that seemed plausible at the time. It centered heavily on rarely-used keys on the keyboard, lots of cryptic and arcane abbreviations, and of course endless pages of numeric "codes" that really didn't mean anything but were just there to make it all seem more realistic.
Eventually, I got bored with trying to invent a programming language (especially because I hadn't the first clue how to make an EXE out of it anyways) so I moved back to my first love: making games. By the time I stopped using QBASIC on a regular basis, I could write a Kroz clone in under an hour, purely from memory.
Times, They Be A-Changin'
During this era, there were muttered rumors of a revolution pending in the computer world. Whispers of the death of DOS floated through the air, and people spoke in hushed tones of the coming evil known as "Windows." Most people - including my parents - hated the very notion. Of course, my family had once owned some of the original offerings in graphical personal computing, so it wasn't so much the GUI thing; it was this dark and deplorable entity called "Microsoft" that was to blame.
There may have been actual legitimate reasons for their fear of Windows, but as far as I can recall, the main reason my parents loathed it was because they would have to pay Microsoft money to use it. I think it was the principle of buying expensive software that they found problematic. Either that or there was some hand-wavy gibberish about how it was "buggy" and that was the end of that. But the conversations always reached the same conclusion: that Windows rubbish shall not enter this household.
Eventually, it became clear that Windows was here to stay - right around the 3.0 release. I guess people at work started using it or something, because suddenly we could no longer (as a family) survive without it. To get their "important, serious stuff" done, my parents were forced to embrace Windows, because all the new software was for Windows, and of course their colleagues were using the new software.
Thus it was that I was introduced to Windows 3.0, indirectly via an obscure and little-known monstrosity known as Norton Desktop. There I found that an entire new horizon of possibility had opened up. No longer was graphics something hard to do with QBASIC, or with mystery techniques that the Black Wizards of Game Development knew (and I didn't). You could, supposedly, just make programs that looked all shiny and graphical!
I had to do it.
That led inevitably to a summer of saving my earnings religiously, and eventually scraping up the cash to buy a copy of Visual Basic 3 for Windows, Standard Edition. (I secretly had wished for the Professional Edition, but couldn't remotely afford it.) It had "Basic" in the title, and promised to at least vaguely resemble the PC-1500 BASIC and QBASIC I'd learned, so it seemed like a decent investment.
I spent several weeks without a computer to run it on, so I sat around on the couch reading and re-reading the Programmer's Guide and Language Reference books cover to cover. They were something like 300 pages each, and by the time that summer was over, I could recite long swaths of each of them from memory.
By the time I managed to get ahold of a junked old 386 that someone was giving away, I was practically frothing at the mouth. I had to start making Windows programs, and I had to do it now.
It wasn't Windows so much, really. It was the fact that at long last I had found a tool that could make EXEs.
Visual Basic proved to be a very different mental model than QBASIC. Gone was the linear flow of subroutine calls with the occasional function sprinkled in; suddenly, one had to contend with this "event driven" concept and the unpredictable ways in which a user could interact with a GUI. It was all very heady stuff.
Most importantly, though, the only resources I had for learning VB - the included manuals - seemed like they'd never even heard of the concept of video games. It was all business applications and all that "serious" stuff that I'd never really paid attention to before. I diverted for a couple of years into making small utilities - spreadsheets, budgeting software, even tax calculators - that focused on the financial libraries built into the VB language. Every now and then I'd make a card game or a Minesweeper rip-off or something, but certainly nothing like a serious video game.
For that, I remained in the land of DOS and QBASIC. I'd learned enough to do fairly sophisticated stuff, including some ASCII-art platformers and even a full-fledged text RPG in the DOS world. It wasn't making EXEs, so something felt like it was missing, but I really wanted to make games more so than business apps, so I endured the endless loading and unloading of the by-then Windows 3.11 environment, switching back and forth between QBASIC and VB.
Then, one day, my mother stumbled across a floppy disk. I still don't know where it came from, and I've never actually remembered to ask. But I will never forget what was on it: a dusty but functional copy of Microsoft QuickC 1.0.
Shit Gets Real. Mode.
C was a huge revelation to me. Suddenly, it was no longer necessary to suffer through the QBASIC model of interpreted programming. I could make .EXEs, and I didn't have to make them for Windows. (In fact, it took a long time before I even found out how to write C programs for Windows, but that's skipping ahead in the story.) In some forsaken garage sale or another I landed a single C textbook, and set about learning how to do all the things that I'd been doing in QBASIC for ages in this new mystery language.
For anyone who programmed C in the early/mid 1990s, you know how chaotic it was. There were memory models, CPU architectures, 16 and 32 bit. Most everything was still in real-mode DOS, which meant 16 bit and near memory model. It also meant occasionally dipping into the realm of inline assembly language to do things like interact with the BIOS for graphics and whatever else. Suddenly I was seeing all this stuff that looked like what I had suspected "real programmers" did for so long; it was like getting a glimpse of my childhood gods.
Meanwhile, I also landed a copy of Turbo Pascal and Turbo C, which introduced yet more mystery to uncover. The Borland libraries included a lot of graphical capabilities, which returned me to the prospect of making games; but they required a lot of arcane stuff that wasn't documented, and I simply had no resources for learning it. Libraries didn't carry books about it, because the books hadn't been written. I certainly knew of nobody else to ask in person. And the Internet was still a distant rumor.
Somewhere in there I also got a copy of Dan Appleman's brilliant Visual Basic Programmer's Guide to the Windows API book. Not the Win32 API - Win32s was a vaguely unfamiliar beast that hadn't totally taken root yet, and Windows was for all practical purposes still very much 16 bit - but the Windows API. I began to see a bridge between the Visual Basic world and the C world, and it was intriguing indeed.
Frankly, a lot of it was over my head. I still don't feel like I ever really mastered real-mode programming, or memory models, or the subtleties of segmented memory addressing. Thankfully, right around this time, it turned 1995.
Windows Destroys Civilization, Again
Out of nowhere, the old complaints about Microsoft ruining the world started to surface again. Apparently, they were doing more shenanigans with this Windows thing. Just about the time we had all embraced the monster and learned to (sort of) love the graphical overlords, they were off and replacing it all with some new schlock called Windows 95. It was going to herald the end of computing and usher in a new stone age, because it was just that bad.
Of course, we now know in retrospect that the prophets of doom were full of crap, and Windows 95 actually wound up being a good step forward - especially where programming was concerned. Full 32-bit virtual memory access! True pre-emptive multitasking! Life was amazing.
Naturally, 16-bit Visual Basic 3 wasn't going to hack it anymore, and of course the incarnation of Turbo C I had acquired had no knowledge of how to exist in this new realm. So it was time to upgrade.
Visual C++ 4.0 was hot off the presses in those days, and it came with a throwback installer for Visual C++ 1.52. Somehow or other I got a copy of VC++ before I had a working Windows 95 machine, so I ended up playing with Visual C++ 1.52 for a few months before moving on up to the 32-bit world. It was a mind-bending experience, and it makes me profoundly glad that IDEs have been improved upon as much as they have in the past 16 years.
Introducing the Intertrons
It was around this same time that I got my first taste of the Internet, and more specifically of the fledgling World Wide Web. (Remember when people knew the difference? God I feel old.)
I immediately knew that this thing was going to be huge. I remember sitting in front of some crusty old excuse for a search engine (yes, kiddies, there was a time before Google) and typing in "Star Wars." Several minutes later, as the 36.6 modem churned data across the phone lines (I feel old again), I got back an exhilarating list of funny quotes from the movies. No images, mind you - it was still too expensive to download pictures all over a standard web site, so everything was still textual - but just seeing some of my favorite lines from the films was a virtually religious experience.
Not long after, our family got some Internet access of their own, and I stumbled across some of the early programming communities on the web. I wish I could remember them, because they were a phenomenal part of my development as a programmer; alas, my memory stopped working right around the time I discovered that I could look up any information I needed to know just by typing at the computer.
Needless to say, exposure to other programmers via the internet was probably the best thing that ever happened to my career. I quickly realized just how much I had to learn, and discovered that people were plenty willing to teach. I merrily burned a few years learning all the ins and outs of 32-bit virtual mode programming in C. I learned how to write Windows programs in C, using the Win32 API that seemed comfortingly familiar after my Visual Basic days. I learned to do some more real-mode stuff, too, but that was falling by the way-side.
DirectX was looming in the future, and once again my call to make games surged up inside. At long last, it seemed like I could find a way to do all the graphical stuff that had eluded my lone-wolf self for so long, and do it just like the "real programmers" did.
The Dark Years
Somewhere in there, I spent a few years freelance consulting. I drew on my knowledge of Visual Basic - which I had since upgraded to version 5, and then 6 - to write business apps. I even dabbled in ASP Classic and did some web development. Over many long and painful months, I continued to refine my understanding of C and what passed for C++.
Java came and went in there; I learned it and used it for a few short weeks, until deciding that it was after all a pretty idiotic language and designed by people who were clearly more interested in bureaucratic masturbation than writing cool programs. (That was my immature and youthful perspective on the matter. As I've aged and wised up a bit, my opinion of Java has not fundamentally changed.)
I taught myself DirectX 6, using the few books I could find and mostly the internet, and started writing ray tracers. I had an epic, huge dream of writing a killer RPG in VB6, and even got a fair bit of art and content developed before getting lost in the weeds of creeping featurism and eventually giving up for lack of people who wanted to help with the ever-expanding concept.
I did a couple of years of research and development on real-time global illumination, and even discovered some original techniques based on photon mapping that have since been rediscovered and documented by other academic researchers. (That was an oddly ambivalent moment; I was happy to see that someone had validated my own work, but rather annoyed with myself for never publishing any papers on it personally.)
And then came the Day Job From Hell. If you really want to know, you can find some angry rants about this in my journal history; but frankly at this point in my life I'd rather just forget entirely about that, and move on.
The Game Industry
About a week after I accepted the Job Offer From Hell, I received another offer, this time from a small German studio making space simulation games. I'd played a couple of their older titles and loved them, and then spent a year as a volunteer beta tester; during the beta testing phase, they casually mentioned that they were looking for programmers to help write quest scripts on a volunteer basis. Work that was deemed sufficiently good would ship with the game.
That was enough for me; I had to do it. I invested a bit of time learning the company's in-house scripting language and tools, and began what would eventually become a nine year relationship with Egosoft. I shipped three games and did heavy principal development on a fourth before ultimately departing for my current position at ArenaNet.
I find it oddly fitting that, 19 years later, I'm still deeply obsessed with making video games. Not many people get to have their dream job, and I feel profoundly fortunate to be among them. (A lot of people accuse me of being lucky. Maybe this is true. But for my own part, I don't credit luck - I credit the decade of intense investment and sacrifice of my youth. I may be fortunate, but I had to earn it.)
I also find it fitting that one of my other early fixations has stuck with me for so long - that is, programming languages. I still get a rush from the very idea of making a language all my own, and the thought of having other people adopt such a creation is just exhilarating. Between my day job and my hobby in the Epoch language, I feel like I've covered the bases pretty well.
The rest is not, contrary to popular opinion, history.
The rest is the future. And I wouldn't have it any other way.