This is a good textbook for an introductory Lisp programming course. No complaints
except Chapter 8 on recursion. The chapter contains several errors and a discussion
regarding efficiency in recursive programming should be added.

Exercise 8.11 (p. 247-248) states that the first two terms of the Fibonacci sequence
are F(0) = F(1) = 1. The first two terms of the Fibonacci sequence are customarily
defined as F(0) = 0 and F(1) = 1. For purpose of the exercise, the non-standard
definition of the Fibonacci sequence is not important, but using the standard
definition would have required no more effort and would not have sacrificed
any point that was being demonstrated.

The recursive algorithm for generating a Fibonacci number is given in Section 8.12.4.
Correcting this for the standard Fibonacci definition is as follows:

(defun fibA (n)
(cond
((= 0 n) 0)
((= 1 n) 1)
(t (+ (fibA (- n 1)) (fibA (- n 2))))))

The function definition is a good example of multiple recursion, but it is notoriously
inefficient. A call to (fibA 30) will take several seconds to return a value on even a
very fast computer. As is commonly known, this is because of massively redundant function
calls during the recursive decent. To calculate F(5), we must calculate F(4) and F(3),
but to calculate F(4), we must calculate F(3) again, and so on. Indeed, the number of
function calls required to generate each Fibonacci number is:

Number of function calls to generate F(0) = 1
Number of function calls to generate F(1) = 1
Number of function calls to generate F(n) =
1 + Number of function calls to generate F(n-1)
Number of function calls to generate F(n-2)

The call to (fibA 30) requires 2,692,537 function calls!

Section 8.16 Advantages of Tail Recursion (p. 281) makes the misleading statement
"Any function that is multiple recursive, such as FIB, cannot be made tail recursive
simply by introducing an extra variable..."

The statement may be literally true in a narrow sense, but it is not true that FIB cannot
be made tail recursive with minimal extra work. The definition of fibB given below is
widely known, and is not only tail recursive, it eliminates the redundant function calls
of the fibA definition.

(defun fibB (n)
(cond
((= 0 n) 0)
(t (fibBhelper n 1 0))))

(defun fibBhelper (n var1 var2)
(cond
((= 1 n) var1)
(t (fibBhelper (- n 1) (+ var1 var2) var1))))

The speed-up in evaluation of (fibB 30) over (fibA 30) is dramatic and is immediately obvious
to a student trying the exercise. A discussion of the differences in performance of the two
algorithms would be a good addition to the chapter.

Although it is not directly pertinent to the subject of recursion, a student might be interested
to know that a closed form for calculating Fibonacci numbers exists using a second order polynomial
with coefficients related to the Golden Ratio.

A discussion of functions that are mutually recursive would also be a good addition to the chapter.
My suggestion is the recursive merge-sort algorithm given below. Producing sorted lists is a classic
programming task, and the simplicity and efficiency of the recursive algorithm is impressive.

The function mysort returns a sorted list of numbers. The function is based on the trivial
observation that a list of one element is sorted. The function mymerge merges a number into
an already sorted list of numbers.

(defun mysort (lst)
(let ((var1 (car lst))
(lst1 (cdr lst)))
(cond
((null lst1) lst)
(t (mymerge var1 (mysort lst1))))))

(defun mymerge (var lst)
(let ((var1 (car lst))
(lst1 (cdr lst)))
(cond
((null lst) (list var))
((< var var1) (cons var lst))
(t (cons var1 (mymerge var lst1))))))