A Review of the ``LISP 1.5 Programmer's Manual''

Information concerning this manual may be found in that menu linking to this document.

Reading this manual should only come after reading John McCarthy's original Lisp paper.  I read this
over the course of one month, making little effort to read quickly.  The document details one of the
first Lisp implementations ever created, and should be fascinating to those enamoured by Lisp or the
history of early computing, in general.  Even I was surprised at some early Lisp knowledge I gained.

The first half of the manual deals with introducing concepts, and the second half is but appendices.

M-expressions are used for describing programs, although some are also shown as S-expressions.  It's
interesting to note all functions have a fixed numbers of arguments, with only special forms able to
deviate; some functions reasonably use lists of arguments to work around this, there being no &REST.
It's interesting that neither AND nor OR had fixed numbers of arguments, and yet several others did.

A symbol is merely a named property list, effectively, with even its name stored in such.  Flags are
also stored therein, such as when tracing, but without being paired.  The origin of FEXPRs is simply
this being the indicator for special forms not having been compiled, FSUBR, and these match with the
pair EXPR and SUBR for functions.  PNAME is that indicator for print names, and APVAL for constants.
The value T EVALs to *T*, and F to NIL, and, oddly, the latter of each pair is a constant of itself.

The provided library of functions reveals the origin of some names, such as NCONC from CONC; it also
has some interesting forgotten functions and conventions, including TEMPUS-FUGIT for recalling time,
and the function SEARCH having a function argument of one argument for searches which failed, yet it
will always be passed NIL.  The system is charming; Lisps don't greet me using Lewis Carroll poetry.

The manual is so old that it was needed to point out advantages of lists over contiguous structures.
Even this Lisp featured arrays, allocated in blocks seperated from the rest of the system, but oddly
required they be named, with the array acting as a function of its indices.  This Lisp also deviated
from a pure style by featuring PROG, for imperative programming, and an entire chapter describes it.

Despite any praise, the Lisp described is irredeemably ugly and unwieldy.  The REPL is controlled by
an OVERLORD program processing punched cards with commands and ``doublets'', the function or special
form to be evaluated followed by a list of arguments.  One interesting quality of OVERLORD, however,
is that it operates with a temporary state, SYSTMP, only optionally persisting state of the session.

The familiar list notation is in full display across chapter seven.  The Lisp Assembly Program, LAP,
had made me think of my working in symbolically representing machine code, but is much less refined.

Ultimately, this manual, and the original Lisp paper, are two documents serious Lispers should read.
.