Today, as I announced earlier, the Corman Lisp 3.1 has been released after more than a decade-long break. Somehow it happened that I am one of the active maintainers of the Corman Lisp, so, I think, it might be appropriate to make a post on this site about how I became a maintainer, what motivated me to work on it and why I believe it is important. You will not find the release notes here because I think it is not the right place to post them. If you have at least mild interest in this implementation, I would suggest you to continue reading.

Some time ago I stumbled upon a non-supported Common Lisp implementation on Github, Corman Lisp. It was in a bad shape - it did not work well on the modern, 64-bit versions of Windows and the project's solution needed a bit of cleaning. I should note that I am genuinely interested in Lisp, compilers, programming languages and their runtime environments. Additionally to that, I possess some knowledge of Windows application programming interface, a skill which not every system programmer, interested in open source development, seems to have. The project seemed to fit my interests well, so I decided to look at it more closely.

Three days later I fixed a very annoying bug which made it possible to use the software on the 64-bit versions of Windows and things started to look even more interesting: it turned out I can work on such a complex system and make important changes to it. I should note that this was kind of an act of insight, to this very day I do not understand how I managed to fix it. Later Roger Corman, the original author, contacted me via Github, thanked for fixing this and returned to the project.

Additionally to that, I understood that this project is very important from the educational perspective. This is a fairly complete Common Lisp implementation which is easy to study and might give one interesting inside on how to build a working, high-performance environment for a dynamic programming language which includes, among other things, a native code compiler and a garbage collector. I realised that if I am able to understand how it works, then someone else can do that too. For me, it was a major turning point. Then I contacted Zachary P. Beane (a.k.a. Xach) who gave me the write permissions to the repository and I became a co-maintainer of the Corman Lisp.

Later Luis Cervantes joined the project and made a lot of valuable contributions.

There are multiple reasons why I believe that maintaining Corman Lisp is important. I am going to describe the main ones in more detail.

In my opinion, Common Lisp is not a hard programming language to learn, especially comparing it to such a language as C++. What is hard is getting the proper environment at the beginning. Here a potential newbie typically has the two general recommendations from the community.

The first one is to use Emacs+SLIME+SBCL (or Clozure CL, …). I should say that this is what I, and most of the other Common Lisp programmers, use most of the time and for a reason: it is an incredibly powerful development environment, probably the best one among environments for the dynamic programming languages. On the other hand, it might be difficult to set up and Emacs might seem weird for a beginner. It takes some time to tame it. In fact, to manually configure Emacs as a Common Lisp development environment one should be familiar with another Lisp (Emacs Lisp).

To overcome this issues a newbie must not lose the spark of interest from the very beginning. For someone, this experience might be overwhelmingly frustrating. It should be noted that such a user might be potentially a good programmer, but he or she just happens to have a somewhat different background. The fact that there are some projects which bundle Emacs preconfigured as a development environment for Common Lisp lowers the entry bar somewhat, but it is not always enough.

The second option is to use a freely available, proprietary, limited version of a commercial Common Lisp programming environment, be it Allegro or LispWorks. Despite the limitations, this option is viable for a beginner who wants to try some Common Lisp if he or she does not mind the limitations. There is always an option to move to another development environment after the initial learning phase.

From analysing the options above it becomes clear that there is a niche for an easy to install, open source Common Lisp implementation which provides a familiar environment for the most commonly used operating systems - Windows. The fact that Corman Lisp is one of the few implementations which have its own integrated development environment makes it a good candidate to fill the niche. Lowering the bar of entry is important, as it might help to attract more users to the Common Lisp. In my opinion, it is something which it desperately needs.

I should say that lowering the entry bar for a beginner is one of my main motivations behind contributing to the project.

One of the more interesting characteristics of the Corman Lisp is that it is incredibly compact, while it still provides all the major features of a Common Lisp. Its runtime, the Lisp kernel, is one of the most compact ones, yet it contains all the important parts of an efficient implementation of a dynamic programming language.

The fact that I was able to start making important changes to it in a relatively short time says a lot.

Although there are few very good Common Lisp implementations available, both open source and proprietary, Corman Lisp has some features which are not always available elsewhere:

  1. It can be used to create dynamic link libraries (DLLs). It is possible to develop the plug-ins to the existing applications on par with C.
  2. Corman Lisp kernel has the interfaces for integration into the other C++ applications as a scripting engine. It does not force you to write the whole application in Common Lisp.
  3. A Corman Lisp's heap image can be dumped and restored without restarting the process. There are not many implementations which allow this.
  4. It is possible to reuse C definitions directly from header files. It is very handy when building Lisp bindings to the C libraries.
  5. Corman Lisp is one of the few implementations which feature its own integrated development environment.

The fact that Corman Lisp is 32-bit only limits its use cases. Nevertheless, it has a lot of interesting features which make it convenient in some cases where using other implementations is hard or even not possible.

Probably Common Lisp has the highest number of implementations to the number of users ratio. It contrasts to most of the other dynamic programming languages which typically have one reference implementation. I think that it is a result of being defined through a standard which thoroughly describes the programming language rather than a sign of the simplicity of the language itself.

Most of the implementations started as commercial products or their development was initially supported by a government because such a project typically requires a lot of effort and needs good financial support. This is a result of Lisp being a programming language which requires non-trivial programming techniques to be implemented efficiently. This fact alone makes any available Common Lisp implementation a valuable technical achievement.

Corman Lisp is not an exception here. It is a bit different though, as it was mostly developed by one person. Taking into consideration how much effort it takes to develop a usable Common Lisp implementation, it is a very valuable achievement as doing it this way surely needed the different approaches. A curious individual might learn a lot from studying it, doing so reveals a lot about how to individually develop a non-trivial project.

You might like a video in which Roger Corman reveals his motivation behind starting the project as well as provides some technical details about it.

After reading the information above you should understand why I think that maintaining Corman Lisp is important. I believe it is a good implementation which, as it was mentioned earlier, very compact and, thus, open for innovation and contributions. It surely has its downsides but it can be iteratively improved to a more usable state. It is also extremely easy to start working on.

While working on it I gained interesting experience as doing so required some knowledge which I had no chance to gain anywhere else. As it turns out, there is no need to be a programming rock star to do meaningful work on a non-trivial project. When I started working on the project I did not know Lisp very well and now I am only moderately better.

The fun continues and I am looking forward to what goes next!