Practical Lisp Programming

Setting up a Lisp system is more work than just downloading a Common Lisp implementation. To use Lisp productively, you might want to have an editor which understands Lisp and which can talk to your Common Lisp (CL), you want important documentation available at a fingertips, you want to be able to use and manage Lisp packages written by others.

This tutorial is a work-in-progress. The following is a possible outline:

Choosing your Common Lisp implementation. Briefly review Debian Free Software Guidelines (DFSG), free Common Lisp implementations (CLISP, CMUCL, SBCL, ECL, GCL, OpenMCL -- others?) and how to install these Lisps on Linux, Windows and Mac.
Could/should this section include reviews of the free versions of commercial environments as well, despite CLiki charter? Also, maybe links to installation instructions per implementation would be better. If the instructions for some are deficient, then contributing to those might be better then duplicating the information here. Also, linking to the CLiki page for the implementation and putting the review there might be more maintainable.-- Nikodemus
Setting up your editor. Covers Emacs, ILISP, CLtL2, the Hyperspec.
Packages. CL's package system is not easy to understand for beginners. There are tools which help.
Important libraries. Some libraries are just a must for serious programming.

Implementations

See Common Lisp Implementations for more information. On UNIX and similar platforms CMUCL and SBCL can be recommended, OpenMCL on Macs, and CLISP almost anywhere.

If you decide for using CMUCL under Linux there already is a tutorial which covers how to set it up. It is located here. If you decide for a Windows environment the Common Lisp Cookbook has some information availabe here.

Setting up your Editor

In principle you can use any editor to edit Lisp source code, save it in a file which you load and execute in your favourite Lisp. Unfortunately, you lose much of the interactive, fast-paced Lisp-programming feeling that way.

You probably want to do better than that: First, you really want your editor's assistance for counting parentheses and indenting your source code. Second, you want to be able to "connect" your editor's buffer to your Lisp implementation. This way, you type in a Lisp definition and execute it immediately to see its consequences, eliminating the save-load-execute cycle and so helping to develop better tested applications faster. Finally, you want some key references available at your fingertips. If you can't remember if one calls (nth n list) or (nth list n) or what the routines are which implement set-handling operations on lists you can quickly look it up without having to take your fingers from the keyboard.

Right now, most serious Lisp programmers will use either an IDE which comes with their Lisp implementation or will resort to emacs. Emacs can be extended by packages programmed in its own Lisp dialect - one such extension is ILISP which nicely answers all the challenges stated above: It understands Lisp syntax, it connects to a variety of Common Lisp and Scheme implementations, and it allows fast access to two important references: The Common Lisp Hyperspec and Common Lisp the Language, CLtL2, both available online.

ILISP comes with instructions for installation. In short, once you downloaded and installed the package files, you want to tell emacs where to find these files, to load them as soon as a Lisp source file is opened in the editor, and where online documentation is located. The following lines (in the .emacs file in my home directory) works for me:

;; tell emacs where to find the sources
(setq load-path (cons (expand-file-name "/local/share/emacs/ilisp/")
                      load-path))

;; tell emacs about CMUCL:
(autoload 'cmulisp     "ilisp" "Inferior CMU Common Lisp." t)
(setq cmulisp-program "/local/bin/cmucl") ; name of CMUCL program file (this may be /local/bin/lisp on your system)

;; tell emacs to auto-load ilisp when a lisp source file is loaded
(set-default 'auto-mode-alist
             (append '(("\\.lisp$" . lisp-mode)
                       ("\\.lsp$" . lisp-mode)
                       ("\\.cl$" . lisp-mode))
                     auto-mode-alist))
(add-hook 'lisp-mode-hook '(lambda () (require 'ilisp)))

;; tell emacs about online references
;; (you can also download these references and store them locally)
(setq common-lisp-hyperspec-root
      "http://www.lispworks.com/reference/HyperSpec/")
(setq common-lisp-hyperspec-symbol-table
       "/local/doc/HyperSpec/Data/Map_Sym.txt") ; I had to download this file and store it locally on my disk
(setq cltl2-root-url
      "http://www.uuhaus.de/cltl2/")

(add-hook 'ilisp-load-hook
          '(lambda ()
             ;; Change default key prefix to C-c
             (setq ilisp-*prefix* "\C-c")

             (message "Running ilisp-load-hook")

             ;; Set the inferior Lisp directory to the directory of
             ;; the buffer that spawned it on the first prompt.
             (add-hook 'ilisp-init-hook
                       '(lambda ()
                          (default-directory-lisp ilisp-last-buffer)))
             ))
;; Use Konqueror instead of Netscape (loads faster on my system)
(setq browse-url-netscape-program "konqueror")
;; Another good browser is w3m, a text-mode browser that can be used via Emacs.
;; To browse with w3m, uncomment the following line:
;(setq browse-url-browser-function 'w3m-browse-url)

Depending on your local setup you may have to make some modifications to the code above. Here the installation instructions which come with ilisp really help. Once it's done you have a comfortable and professional Lisp programming environment available.

Packages

Here is a link to a tutorial by Henrik Motakef on defsystem.

---I'm a beginner myself. I know that this stuff is important (esp. for people who do not have a Lisp-guru next office), and it is not covered at too many places, but I also have to collect the information. So this is work in progress. Feel invited to join!

Some suggestions, then

Put your name on your edits, so that people know with whom they are dealing
There's a difference between asking for contributions, and (what appears to be the case here) asking people to write it for you. If you don't have any actual information yet, reshape this page to make it obvious that it's a work in progress, which bits you're going to write yourself, and what you're hoing that other people will contribute
The CL Cookbook is a related project that very likely already covers a lot of this stuff. You should definitely look at that first.

This page is linked from: Getting Started Online Tutorial

CLiki pages can be edited by anyone at any time. Imagine a fearsomely comprehensive disclaimer of liability. Now fear, comprehensively