At the end of this month's meeting, Justin asked what are some of the seminal lisp books to bring on a long trip.

I found that I was unable to immediately answer the question.

After pondering this on the way home, I realized that I didn't learn lisp from books - I learned it by reading source code of implementations of lisp.

In addition to this, good lispery doesn't necessarily come from learning lisp. It also comes from being a generalist - learning as many paradigms as possible, then using lisp as the vessel for combining those paradigms. (One of the more extreme examples of using lisp as a vessel might be SICP - the Structured Interpretation of Classical Mechanics, Sussman and Wisdom, http://mitpress.mit.edu/SICM/).

Here's a brief summary of what I read / did:

- played with writing assembler code for Z80's and MC6809's

- read source code for Tiny Basic (Dr. Dobb's Journal of Computer Calisthenics and Orthodontia, http://en.wikipedia.org/wiki/Tiny_BASIC).

- read source code for Utah Lisp (IBM 360).

- read source code for Fritz van der Wateren's MC6800 Lisp and transcribed it to run on a Z80.

- read Lisp 1.5 Manual http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programm...

- read John R. Allen's "Anatomy of Lisp" (a book) and implemented the lisp compiler contained in it on the Z80 lisp (fixing a few bugs in the book). It ran in 22K of RAM and successfully compiled the IOTA function to Z80 machine code.

- learned how to build compilers by reading the source code to Small C (it became my 4th year EE thesis project - I rewrote the whole thing using "better" compiler techniques and got it to self-compile). http://en.wikipedia.org/wiki/Small_C

- learned how multi-tasking works by reading Ric Holt's small, but wonderful books on the subject, the most up-to-date one being, I think, "Concurrent Euclid, Unix and Tunis".

- read source code for V7 Unix (which is now published in book form, with a front cover illustration of students making clandestine copies of the source on a xerox machine, heh, heh).

- read source code for Tunis.

- (I only recently read the Smalltalk Blue Book http://web.archive.org/web/20070927190722/http://users.ipa.net/~dwighth/smal... - it is clearly an inspired work).

- read papers on Orthogonal Code Generation (Cordy, et al) and Fraser-Davidson compilation techniques (long before gnu-c existed, gcc uses Fraser-Davidson RTL as its core).

- read source code for PT Pascal, Tiny Pascal, Concurrent Euclid, S/SL, etc.

- read and implemented the WAM tutorial http://web.archive.org/web/20030213072337/http://www.vanx.org/archive/wam/wa... (I wrote the WAM in CL, but haven't finished debugging it yet).

As I look at the list above, I note that most of the implementations I read were done on "simple" hardware (no mmus, pipelining, security rings, mmap'ed files, etc). This made the material accessible, readable, understandable, and brief.

Understanding compilers helped me understand macros, since CL macros are similar to having a language with YACC built into it.

So, another suggestion for reading up on lisp, is to read the source code for some of the simple lisp and non-lisp "classics", and then to spiral into lisp.

(I can't vouch for it since I haven't done so, but maybe some of the open-source CL's would make good reading, too).

pt

ps. If anyone wants the source for Frits van der Wateren's lisp, I'm hoping to scan it in and post it on my site (I have his permission). At one point I was toying with the idea of bringing it back to life by writing a 6800 simulator (in CL).

pps. If there is sufficient interest, I could bring and explain the (assembler) source of FvdW lisp to one of the meetings. It would be a quick and easy intro to assembler and to low-level lisp structures.