It's case insensitive.
Prefix.
There are anonymous functions. (lambda functions)
Has a 'map' function.
Has garbage collection.
Uses 'name scope'.
Has a built-in interpreter.
 

These are functions with no name.  These functions can bu used anywhere you need a function as an argument, but won't need it any other place.  These functions cannot be recursive.  There's an example use under 'map'.  Syntaically, it looks like this

(lambda (x) (* x x ))

Takes a function and a list.  Returns the result of calling the function on each element of the list.  The two code segments below work the same.

(define (square x) (* x x)
(map square '(2 3 4 5))

(map (lambda (x) (* x x)) '(2 3 4 5 ))

These are association lists.  Each a-list is a list with tuples as elements.  Each tuples is a trait followed by a value.  For example, the list Scott might look like this ...

((name Scott) (age 22) (heigth 5.93) (male #t))

This is a great data structure for storing information about ill defined objects.  A common use would be to have some fields generally present (name) and other fields only sometime present (girlfriend's name) and other fields completely optional (favorite tele-tubby).

A Lisp programmer never need allocate and deallocate ram.  Instead, he just creates and uses lists as needed.  The system will free up unused lists when required, either using mark-sweep or reference counting (see page 417).

Most programming languages use 'lexical scope', where the binding of a variable is determined by the location of the code refering to the variable.  Lisp uses 'name scope' which means that the binding of a variable is determined by the runtime path taken to get to the reference.  Consider the example below.

All list programs can build more code, and then either run that code or add that code to themselves.  Try that in Java!!

(define (eval_infix e)
    (eval (list (car (cdr x)) (car x) (car (cdr (cdr x))))))
(eval_infix `(1 + 2))