Spec gotchas

• Modifying quoted lists = bad.

  See QUOTE; doing this is undefined and left to the implementation. You can easily use COPY-LIST or COPY-TREE on your quoted list if you want to modify it in a defined way. In fact, modifying any "literal object" is undefined -- like a string created with double-quotes "", or a vector created with #() syntax.
  

• NTH/ELT/GETHASH argument orders inconsistent.

  Solved by an IDE's intellisense features, like in Emacs/Slime where hitting space shows the arguments in the minibuffer.
  

• LOOP bodies shouldn't be before variable initialization

  Solved by Iterate?.
  

• The implicit NIL block wrapping DO, DO*, DOLIST, DOTIMES, DO-ALL-SYMBOLS, DO-EXTERNAL-SYMBOLS, DO-SYMBOLS, and LOOP, to name a few, may screw up macros. LOOP allows the user to rename the emitted block, the other standard iteration macros do not.

  Description on Usenet
  

• DEFVAR may be surprising

  Keep in mind there's a simple difference between DEFVAR and DEFPARAMETER. Both are useful depending on your needs.
  

• Sometimes Lisp will print mysterious, annoying # characters in lists

  *PRINT-LEVEL* and *PRINT-LENGTH* control this.
  

• Assigning to unbound vars is undefined

  Unfortunately, the hyperspec shows bad examples where it simply SETFs them, without warning.
  

• SORT function is 'destructive'

  That is, it doesn't return a fresh sequence, but tries to modify the one you give it.
  

• Don't APPLY functions to huge lists

  Unless your implementation supports a large CALL-ARGUMENT-LIMIT.
  

• Backquote (`) has no corresponding macro

  Scheme seems to have it.

Frequent errors

• LOOP's finally clause doesn't return anything on its own

  It's common for people to have something like:

  ;; likely buggy
  (loop for blah = ...
        finally blah)
  
  ;; good
  (loop for blah = ...
        finally (return blah))
  

  
  

• Recursion may eat stack space

  Common Lisp does not guarantee that an implementation will optimize things that look like "tail recursive" calls. (Because maybe that's not what you want.) So you might prefer using iterative forms like DOTIMES and LOOP, unless the code is best expressed recursively.

Implementation gotchas

• CMUCL multiprocessing

  You probably want your CMUCL init file to say something like #+mp (mp::startup-idle-and-top-level-loops)

  
  

• Download Slime from CVS

  With many implementations, like SBCL, it's best to ignore the deadly, convenient-looking Slime tarball and go straight to the source -- CVS.

Meta gotchas

• READing external data can pose security problems.

  If you want to use READ like this, bind *READ-EVAL* to nil. Otherwise an attacker can have Lisp run arbitrary code using "#.".
  

• Macro overuse

  Mentioned in Ernst's talk at lisp-user-meeting-amsterdam-april-2004, and at LL2 workshop during Q&A by Symbolics guy.
  

• PAIP examples are tricky to run on today's CL
  
• CL implementations aren't that alike
  
• Often in free/opensource code, you'll see screwed-up indentation. So you have to issue indent-sexp in Emacs or whatnot.

  Might be solved by a structure-editor like Interlisp's... had it not been killed off by Common Lisp standardization in some crazy corporate war.

Minor trivia

• Funcalling a symbol

  You can FUNCALL a symbol, in which case its global function definition will be used.