An Introduction and Tutorial for Common Lisp

Note that some of the documents are in PostScript. If your WWW browser cannot display PostScript, they can still be saved and printed.

Table of Contents

• Lisp-Related Books.
• Online Lisp References.
• Issues for Lisp Beginners and Advanced Beginners.
• Issues for Intermediate/Advanced Lisp Programmers.
• CLOS.
• Internet Lisp Resources and Free Lisp Implementations.
• Lisp-Related Papers.
• Misc.

Lisp-Related Books

Find More Books

• Basic Common Lisp Programming
  • No AI Slant: Moderately Fast-Paced: ANSI Common Lisp by Paul Graham. The best introduction to Common Lisp as a general-purpose programming language. A bit hard going for inexperienced programmers, however.
  • AI Slant: Lisp by Winston and Horn. The classic AI applications in Lisp text.
• Advanced Common Lisp Programming
  • No AI Slant: On Lisp: Advanced Techniques for Common Lisp by Paul Graham. Amazingly deep coverage of macros and closures.
  • AI Slant: Paradigms of AI Programming: Case Studies in Common Lisp by Peter Norvig. My single all-time favorite Common Lisp text.
• CLOS
  • Object Oriented Programming in Common Lisp: A Programmers Guide to the Common Lisp Object System by Sonya Keene.
• Lisp References
  • Common Lisp: The Language by Guy L. Steele Jr. The definitive reference prior to the release of the ANSI spec. Look up "kludges" in the index for some good geek humor. My other favorite is the "BOA constructor" business.
• Scheme (really programming and algorithms)
  • Structure and Interpretation of Computer Programs by Abelson, Sussman, and Sussman. One of the best Computer Science texts I've ever seen. More good stuff in the footnotes than in the entire contents of most other books.
• Artificial Intelligence (roughly in order of preference)
  • Artificial Intelligence: A Modern Approach by Russell and Norvig. If I had to pick one AI text, this would be it.
  • Essentials of Artificial Intelligence by Matt Ginsberg. Entertaining and concise introduction to the best-established areas of AI.
  • Artificial Intelligence Theory and Practice by Dean, Allen, and Aloimonos. A good AI book that includes some coverage of (and examples in) Common Lisp.
  • Artificial Intelligence: Structures and Strategies for Complex Problem Solving by Luger and Stubblefield. If you want a good AI book that includes some coverage of Lisp and Prolog, this is the one for you.
  • Artificial Intelligence by Patrick Henry Winston. The classic reference. A bit heavy on the topic of learning.

    Find More Books

• Java and Web Programming.
  OK, ok, so these don't have anything to do with Lisp. But I couldn't resist.
  • Recommended books on Java, Ajax, JavaScript, and Web programming.

Online Lisp References

• HyperSpec. An HTML version of the official ANSI specification for Common Lisp. From Kent Pitman and Harlequin Inc. Not a tutorial, but completely defines every function, variable, and construct all of Common Lisp.
  • Table of Contents.
  • Highlights (alternate Table of Contents).
  • Master Index.
  • Index of all words in Common Lisp (variables, function names, etc).
• Common Lisp: The Language (2nd Edition, HTML version). This was the official language definition prior to the release of the ANSI Specification, and is still a useful reference.
  • Table of Contents.
  • Index.
  • Intro/Overview.
• The draft ANSI specification for Common Lisp (PostScript by sections). For online access, use the HyperSpec., but the final ANSI spec is not available free in PostScript.
• On-line guide to the CLOS MOP (Meta-Object Protocol).
• How to access Common Lisp: The Reference from the local machine (apl.jhu.edu users only).
• User's Guide for CLIM 2.0. CLIM is the Common Lisp Interface Manager, a graphics library supported by several different vendors. User's Guide is from Harlequin.
• A short bibliography of Lisp references. Also available in PostScript.

Issues for Lisp Beginners and Advanced Beginners

• A one-page summary of the most basic Lisp constructs (PostScript).
• Some thumbnail summaries. The PostScript versions are one page.
  • When to use or not use quote.
  • cond, let, and let*. Also available in PostScript with brief loop info on same page.
  • loop. Also available in PostScript.
  • format, Lisp's answer to C's fprintf. Also available in PostScript.
  • Structures and defstruct syntax. Also available in PostScript.
  • backquote (PostScript).
  • CLOS. Also available in PostScript.
• Very brief summary of how to interact with Lisp from within emacs. See the PostScript emacs handouts (Quick Reference Sheet and Intro) for more details.
• Slightly more detailed summary of how to interact with Lisp from within XEmacs and GNU Emacs, under X-Windows or on dumb terminals. See the PostScript emacs handouts (Quick Reference Sheet and Intro) for more details.
• Even briefer summary of using vi for Lisp. How to blink parens and do auto-indentation.
• Capturing the results of an interactive Lisp session. I.e. how to save the results of testing to file. This gives Lisp-specific (dribble), UNIX-specific (script), and emacs-specific methods. In all cases, use of the Show-Output macro will make it easier to save the test cases.
• The convention of putting "*"s around global variable names in Lisp.
• A simple Common Lisp implementation of Towers of Hanoi.
• A Common Lisp implementation of the N-Queens problem. Finds a solution to the N-Queens problem for any N 4 or greater. The solution can be found in linear time (constant time per queen), although printing out the board takes O(N^2) time. But no search is involved. If you have a Java enabled browser, visit http://www.apl.jhu.edu/~hall/NQueens.html to see an interactive version of this in Java.
• A very brief example of using the Common Lisp sort function.

Issues for Intermediate/Advanced Lisp Programmers

• An introduction to some higher-order Common Lisp functions. Higher-order functions are ones that use other functions as arguments. Passing functions around in Lisp is one of its distinctive features. Also available in PostScript.
• A macro called Show-Output that lets you save test cases. Using Show-Output is not at all difficult: you just supply Lisp forms and each form is printed out along with the return value of the form. But writing it requires a basic understanding of Lisp macros.
• Some hints on benchmarking Lisp code (PostScript).
• A set of simple timing/metering functions in Common Lisp.
• Destructive operations and list performance. Also available in PostScript.
• An introduction to Common Lisp macros. Macros are forms that generate Lisp code. Also available in PostScript.
• Guide to good Lisp style (PostScript). From Peter Norvig and Kent Pittman's LUV-93 tutorial.
• Jeff Dalton's list of Common Lisp pitfalls. Most are for the advanced user.
• VT100 cursor control from Lisp.
• A Short Ballad Dedicated to the Growth of Programs (by Ashwin Ram).

CLOS

• A thumbnail summary of CLOS. Also available as a one-page PostScript file.
• Introductory CLOS lecture notes. Also available in PostScript.
• Common CLOS Blunders (PostScript).
• Some details on defclass. Also available in PostScript.
• Some details on defgeneric. Also available in PostScript.
• A simplified interface to defclass. The Def-Class macro lets you type

  (Def-Class Class (Parents)
    (Slot-1 Val-1)
    (Slot-2 Val-2)
    Slot-3)
  

  and get the effect of

  (defclass Class (Parents)
    ((Slot-1 :initform Val-1 :accessor Slot-1 :initarg :Slot-1)
     (Slot-2 :initform Val-2 :accessor Slot-2 :initarg :Slot-2)
     (Slot-3                 :accessor Slot-3 :initarg :Slot-3)))
  

  The Define-Class macro has identical syntax to Def-Class, but it also adds a unique name slot and does some bookkeeping to keep track of instances. It supports Instances to get objects of the given class, Direct-Instances to get objects of the given class but not of a subclass, and several other bookkeeping routines.
• Optimizations in the Symbolics CLOS Implementations. A paper by D. Scott Cyphers and David Moon showing how CLOS could be implemented efficiently.

Internet Lisp Resources

• A free Common Lisp for Windows. This is a version of the popular commercial Allegro Common Lisp for Windows, with some limitations such as limited heap size, no foreign function support, no compile-file, no disassembler, and no image saving (save-image). However, compile is still available and files get compiled as they are loaded (you just can't save the compiled version to disk). Otherwise this is the same version as their commercial implementation. An excellent choice for students with Windows machines at home, and includes an interactive tutorial. This page also allows downloading of a free evaluation copy of Allegro CL for UNIX. Also see the Franz Web Site for more info on this offering.
• Another free Common Lisp for Windows. From Harlequin, Inc., makers of the UNIX LispWorks environment, this is a more limited implementation formerly only for academic use. No compiler.
• A limited-time use evaluation copy of Macintosh Common Lisp 4.0. From Digitool.
• Pointers to other free Common Lisps available on the Net for UNIX, VMS, DOS/Windows, and Macintosh. Extracted from version 1.48 of the FAQ for comp.lang.lisp. See there for the latest details.
• Lecture notes, handouts, and some exercises from Marty Hall's AI Programming class in the Hopkins part-time MS program in CS.
• The Association of Lisp Users (ALU).
• Tulane's Interactive Lisp Tutorial. By Eduardo Villamil.
• Texas A&M Basic Lisp Tutorial. By Colin Allen and Maneesh Dhagat.
• The FAQ (Frequently Asked Questions) list from comp.lang.lisp.
• CMU's Archive of Common Lisp Code.
• Lisp Resources Page from the WWW Virtual Library.
• Source Code from Three Popular Common Lisp Texts.
  • Paul Graham's ANSI Common Lisp.
  • Paul Graham's On Lisp: Advanced Techniques for Common Lisp.
  • Peter Norvig's Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp.
• An extensible http server written in Common Lisp. From the MIT AI Lab.
• A commercial ANSI-CL to C translator and Lisp-in-C libraries.
• The comp.lang.lisp Usenet newsgroup. You may want to use a newsreader like nn or gnus instead of a WWW browser if you really subscribe to it.
• Collection of job postings for Lisp-related positions. Most of these jobs come from the Lisp-Jobs mailing list of Mark Kantrowitz (send "help" in the body) or the comp.lang.lisp Usenet group. This collection is in UNIX mailbox format, so to peruse you probably want to download it and read it with your favorite mailreader. It also includes AI-related jobs that don't necessarily mention Lisp if they are in the greater Baltimore/Washington area. For complete archives of the Lisp-Jobs and AI-Jobs mailing lists, see the archives at CMU.

Lisp-Related Papers

• A Brief History of Lisp. (PostScript)
• The Evolution of Lisp A Detailed History of Lisp, from the 1993 ACM History of of Programming Languages (HOPL-II) conference. (PDF)
• Lisp: Good News, Bad News, How to Win Big. From AI Expert. Also available in PostScript.
• Hall, Marty and James Mayfield, "Improving the Performance of AI Software: Payoffs and Pitfalls in Using Automatic Memoization," Procedings of Sixth International Symposium on Artificial Intelligence, Monterrey, Mexico, September 1993. (PostScript). Source code is available here. See the top of Memoization.lisp for a quick description of the main user-level functions.
• Paper by Ken Anderson giving details of numeric optimization in Lisp with comparisons to C. Based around an algorithm known as fannkuch. (PostScript)
• Henry Baker's outstanding collection of Lisp-related papers. Note that netcom is frequently overloaded, so it might take several tries to connect.
• A survey of garbage collection techniques by Paul Wilson. To appear in ACM's Computing Surveys. (PostScript)
• Garbage Collection FAQ maintained by David Chase of Centerline.
• GC Papers by Hans-J Boehm at Xerox PARC:
  • Discussion on the complexity of mark-sweep vs. copying garbage collectors. He attempts to refute the claims that copying collectors have better paging performance due to compaction, and that the asymptotic time complexity of copying collectors is necessarily better.
  • Example showing that in some cases explicit allocation/deallocation (malloc/free) can be computationally more expensive than garbage collection. Note that he is not claiming that GC is faster in practice, only refuting the claim that it must be slower.
  • A garbage collector for C and C++.

Misc.

• Home Page for Marty Hall.
• Java programming tutorial.
• Servlet and JSP tutorial
• Apache Tomcat tutorial.
• JSF 2.0 tutorial.
• Ajax and jQuery tutorial. See also the section on JavaScript programming that has many functional programming and Lisp-related concepts.
• GWT tutorial.
• Customized onsite training courses: Java, JSF 2.0, servlets, JSP, Ajax, jQuery, GWT, Spring, Hibernate, etc.
• Java Programming Resources at Johns Hopkins