I've been involved with web programming and developing web application frameworks for a while, as you'll see in the history section below.

I've made a beta release of the compiler for Ur/Web, a domain-specific language for developing web applications backed by SQL databases. The static type system rules out code-injection attacks and many common kinds of web programmer negligence. Beyond that, I've added features from the world of dependent types, especially to support metaprogramming, where programs can be written by recursion on type structure. This makes it possible to reify as well-typed functions many "design patterns" that show up via copy-and-paste in most of today's web applications.

My previous tool for web development has the lackluster name smlweb. It's a sort of PHP replacement language based around the Standard ML programming language. That means basic static type-checking of your page generation templates, plus easy interfacing to new and existing SML code. I also developed a generic SQL access library that plays well with the page generation piece.

I founded HCoop, the Internet Hosting Cooperative, and, until about 2009, I was the de-facto person in charge of developing custom software for managing secure Internet services that dozens of people are allowed to configure. Today, this mainly means a custom command-line configuration management tool and a web portal (implemented with smlweb) for handling tech support issues and more. The code is available in CVS via the SourceForge project.

I am a die-hard functional programming fan, of the statically-typed variety. My particular favorite languages today are:

• The ML family, including Standard ML and OCaml
• Here's a lightning-speed tour of ML and why you ought to be using it that I wrote.
• I also created a side-by-side comparison of SML and OCaml.
• And the surprise dark horse candidate, Coq! You may know it as a proof assistant to help you get a computer to check your mathematical proofs, but it's actually a rather spiffy programming environment. I think the future is bright for languages like Coq's, where the compiler will check very specific correctness properties of your programs.

I joined Teen Programmers Unite around the end of 1996, when I was 15 years old. It was a great experience and the impetus for me to move beyond QuickBasic to "real programming." Looking at the Internet today, it's hard to imagine a bunch of teenagers not only gathered together on such an intellectual subject, but also actually doing real programming on a day-to-day basis. Yet, it happened, at the dawn of the commercial Internet!

Early on, I volunteered to create first a web message board and then assorted other CGI scripts for TPU. I soon ended up as the primary administrator and all-around head honcho, from about 1997 to 2000.

Now we segue into my DJGPP phase. I was introduced to this DOS port of GCC by a loyal cadre of DJGPP'ers in TPU. As the prestige things to code in that crowd were either demos or games, I tried my hand at quite a bit of game programming over the years.

On the left, you see a scanned drawing of a character called "Burp," drawn by David Palumbo and colorized by me. This is for a Street Fighter II clone that we were working on called Brimstone, planned mostly in 9th grade study hall.

I did some Visual Basic 5 coding in this period, too. Among the programs I created was a GNU Info browser for Windows called WinInfo. This was the format in which the DJGPP docs came, so it was only natural to want a better interface than the text-based client they provided. To the left you can see a screenshot of a document opened in WinInfo.

Dynamic web site development was one of the first kinds of serious programming that I did, so it will always hold a special place in my heart. Over the years, I've tried a lot of ways of doing it, and I've progressed more and more towards designing my own frameworks and languages for it.

• I started out writing CGI scripts in Perl 4, probably because a Yahoo! search (no Google back then!) revealed that as what Most People seemed to be doing. I hosted the first TPU dynamic content on a Dragonfire.net account, with only an FTP interface to use in developing and debugging scripts. It's a wonder that I can still look at a regular expression without going berzerk.
• The next stage of TPU stuff was CGI implemented in C with that Boutell library. Let's just skip over this stage as quickly as possible, OK?
• Then I discovered the TeaServlet, a Java-based web templating system from the folks who brought us the web sites in the ABC/Disney family of corporate malevolence. I built my own infrastructure around it for allowing safe division of a web site into a hierarchy of pieces (called categories) managed by different folks. It was allowed to edit and compile templates over the web, for your particular categories.
• Next I went off to college and discovered the wonders of functional programming. I created smlweb, which I mentioned earlier. By this point I was past the age to be managing TPU, but the fellow who took over used smlweb for a while.

I had a Texas Instruments graphing calculator phase, too. Some folks aren't aware that most of the TI-8x series and above support assembly programming. Starting in the 1990's, there was a serious cottage industry of mostly high school students coding some pretty slick games for these beauties.

Unfortunately, most of these lost souls were programming directly in assembly, so I set out in 9th grade to write TCC, an ANSI C compiler for TI-85 (and later TI-86) calculators. This also marks the beginning of my interest in programming languages and compilers.

Pretty soon I got to thinking about extensible MUD engines. Scripting languages were so passé, and Java was so slow. I wanted to be able to write plug-ins in C (yes, I was programming language-challenged back then), compile them, and run them in a speedy virtual machine. So I created xCode (I had the name before those Apple people!), Yet Another Virtual Machine, including an assembler, C compiler, and standard library. This time I got the C compiler to the point of almost full compliance with the ANSI C standard.

The neat thing about xCode that still sets it apart to this day (as far as I know) is that it supported selective streaming of program bytecodes across network connections. This makes it possible to do away with roll-your-own network protocols and instead use an RPC style: Some portions of your program are marked as normal, and some are marked to execute on the remote host, where functions called in these parts of the code take the places of explicit network messages.

In the summer after 10th grade, I had my first job, as a programmer at Trifecta Technologies. We worked on electronic commerce web site development based around IBM's now-extinct Net.Commerce system. As Trifecta is an IBM business partner, I had opportunities I likely wouldn't have had elsewhere to use their AIX operating system and its C compiler, xlC. That first summer, all of the programmers were under 21 years old.

I went on to work there for the next two summers, too. Looking back, the most braggable thing that I got to do was write a good chunk of the custom code that drove the web site that took donations to John McCain's 2000 presidential campaign. He had the URL flashed on the television screen during a speech, perhaps marking a first in the historical popularization of the Internet.

I used xCode to realize my original vision of a 3D MUD engine. The client worked in Windows via OpenGL and featured a small windowing/widget library that I wrote to work entirely inside OpenGL, so that it could be used in full screen mode without interfering with the best 3D graphics card acceleration. All network protocol stuff was done through streaming execution of bytecode programs.

You can see a screen shot of the client on the left. Click on it for an enlarged version with some of the pieces labeled.

Now let's wrap up with some random links to other related stuff.

• Aanigo Software Productions: Old site for a "software company" I made up for myself.
• DevLocus: My domain, used at first for a failed programming resource site to replace TPU, then for the dynamic web content system that ran TPU, then the original default domain for what became HCoop, and now just a souvenir.
• The Fellowship of Hobbyist Programmers: Another attempt to create a worthy successor to TPU. This fizzled, too, probably in part because the use of "hobbyist" implies to many people that it's for newbies or folks who don't actually care about programming.
• CodeApplet: A system for sharing an interactive programming language loop over the web, via a Java applet. Included Scheme support via SISC.
• ML Special Interest Groups: Currently-dormant wiki for organizing meetings of fans of the ML programming language family. (The domain has expired.)