ANSI Common Lisp seems to be a language with enough features and high-quality implementations available to be considered quite useable for high-performance production programming.

• Tutorials, Intros, Reference material
  • [On Lisp] (book)
  • [FAQ for comp.lang.lisp]
  • [Idiot's Guide to Packages]
  • [MERL - Some Useful Lisp Algorithms, Part 2]
  • [Highly Opinionated Guide to Lisp]
  • [Pathnames Quick-Start and Reference]
  • [Practical Common Lisp], Peter Seibel's introductory Lisp book. Highly recommended. Hard copy can be borrowed from DWM.
  • [Successful Lisp] (book, toc)
    • [Professional Track]
  • [The Common Lisp Cookbook]
  • [Getting Started], a short but interesting page on CLiki. Note the example setup files for configuring a Lisp environment.
  • [Common Lisp Object System]
  • [Common Lisp HyperSpec], aka CLHS, an online version of the language standard.
  • [Lisp Starter Pack] (for Windows)
    
    
• Build systems (aka defsystems) and installation systems
  • [A Tutorial for ASDF-INSTALL]
  • [Fight The System]
  • [Installing & Using Windows Common Lisp Controller]
  • [ASDF manual] -- Looks somewhat better than the readme.
    
    
• Libraries, interlanguage binding tools
  • [Verrazano], a Common Lisp binding generator for C/C++ interfaces.
  • [RDNZL], a Lisp library that provides interoperability with the .NET framework. Hmmm...!
    
    
• Testing tools:
  • [ClickCheck] test generator
  • Peter Seibel's [unit test framework]
    
    
• Blogs, wikis, forums, societies
  • [CLiki]
  • [Bill Clementson's blog]
  • [CL Gardeners], a group of people working to address some of difficulties commonly encountered by people that try to adopt Lisp for development.
    
    
• Misc.
  • [Cardinal Rule]
  • [Generators]
  • [Hierarchical Packages] (Franz Lisp extension)
  • [A nice example] of decoding network packets with Lisp. I've only read the first page, and already learned some things about Lisp coding style.
  • [Usenet discussion] about building a game engine for Lisp. Pointers to useful libraries and extensions to libraries. Cf. Kenny Tilton's reference to his callback extensions for UFFI.
  • [The Lisp Lesser Gnu Public License] -- This is a copyright license written by Franz Inc. that consists of a preamble to the LGPL, plus the LGPL itself. The preamble recognizes the fact that Lisp libraries can rarely be built as DLLs, so direct linking into an executable is allowed. The resulting program is not subject to the LGPL, but the source for the LLGPL portion of the program must still be made available. Many Lisp libraries apparently use this, and the conditions seem to be acceptable for commercial program development.
  • [Association of Lisp Users' (ALU) wiki]
  • [Lisp Information], a collection of interesting info about Lisp.
• [Equal] -- what does the concept really mean? Why does Common Lisp have so many different functions for determining equality?
• [Tips for using SLIME]

Implementations for Windows

• [Corman Lisp] - Inexpensive - $250. You can try the IDE for 30 days free, and the rest of this system is free for non-commercial use. This implementation of Lisp never interprets code; it always compiles, like a Java JIT compiler.
  • [Discussion boards]
  • [Third-party patches] and instructions to get partial ASDF functionality for Corman CL. This highlights why I can't recommend CCL at this time -- too many deviations from the CL standard, which impede the functioning of useful third-party libraries. A pity, because the compiler seems quite good.
• [CLISP] - Open source. "Compiling" produces byte-code. Less attractive for this reason. Also, copyright restrictions unclear. Soe involvement w/ GPL, dispute exists over whether this extends to user programs or can be circumvented.
• [Allegro Common Lisp] by Franz Inc. - This vendor has been in the Lisp business forever. "Franz Lisp" was well-established even in the eighties. Allegro has an IDE for Windows. Redistributing applications requires a licensing agreement, possibly including a percentage of product revenue. Bleh. A personal-use edition is available for free download, requiring periodic (free) license renewal.
• [LispWorks for Windows] by LispWorks Ltd. (formerly Xanalys) - Includes an IDE. The "Professional Edition" is required for royalty-free redistribution of applications - $999. A [Personal Edition] is available for free download.
• [ECL] (Embeddable Common Lisp) This is a Common Lisp interpreter designed for embedding in other programs. It can be compiled via C; i.e. compilation generates C code that can be compiled and linked. I'm not sure exactly to what extent it is compatible with Windows; it claims to compile using gcc, and I've read elsewhere that it supports Cygwin. If it generates reasonably standard C, I suppose it could be hacked to work with other compilers.

Libraries

• [Lisp-Stat] (Can this really be used as a library, or is it an application?)
• [Libraries] from CMU's Artificial Intelligence department.

Discussions about Lisp

• [Kent Pitman answers] questions about Lisp on Slashdot.
• [Kent Pitman answers more] questions about Lisp on Slashdot.

Reviews

General comments on Lisp

(Based only on reading and experience with Corman so far.)

Upsides:

• Lisp is incredibly flexible. There are few language features from your favorite language that you won't find in a powerful form in Lisp.
• Modern commercial Lisps can apparently generate very fast code. Lisp is generally manifestly typed (meaning that type information resides with values rather than variables, and is checked at run-time). This makes development easier but slows program down. In Common Lisp, you can optionally specify type restrictions on variables. A good compiler will use this information to generate tighter code. So there's a clear path for speeding up code as it solidifies and as bottlenecks are identified.
• Common Lisp has a number of built-in data types that are more efficient than traditional list structure - particularly hashes and arrays.
• The Common Lisp Object System (CLOS) allows you to do object-oriented programming. It's a little different from what you're used to, but more powerful IMO. Member functions are replaced by multimethods, which are potentially much more useful, especially for something like a physical simulation.

Downsides:

• GUI programming looks like it might be a pain.
• DirectX programming would largely be restricted to either the C or COM interface.
• Most commercial Lisps are pretty pricy if you want to redistribute applications, or there are restrictions on what can be redistributed. Part of the reason for this may be that it's easy to expose the entire Lisp interpreter to end-users, so vendors have to be careful that they're not letting you redistribute the whole enchilada.
• You have to get used to parentheses -- but it's not so bad if you use a decent editor.

Corman Lisp

The IDE is not very impressive (bordering on cheezy), but is usable. (Although version 2.5 seems to have some annoying bugs which will hopefully be cleaned up soon.) The compile-only technology is interesting. Whenever you define a function, it gets compiled immediately. Unfortunately, the compiler does not appear to inline floating-point operations, which could be a real liability.

The debugger follows the traditional Lisp text-based model, i.e. it's clunky. One downside to the compile-only technology is that you can't really step into functions - you can just debug calls and returns. Some information about context for each call on the stack is available (local variables and such), but it's hard to interpret.

Building applications is easy -- start Corman Lisp, load the files that are part of your application, and call SAVE-APPLICATION with a few arguments. Voila, you have an executable file.

Corman Lisp includes a bunch of tools for interacting with Windows. Setting up interfaces to C and COM looks a bit messy, but easy to use once done. There are also tools for embedding assembly language in Lisp.

Comes with the source code for everything except the IDE! Some of it is C++, but a surprising amount is written in Lisp itself, using some implementation-specific extensions. Having all the source opens up some interesting possiblities, I suppose.

All in all an interesting product, but with some real shortcoming. Perhaps you get what you pay for?

A note on development environments

I use XEmacs as my primary editor. I initially played around with ILisp, an Emacs package for interfacing with an external Lisp interpreter. It was a mess, and very hard to get it working with Corman. Now I use Slime, which is under active development, and works great -- but not yet with Corman Lisp. I'm using it quite successfully with the trial version of Allegro Common Lisp.

Emacs editors, by the way, use a form of Lisp as extension language. Emacs-lisp (sometimes call elisp) is based on very early Lisps, and is very different from Common Lisp in many ways. For instance, elisp has only dynamic scoping of variables, no lexical scoping. However, there are enough similarities that basic "Lisp-think" transfers between elisp and Common Lisp fairly easily.