I do not have the time to properly maintain this page. (No, this is not news, it has been this way since, oh, just about forever). However I sometimes put some links to software packages that might be of interest here.

30.11.2002 I can no longer find a link to the version of ffigen that I use. (This is a patched version built on top of lcc-4.1.) So here are newer versions of lcc-ffigen.tar.gz and ffigen.tar.gz

28.11.2002: A Common Lisp (actually CMUCL) backend for the ffigen program is available here.

21.02.2002: An implementation of a generic for macro for Common Lisp is available here.


Programming Languages

Common Lisp

Common Lisp is a modern dialect of Lisp that is the result of a standardization effort of several Lisp vendors. Common Lisp is a large language but this has the advantage that many things that a programmer needs are already present in a standardized way in a CL system. Because it needed to maintain a certain degree of backward compatibility CL may not be the most elegant variant of Lisp available, but it is a very efficient tool to get real work done. Common Lisp is the Lisp dialect that has the best commercial backing from several vendors and that is an approved ANSI standard. It offers support for imperative and functional programming and includes a very flexible object system called CLOS; most implementations support a meta object protocol as well.

Commercial Common Lisp implementations are available from Franz Inc., Xanalys, Corman, from Digitool and from other vendors. Good free implementations are CMU Common Lisp and CLisp.

You can obtain a lot of information about Lisp from the Association of Lisp users.

One of the main advantages of Common Lisp is its incredible flexibility. It offers support for procedural, functional and object oriented programming "out of the box" and it is easy to incorporate different programming paradigms in a seamless way. Following an exchange in Usenet I have written a little package that provides support for Design by Contract in Common Lisp. You can get if from here, and I have included some (useless) examples as well. I have also written several test frameworks which are somewhat similar to Kent Beck's Smalltalk test framework. You can get the source code for a old version and a file that shows the test framework in action. To run the test suites, load the two files and type (run-all-known-tests) in the listener. You can optionally supply one of the keywords :silent, :verbose or :gabby to control the amount of output generated. If you are interested in my (much improved) new test framework, send me mail.


Dylan is a dynamic object oriented language developed by Apple Computer. It is inspired by Common Lisp and its object oriented extension CLOS but the parenthised prefix notation of CL is gone and replaced by a more conventional algebraic infix syntax. More important, however, is the fact that in contrast to most other Lisp dialects the Dylan language has been designed to allow efficient compilation into small and fast stand-alone binaries.

A free Dylan compiler was developed by the Gwydion project at CMU. At the moment the envisioned high performance compiler is not available but you can use their Mindy byte-code compiler and interpreter and their d2c compiler to learn about Dylan. While d2c doesn't produce blazingly fast executables it produces binaries that might be suitably fast and small for some real word tasks. A group of volunteers has taken over the development of the Gwydion compilers. You can look at their efforts at Currently they are working, among other things, on improving the Melange interface generator and allowing callbacks from C to Dylan. Once this is done it will be possible to interface to the most common widget sets and implement DUIM for Gwydion.

Functional Objects Dylan is now Open Source! The full development environment is available for Windows, the console compiler has been ported to Linux. You can get it from the Gwydion web site..


Here is the not-yet-working wrapper for the Gtk toolkit

I have written a test framework similar to Kent Beck's Smalltalk test framework and JUnit. If you don't happen to use my patched version of d2c you have to use the disabled version of the function print-failure (at the end of the file test-framework.dylan), the original version outputs a more meaningful error message for uninitialized slot accesses.

Here is a simple class browser for Dylan programs. You need STk to run it.

Here is the old manual for prefix Dylan. I have some material about restarts which might be useful since there is very little information about them in the literature for Dylan. I have included a simple implementation of Scheme's delay and force which might also be of interest because it implements a forward iteration protocol.


Like Common Lisp, Scheme is a dialect of the Lisp family. But unlike CL, Scheme is a very small language; but that doesn't mean that Scheme is a toy language. It offers few different concepts, but these are kept as general and with as few restrictions as possible. There are many implementation of Scheme available, most of them developed at universities but also a few commercial implementations. Guile is an implementation of Scheme that is used as extension language for programs from the GNU project.

A nice interpreter for an extended version of Scheme (featuring an object system with meta object protocol and an interface to the Tk toolkit) is STk. A quite efficient batch compiler for Scheme is Bigloo which, unfortunately, doesn't offer STk's nice object system (instead it offers a, in my opinion, rather unpleasant to use object system based on Meroon) but delivers rather efficient applications.


Eiffel is an object oriented language offering support for Design by Contract. It was developed by Bertrand Meyer to address some of the problems that software engineers face when developing complex software projects. Unfortunately Eiffel offers almost no support for introspection or meta programming, but since this means that it is possible to generate very efficient and small executables it is a good language for projects where currently languages like C++ are used.

Following an exchange in Usenet I have written a little package that provides support for Design by Contract in Common Lisp. You can get if from here, and I have included some (useless) examples as well.

Operating Systems


Linux is a free Unix clone. Starting out as a simple one-person project it has grown to be a very reliable and efficient operating system. It is supported by several companies and volunteer organizations and offers a wealth of (free and commercial) applications. See for more information.


Some people have started discussions about developing a Lisp based operating system. Their implementation is to be based on CMUCL and the Flux toolkit. Check out the archive of the mailing list for further information. You can subscribe to the mailing list by sending mail to Unfortunately enough, apart from some discussions nothing seems to have come out of this project.

Open Implementation

See this page for further information.


This section is even more rudimentary than the preceding one about computers.

Proof Theory

What is proof theory? Proof theory is a part of mathematical logic that is concerned with logic from the syntactical viewpoint. One might claim that proof theory is concerned with the relationship between infinite objects and finite proofs. It originated with the foundational crisis and the dispute between D. Hilbert and Brower about the foundations of mathematics.

Lambda Calculus

The lambda calculus is a theory about functions viewed as computations rather than graphs. There exist untyped versions as well as typed versions of the calculus. Especially the typed variants are used to study principles of computability and foundations of programming languages. There is a close correspondence between some typed lambda calculi and systems of intuitionistic logic known as Curry-Howard isomorphism.
Matthias Hölzl (tc)
Last modified: Fri Feb 22 02:21:00 CET 2002