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.
You can obtain a lot of information about Lisp from the Association of Lisp users. A hypertext version of the standard (the HyperSpec) is extremely useful if you want to do any serious programming in Common Lisp. The online tutorial Successful Lisp is often recommended as a good introduction.
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.
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.
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 Developer (formerly known as Harlequin Dylan) is now Open Source! The full development environment is available for Windows, the console compiler has been ported to Linux. You can get more information from the Gwydion Dylan web site. You can get a current build here: fundev-win32-2005-06-12-tc.exe, fundev-win32-2005-06-27-tc.exe.
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.