Well, let's see.

Beasties was a pond-life simulation on the Mac, circa 1989. It was a Common Lisp program loosely based on a BASIC and assembly-language program I had written earlier that ran Conway's Life with 4 slightly-different sets of rules in the same world. Each ruleset had a different color for its live cells.

Panels was a simple experimental window system, in Lisp again. There's a theme here. Once I learned Common Lisp a lot of my own projects ended up being written in Lisp, and so did some of the things I did in my day jobs. Panels was built around constraints satisfaction and continuous event recording. I started with this vague desire to be able at any time to ask, "What was I doing at exactly X o'clock?" and have the UI system be able to give me an understandable answer. Another idiosyncratic feature it had was a rule that whenever the user started doing something, you should try to figure out something sensible to do with the input, regardless of what was on the screen--even if it was nothing. That idea went with the continuous event recording. The general idea was that if you really couldn't figure out anything reasonable to do, at least you would have a log of all the recent events, so that if the user's actions started to make some sort of sense you could maybe fit the logged events into it somehow.

Yeah, I know how bizarre this sounds now, but it did some kind of cool things. Like, for example, if you just started dragging the mouse around with nothing on the screen, it would go, "oh, mouse-dragging. Well, let's just capture that in a vector and plop a window around it. If nothing else maybe it'll be a drawing." Or, "oh, keystrokes. I know, let's shove them in a buffer and render them as text in a window."

The whole thing was sort of organized around that kind of ad hoc thinking.

GATE, the Generalized Automated Test Environment was a big honking Lisp program written originally by Matt Maclaurin, with later contributions by Chuck Lins and me. It was a big knowledge-based system written in a frame language called MacFrames (invented by Ruben Kleiman; MacFrames later evolved into SK8). MacFrames was of course written in Macintosh Common Lisp. GATE stored a bunch of descriptions of application software in terms of frames called "features". Each feature was something a user could activate in the application in order to cause some particular effect to happen. GATE would traverse the description of an application and use the feature descriptions to transmit synthesized events to a remote program called the Mole which ran as a system extension on a fleet of Macs of various models. Basically, the GATE machine would pretend to be a user who was exhaustively exercising every window, menu item, and dialog box in a whole raft of applications and spying on the remote Mac's screen, recording very time it saw something it didn't expect.

We used GATE to find and report legions of application compatibility bugs in Mac system releases. Later the event-recording code from panels came back to life in a utility called ShowMe that was supposed to make it easier to create the app descriptions in the knowledgebase.

I worked on Bauhaus. Matt Maclaurin was on that, too. It was the second OS written in Lisp for the Apple Newton. We wrote it after John Sculley ordered the Newton group to scrap the first Lisp OS and do a new one in C++. Larry Tesler told a small group of us to see if we could do anything useful or interesting with Lisp on Newton and we took him at his word. Actually, we probably took it too far. But we wrote an OS for a handheld mobile computer in Lisp in 1992. I regret nothing.

I worked on SK8, Apple ATG's "HyperCard on steroids", also written in Lisp. I didn't create it; that was Ruben Kleiman and Dave Vronay, and later Brian Roddy and Sidney Markowitz and Hernan Epelman and Adam Chipkin and Dave Yost and more folks I am not remembering. I came in late and worked on the object system and SK8Script, the first working version of AppleScript (I didn't create that, either, I just worked on maintaining and extending it).

I worked on Reactivity's crazy network security appliance that sat on a network and spied on all the application-layer traffic looking for violations of network policy. Cisco bought it and turned it into the Cisco ACE line of products. It was an example of a product that was all software but that was sold as a hardware box. It was a crazy ambitious product. I worked on various parts of it--a rules engine, auth interface, message-queue support, other stuff I forget, and then when it started to get close to being an actual product I built the whole documentation suite and the toolchain that delivered it. I remember once Franz asked me if I thought we could use their XML parser and I explained that we already had five XML parsers on the box running in parallel, one of them implemented in hardware.

I worked on a diff tool for C++ and Java that diffed AST nodes instead of text. I knocked that out in a few weeks and cleared a tidy sum for it. I did it so quickly and sold it off so thoroughly that I don't have any of the code anymore and don't really remember how it worked.

I built almost all of an embedded control system for a forensic fingerprint livescanner, including its built-in GUI UI, all in about a month. Then I rebuilt it in about another month. It wasn't all me, but Mercurial claimed I wrote 85% of it. I really liked that job. It was in Lisp again. Lisp makes me happy and productive.

I wrote a 2D game framework built on Cocos2D and then used it to write the first three titles in the LearningTouch FirstWords series of products on iOS. LearningTouch was founded by Clozure Associates, the people who maintain Clozure Common Lisp. They're about the best people I know on several different axes.

I worked for a while on the CRASH-SAFE part of the CLEAN-SLATE computing initiative, Peter Neumann's galactic plan to reinvent computing to actually be somewhat reliable and secure. That was super interesting. I maintained and extended Breeze, an interpreter for a programming language with extremely aggressive security and integrity proofs built into it. It was written in Haskell. I like working in Haskell almost as much as working in Lisp.

I wrote another games framework for iOS that was used to develop a set of proof-of-concept games for a DARPA-funded STEM project meant to create games to educate the general public about what various federal agencies do for a living. I wrote most of that in Objective-C, but the rules engine and game-data compiler were written in Bard, a Lisp that I designed.

I wrote a multiplayer networked game called the Fabric, based on my own science fiction stories and written in Scheme, using the Kawa compiler and the JMonkeyEngine game engine. Per Bothner, Kawa's author, presented a paper about that work at the 2015 JavaOne conference.

Right now I'm working on a social network with some novel features invented by a Xerox PARC researcher. It's written in Lisp again.