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.
lcc-ffigen.tar.gz and
ffigen.tar.gz
for macro for Common Lisp is available here.
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.
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 http://www.gwydiondylan.org. 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.
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 linux.org 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 lispos-request@math.gatech.edu. Unfortunately enough, apart from some discussions nothing seems to have come out of this project.