Troels' Common Lisp Page


  1. Introduction
  2. Common Lisp Interface Manager (CLIM)
  3. Resources


Welcome to my page about Common Lisp, the programmable programming language. I am supposedly a smug Lisp weenie, though I suppose that my belief that Common Lisp is not the most elegant programming language, only the most practical, will probably result in my weenie-status being revoked. Paradoxically, Lisp is one of the oldest programming languages still in use, and it still has features not matched by many other, so-called "modern," languages.

It is hard to provide a single, succint answer to why I find Common Lisp so appealing - I suppose I could say because it trusts the programmer, but that would be so general an answer as to be useless. It is more likely a sum of the inherent flexibility of code represented as lists, and the philosophy prevalent in the Lisp community of trying to do the right thing, and giving the programmer the tools necessary to do this. Features such as metaprotocols, compile-time code manipulation, runtime-generation of code, functions as first-class objects, symbols and good introspection facilities all contribute to form the amazing experience that programming in Common Lisp is. It is certainly hard to go back to programming in other languages once you have tried Common Lisp, though one must, of course, keep an open mind. Of course, Common Lisp is not perfect, and one of its greatest defects may be its apparently sluggish pace of change, when compared to more "hip" languages such as Ruby. I suppose that is a consequence of Lisp's decades-old history, though.

I started looking into Common Lisp in April, 2005, when Peter Seibel's excellent book, Practical Common Lisp, was released, though I had been using Emacs Lisp since 2004. Having been an avid GNU Emacs-user for a time, I quickly became interested in reimplementations of Emacs in Common Lisp, an interest that eventually led me to CLIM.

Common Lisp Interface Manager (CLIM)

Common Lisp Interface Manager, or CLIM, is a protocol for building rather graphical user interfaces (GUIs) in Lisp. The GUIs produced are very different from the concept that most people associate with the word, but they embody some very fascinating concepts, and a potentially very productive workflow, so it caught my interest. There is a free implementation of the CLIM specification available, McCLIM, which is the one I use when writing CLIM-based applications. These days, I spend as much time working on McCLIM itself as using it to write CLIM applications, but that's not too bad - it's an interesting piece of code. McCLIM is, in my mind, the best available toolkit for writing Lisp GUIs, though it is rather opinionated, and the GUIs it creates are not like anything you are likely to see anywhere else. Still, neither is Lisp itself.

Here is a list of CLIM applications that I have written. Usage instructions are in the source (this means that they are not intended for use by non-CLIMers), and you are expected, and required, to manually compile and load the files (no system definitions are provided). They all implicitly assume availability of the facilities provided by CLIM-desktop.

Process Browser

This is a CLIM-based process browsing- and management-tool, that enables the user to navigate a list of running processes in the Lisp image. Functionality is provided for destroying, inspecting, breaking and snooping (by running an interactive Listener in a given thread). It works best under SBCL, but if you install BORDEAUX-MP, it will likely work under your Lisp as well. It is very much a WIP. The source

Error Logger

Error Logger may be too strong a word, this "application" is a simple frame, that, upon launch, redirects *error-output* to its embedded pane. It can be very useful, but its simplicity can also make it a danger, if you manage to close it without having *error-output* reset to an existing stream. The source


As stated previously, I'm a fan of Emacs, and I eventually got interested in implementations of Emacs in Common Lisp. The one that seemed most alive was Climacs, which I started trying out and fixing some small bugs in. Eventually, Climacs also made me interested in general CLIM, and I became a developer on both projects. Climacs is not designed to be an entire environment, the way GNU Emacs is, but instead be a powerful editor working together with other CLIM applications in a whole-Lisp hacking environment. Climacs is based upon an editor substrate called Drei that was initially forked from Climacs code, but now available to all CLIM programs. While Climacs already has some nifty features for doing Lisp development, it's not quite ready for prime-time yet, though most truly major problems have been solved. Still, it's quite fun to hack on, the code being well-documented, commented and readable, so if you're just dying to write code for an Emacs in a sensible language, you're more than welcome to contribute to Climacs (or Drei).

Climacs can look really cool if you invoke it as (climacs:climacs-rv) instead of (climacs:climacs). Alternatively, if you care a lot about flashy screenshots showcasing dubious functionality, take a look at JPEGs in Climacs.

Simple Grapheditor

This is a port of an old CLIM program found in the CMUCL AI repo called simple-graphedit.lisp (available here). I updated the program to work on McCLIM and fixed a number of bugs. The porting mostly considered of replacing usage of symbols internal to the CLIM-INTERNALS package with a more well-defined alternative. You can get the source-code here.


Common Lisp has a lot of online resources for both the beginner and the expert.

Troels Henriksen Back to index