Our interpreter as it stands is like older implementations
of lisp. It uses dynamic binding. Common lisp uses static
binding.

The difference:

  with static binding:

    > (defun f (x)
    >   (lambda (y) (list 'x 'is x 'and 'y 'is y))

    > (setq g (f 'hello))

    > (funcall g 'cat)

    (X IS HELLO AND Y IS CAT)

    > (defun illustration (fun x)
    >    (prin1 (list 'x 'is x 'now))
    >    (funcall fun x))

    > (illustration g 'keyboard)

    (X IS KEYBOARD NOW)
    (X IS HELLO AND Y IS KEYBOARD)

  same definitions, but with dynamic binding:

    > (funcall g 'cat)

    ERROR because X is an unbound variable

    > (illustration g 'keyboard)

    (X IS KEYBOARD NOW)
    (X IS KEYBOARD AND Y IS KEYBOARD)

Static binding is useful, and very easy to implement with
our style of interpreter.

When a lambda expression is evaluated,
  (in the example, that was when (setq g (f 'hello)) was
   executed. The result of (f 'hello) is a lambda-expression,
   and of course the result of a function is always evaluated
   before it is returned)
we should not just let it represent its own value, as in the
interpreter now:
  (cond 
    ...
    ((eq (car form) 'lambda)   form)
    ...)
instead, we create a THUNK or CLOSURE, which contains all the
information in the lambda expression plus memory of the current
values of all the variables that might appear in its body:
  (cond 
    ...
    ((eq (car form) 'lambda)
           (let
                ((params (cadr form))
                 (body (caddr form)))
              (list 'closure params body mem)))
    ...)

because we don't use setq in functions, our ALset is non-destructive,
so we don't have to worry about mem changing behind our backs.

When the big cond in lisp-eval reaches its final case, we are trying
to evaluate a form like this (F X Y Z ...) when F does not match any
of the pre-defined operations such as +, *, EQ, IF, CAR, etc, it must
be a user-defined function. So we evaluate F, and this time expect
to see not (LAMBDA params body) but (CLOSURE params body old-mem).
X Y Z ... are evaluated in the current memory, but they are bound
to their values (by ALset) in old-mem, and it is in this extended
old-mem that the body is evaluated.

ALMOST.

There is one very tiny fly in the ointment, just a gnat really. Test
your understanding by trying to spot him.