Cautionary note:
These files have been updated for sbcl from gcl: I think they're all correct, but there may still be a few bugs.
Please let me know if you find any glitches!

(steel bank) common lisp: features and functions
Getting started A quick intro General use /usr/bin/sbcl is the lisp interpretter (quit) or (bye) to quit, (help) for help (load "filename") to load an existing file of lisp code (that doesn't start with the #!) (trace functionname) (untrace functionname) to turn on/off tracing (step (functioncall)) to single step through a function call return to step, ? for help, q to quit Google code standards/style guide for common lisp (They're quite good, but I'm really bad about following them) To create executable scripts Edit and save the file (.cl is the typical extension) Make sure the first line is #! /usr/bin/sbcl --script Make the file executable chmod u+x filename ./filename to run the file command line arguments Availability We are running Steel Bank Common Lisp, packaged for debian There are some lisps with similar (though definitely not the same) functionality available, but your labs/assignments must run on otter/cubs/pups. Compatibility is definitely not guaranteed with other packages, or even with sbcl compiled/configured on another system. Variables, data types, operations quote and ' defvar, defconstant, setf data types equalp, =, eql, eq boolean logic operators bitwise operators math functions character functions string functions type checking and definitions symbols Basic I/O output (format) A good summary of the many many formatting options, from cs.cmu.edu's AI group input (read) Selection if/else cond case (like switch) typecase (switch on type) unless when Creating functions function declaration (defun) function side effects (setf inside functions) documentation strings (documentation) variable number of parameters (&rest) keyword parameters (&key) optional parameters (&optional) dynamically scoped variables (special) returning multiple values Recursion recursion tail recursion Iteration do dolist dotimes loop for	Advanced data types list functions list implementation and side effects pop/push (using list as a stack) multi-dimensional arrays vectors (one-dimensional arrays) sequences (includes lists and vectors) structures hash tables Code blocks code blocks (block) blocks with local variables: let, let* or prog or with local functions (labels) catch blocks and throw tagbody/go (lisp equivalent of goto) unwind-protect (continuing after interruption) Misc. observations on efficiency and maintainability pure vs impure functional programming macros (defmacro) packages (like namespaces) random number generation (random) pausing execution (sleep) time and timing recording a lisp session (dribble) compiling functions and files (and a sample file to compile) seeing the compiled code for a function (disassemble) a simple class/object example with CLOS File I/O, pipes and streams file i/o run a program from lisp pipe the output from one program into another Higher order functions homoiconic languages apply eval (and eval-when) funcall map maplist mapcar reduce lambda, function closure Let over lambda let over lambda (creating public accessors to private data) "let over lambda" instead of classes, and "let over label" version Altering functions "on the fly" The code in this segment is actually for gcl lisp, it has not yet been revised for sbcl dynamically analyzing function composition dynamically altering functions A macro suite for moddable functions,   - a short test script, and resulting output   - an interactive function editor/tester built on the macro suite Parsing lisp in lisp preliminary exploration of a function implementation, simple recognition of program elements using read and typecase, the early stages of an attempt at a lisp code analyzer/debugging aid, recognizing strings as integers tokenize a string of integers and identifiers CFG checker for simple arithmetic expressions STILL IN GCL, NOT SBCL: Building a translator/interpretter for a new language (calcish) Graphics ascii text effects (changing color, move cursor, clear screen, bold, underline, etc)
General coding examples
Data structure examples (lists etc) append two lists divide a list into strictly ascending subsequences extract one row (vector) from a 2d array breadth-first search (directed graph) binary search tree (using let over labels to allow recursive local functions) count elements of a list and sublists flatten a list doubly-linked list using structures set the elements of one list equal to the elements of another testing list for element properties remove the nth element from a list take the difference of two lists reverse a list find the intersection of two lists find smallest value in list, with configurable types/functions take the union of two lists display all permutations of a list tail recursive function to find the smallest number in a list	Other examples checking validity of list of pairs of reals and script for automated testing simple output functions computing the roots of a quadratic polynomial simple ascii animation evaluate a postfix math expression multiply two numbers using shift and add ("almost tail recursive") checksum for bits within an integer structured lisp script (main routine, command line args) approximately equal adding a unique 'error' value to a program towers of hanoi calculate your grade so far an anagram-solving game, the dictionary it uses, and a sample run build and return a list-rotating function (closure) print a formatted message and return a value (unlike format, which returns nil) randomly choose an element from a list, but without looking at the length of the list (tail recursive) state machine generator (using let-over-lambdas)