George the Avatar
Programming Place

Current Projects
Program analysis
Research on software verification

My PhD research was on formal verification of software. I worked on techniques for constructing programs that have formal, machine-checked proofs of correctness. The two main components of my thesis were certified program verifiers and certified compilers. I started in summer 2008 as a postdoc with Greg Morrisett, and now I'm a professor at MIT. See my professional web site.

Lambda Tamer
Lambda spider
Programming languages for web applications

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.

Noisy globe
Infrastructure for cooperative Internet hosting

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.

An old friend
Obligatory programming language preferences

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

Favorite gripes about software development today
  • Non-type safe languages ought to be nearly extinct today. There's no reason to be writing applications in languages that let you screw up the basic abstractions of programming in arbitrary ways.
  • Object-oriented programming is the cro-magnon man of the programming language family tree. It conflates in one mechanism of "objects" or "classes" a calvacade of features that ought to be mutually orthogonal: dynamic dispatch, encapsulation, interface compatibility, namespace management, records, .... Really, you'd think these people had never seen ML.
  • Imperative state was sent to this planet by alien tricksters who delight in watching us immolate ourselves. I don't want to have to think beyond the syntax of a piece of code to understand its control and data dependencies with the rest of a program. Try writing a formal proof of correctness of a sizable imperative program some day, and then remember that formal provability is a good proxy for how easy it is for humans to understand something!
  • What's up with this fetish for making everything fit the abstraction of an array of bytes? Filesystems, network protocols, it's all at the wrooong level of abstraction, and not very cordial for developers who don't care for bugs.
  • And the mother of all meta-gripes: Most programmers just think at too low a level of abstraction, writing repetitive low-level code that obscures their original intent. Part of the problem is a common ignorance of what compilers and other language tools can do today and what they're capable of doing if enough people get on the wagon train.

GOTO HELL I started programming GW-BASIC when I was around 6 years old, on a brand spankin' new 386.

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.

WinInfo browser

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 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.

Divert power from life support to the replicators I did a fair amount of random Allegro programming in this period. Among other things, I started coding a computer version of Starfleet Battles. You can see an "analog" screenshot of it to the left; that is, I got fed up trying to take a proper screenshot of a DOS program and decided to just photograph my laptop's monitor.
Valiant Bob

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.

The salaryman

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.

Welcome to my world

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.

Bye-bye! For further detail on my exploits up through the end of high school, see The Gallery of Days Gone By, a document I wrote a few years later to record the facts for posterity.
Science! I've been involved with a bunch of funded research projects in computer science since I started college, with all of them involving some amount of programming. My research page has more information.
Jane St. After grad school, I worked full-time for about 6 months writing OCaml code for high-speed algorithmic financial trading systems in the quantitative research group at Jane Street Capital in New York City.
Nice horsey!

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.)