Naming conventions
Some symbol naming conventions, distilled from CLHS, the Lisp FAQ, and comp.lang.lisp.

Widely used "need-to-know" conventions:

foo-bar "-" is used as a word delimiter
*foo* (global) special variable
foo* slightly different variant of the foo operator
&foo lambda list keyword. These symbols will be in the lambda-list-keywords list.
nfoo (possibly) destructive (non-consing) function
foop predicate (also foo-p); see notes below for when to hyphenate
foof place changing (like in SETF, INCF, ...) (also foo-f)
+foo+ constant, or single CLOS instance
%foo low-level, fast, dangerous function, or Lisp system specific implementation of foo
make-foo create a foo and return it
define-foo (globally) define a new foo (also short version: "deffoo")
with-foo create a dynamic context with a foo
do-foo iterate through a foo
foo-case foo-specific case expression
foo-bar type-slot, converting FOO to BAR
foo-to-bar converting FOO to BAR

Often seen, but not-quite-so-common conventions:

bar-of slot bar of an object
foo/bar type/operation, foo with bar, bar version of foo type.slot or, in some implementations conventional hierarchical package (e.g. ACL and CMUCL)
?foo variable in embedded language
<foo< variable in embedded language

Occasionally seen:

<foo> class
%foo% local special variable
.foo. internal special variable
.foo. private macro symbol
/foo/ global lexical variable
$foo function visible from Macsyma
foo& foo, operating on fixnums
foo$ foo, operating on floats

Conventions in Scheme:

foo! destructive function
foo? predicate
$foo constant
call-with-foo Invoke a thunk in some dynamic context
foo->bar Coerce object of type foo to object of type bar

This is standard syntax, not convention:

:bar keyword
foo:bar external symbol bar in package foo
foo::bar internal symbol bar in package foo (don't try this at home, kids!)
#:bar uninterned symbol (does not belong to any package)

These will annoy people:

CamelCaseIdentifiers Use identifiers-like-this
identifiers_with_underscores are harder to type
abbrv-idntfrs Use Emacs to expand them.
Unless there is a good reason to use them (for instance, you need to interface to a third-party package that uses them), they should be avoided.

Some additional style notes:

  • A function that tests for something involving its arguments is called a predicate and usually ends in p or -p. CLTL2 explains the rationale for each suffix:

    By convention, the names of predicates usually end in the letter p (which stands for "predicate"). Common Lisp uses a uniform convention in hyphenating names of predicates. If the name of the predicate is formed by adding a p to an existing name, such as the name of a data type, a hyphen is placed before the final p if and only if there is a hyphen in the existing name. For example, number begets numberp but standard-char begets standard-char-p. On the other hand, if the name of a predicate is formed by adding a prefixing qualifier to the front of an existing predicate name, the two names are joined with a hyphen and the presence or absence of a hyphen before the final p is not changed. For example, the predicate string-lessp has no hyphen before the p because it is the string version of lessp (a MACLISP function that has been renamed < in Common Lisp). The name string-less-p would incorrectly imply that it is a predicate that tests for a kind of object called a string-less, and the name stringlessp would connote a predicate that tests whether something has no strings (is "stringless")!

  • There are useful conventions for macros: deffoo or define-foo defines objects of type foo. Setting up a context for some actions, usually performing some binding, and including setup and teardown code, is usually a with-foo. Iterating macros are defined usually as do-foo.

  • deffoo vs. define-foo used to be, and is in the spec, determined by foo. If foo is a hyphenated name, then the define-foo format is used, otherwise deffoo is used. For example, defmethod and defsetf vs. define-method-combination and define-setf-expander.

  • Occasionally, there will be a pair of operator functions, and one is a destructive version of the other. Historical tradition will name the destructive variant nfoo for the basic non-destructive function, but this is inconsistently used.

  • The CLIM specification supports a rather large protocol, and has a "spread arguments" convention for functions where there is a desire not to have to construct a large object just to call one function with it. A spread function takes many small constituent arguments and is named foo* for a basic function foo.

  • There are some various methods ending in f, notably setf (but some advanced ones include locf for old ZetaLisp). The f stands for a generic field of an object, like a part of a cons cell, structure, vector, array, class instance, and so forth. Kent M. Pitman explained the origin of it on comp.lang.lisp.

  • Note that nested conversions (e.g., (bar-to-baz (foo-to-bar x)) or (bar->baz (foo->bar x))) compose nicer if written the other way around: (baz-from-bar (bar-from-foo x)), (baz<-bar (bar<-foo x)).