My Programming History

A walk through technologies and languages past.


Early Years

I still remember when our first computer arrived. It was the original IBM PC and when I saw the monitor I thought it was a new television. Everything was text-based and monochrome. It was awesome. Of course, as time marched on we’d get color ASCII graphics and eventually EGA, but I digress. My earliest memories with programming were trying to mimic BASIC code that my older brothers wrote for various games they created to amuse themselves. It was probably my first introduction into algebra. Around the same time we were using LOGO in grade school (too far removed to remember what grades).

College Classes

My first programming class was at Marist College. It was an evening class I took to try to figure out if I wanted to major in Computer Science or not. I was hooked pretty early on. The class was fairly dry, but informative. I simply loved the straight forward logic, and how you could build complexity out of very simple ideas and constructs. The class had a lab with a grad student teacher; he had a lot of fun setting up creative projects for us, generally around alien invasions or setting up some sort of system for bureaucrats on a Mars colony. Some students were less enthusiastic than I on these topics, so after a lab or two he also included some dry “real world” business scenarios. I don’t recall ever completing one of those. I still have some of the more interesting ones filed away. We used Turbo Pascal (and its glorious blue screen) on MS-DOS.

When I entered Geneseo, Pascal was still their intro language (by the time I was a senior they were transitioning to Java). The main CS labs were Mac OS, so it seems likely we were using Object Pascal. Classes included the standard CS fare on data structures, algorithms, and so on. The most advanced Pascal-based project we had was for a 200-level class that involved creating our own virtual machine in assembly to run given machine code.

All 300+ level classes required C or C++ (with the exception of AI, which used LISP). 3D was just becoming a real thing at that time, so our Graphics class involved creating 3D environments in OpenGL which was a bit of an adventure (various teams had things like the planets in the solar system, a cave with stalagmites, or ours with rolling hills and trees). For Operating Systems we created a few different core parts of an OS (but nothing cohesive). The most challenging and fun (requiring at least one all-nighter in our Sun workstation lab) was Compilers where we had to create our own pascal-like compiler. On the last day the professor ran real code that he wrote and observed the results. It was stressful, manic, and beautiful. Most of the teams worked in C while my partner and I went all in with C++. It worked out well for us as we were able to split up the work and had a nice fast compiler in the end. I recently re-found the original source for the project, which resulted in a nice mix of horror at my code and pleasant memories.

I took LISP, but it was just a partial credit class early on when I hadn’t realized it was meant for AI students. Unfortunately, as the AI class was not offered every semester I never got to take it. But I did enjoy that brief functional foray, even if I did dream in parentheses for a time. The language derivative was Common Lisp, using Paul Graham’s book a solid decade before having any idea who he was (although to be fair, he really wasn’t anyone just yet!).

In one of my last classes I actually did have to do a little bit of Java; it was for a Database class taught by a “real world” adjunct. I don’t remember the details, but the simple API we wrote was in Java (the real guts obviously being our underlying database). Of course, this class had a lot of practical use in the real world where relational databases are used extensively. So that was nice.

First Game

I’m not sure if it was before I had even finished my first class at Marist, but I attempted to make my first real game: MacRonalds. It was a BBS door game inspired half by Legend of the Red Dragon and by my previous work experience at a certain fast food establishment while still in high school. Initially, I was in way over my head. After a couple of semesters I revisited it and did get a working version out in the wild (run at one local BBS, at least: Chicago Fire). I put out a final release (v1.03) after graduating while conducting my job search. I played with the idea a few times of creating a web-based version, but never got too far along.


I interned at Sunburst Communications (after being purchased and passed around, I believe they’re now called Sunburst Digital). They made educational videos and computer games. I was there over two summers and worked with their custom C++ engine on a few games, as well as typical grunt work you’d want to farm off to an intern. I scored a “project engineering” credit for at least one product, “A Field Trip to the Rainforest Deluxe”. There might have been others as well, but that’s the only one I received (yes, I still have it).


After graduating I worked for Malcolm Pirnie, an environmental engineering firm, where I stayed through a merger with Arcadis until I left in early 2012. In the beginning I worked on a monolithic Visual Basic 6 client application. I was the first programmer hired (they previously had programmers, but they had split off into a new client-facing group), so for the first year I was primarily working with a small army of consultants. Over time we were able to move on to a nice sized internal team, providing custom development for pretty much every group across the firm (accounting, marketing, HR, and project managers). As the company itself grew, corporate IT transitioned to become a national team with multiple datacenters.

Over those first few years we transitioned away from the monolithic client app to use a stateless VB6 COM+ middle tier with a much lighter client. We created new classic ASP/COM+ intranet sites to replace older Windows client applications, mostly using VBScript (there was a brief time where IE was cutting edge). We transitioned most of the monolithic app to use web pages instead. Every app was more or less its own island.

We finally created our own internal web portal for custom applications; initially it was part of a large CRM system we created, but the intent from the start was to tie all of our applications together. Technology-wise, it was still in the era of VB6 and COM+, with XSLT utilized for views (and obviously XML being the data transport of choice).

We didn’t get beyond R&D for .NET 1.0, but for v1.1 of the framework we actually had a decent portfolio of applications. I rewrote our portal to support it (initially still using “EnterpriseServices” functionality for .NET). It was certainly more of a port than a true rewrite. When 2.0 .NET was released, it was updated to support that as well. I have bad memories of utilizing the GAC during this time period, which was not helped by 1.1 and 2.0 being completely separate.

Thankfully, as we created more and more sites (and of course revisited old ones), we had a much better feel for things. Partial classes allowed me to create codegen templates for quickly spinning up new applications while upgrading older ones much quicker than before. It was a constant cycle of refinement.

The stateless architecture of COM+ and early design decisions bled into a lot of our work long after those servers were shut down. We setup web services for sharing data/logic across applications, which before I left meant we could use an internal server for shared Nuget packages. We utilized XML as a primary data transport mechanism with XSLT to build the vast majority of our views. Obviously after those initial forays we migrated to Javascript and then jQuery (albeit after an initial attempt with YUI).

Of course, there were other types of applications built along the way. I utilized Windows Services for handling scheduled or queued tasks and worked on a few normal Windows apps for end-users. As you might expect in a corporate environment, there were many customization/integration efforts for the usual alphabet soup of suspects: ERM, CRM, EDMS, DW, and so on.

Recent History

After striking out on my own I’ve primarily focused on web development. The most public-facing work would probably be Wetzdoku and Stone Leaf Teahouse, along with previous work on Esquire’s Life of Man (80th anniversary micro-site) and the web comic Sufficiently Remarkable.

I’ve enjoyed working with .NET Core so far, although like most devs I’m seriously looking forward to both the framework and tooling being fully fleshed out and stable. It’s nice being able to run multiple .NET apps on a linux VM (and very performant at that).

I’ve transitioned most of my low volume (edit-wise) sites to use Hugo, the go-based static site generator. In combination with renewed use of linux (both cloud VMs and WSL locally), it’s a pretty simple and clean way of getting quick work done and rolled out to production (typically via git push).

I’m still biased towards server-based web apps, but I do have a local app I created using Vue. While that framework lets you use bits and pieces, I went all in with the “preferred” tooling: Npm, Babel, VueX, VueRouter, ESLint, Webpack, and others that I’m probably forgetting. I decided to keep the server API in a completely separate project (Asp.Net Core), mainly because it’s a pretty simple backend and I wanted to use Webstorm for the front end development (lighter app that I prefer for front end dev compared to VS).