
LISP 1.5 Programmer's Manual (1962) [pdf] - kick
http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf
======
OldGuyInTheClub
Every other programming language I've studied starts off showing me how to do
things. As I go through this manual, I think I am seeing a language define
itself from the ground up. It's kind of like chemistry; atoms to (small)
molecules to functional groups to functional group transformations and onwards
to bewildering complexity. I'm getting flashforwards to what this could
ultimately achieve and why LISP has stayed relevant for so long.

~~~
capableweb
If you liked that, you might also like one of Paul Grahams pet projects, the
Bel Language:
[http://www.paulgraham.com/bel.html](http://www.paulgraham.com/bel.html)

It's a specification for a new dialect of lisp, written in lisp.

~~~
grzm
s/Bell/Bel/

~~~
capableweb
Thanks, now corrected.

------
lispm
Earlier: the LISP I Programmer's Manual from 1960

[http://history.siam.org/sup/Fox_1960_LISP.pdf](http://history.siam.org/sup/Fox_1960_LISP.pdf)

~~~
aap_
Written by the woman who implemented the ao (add one) instruction on the
Whirlwind I!

~~~
Rerarom
[https://en.wikipedia.org/wiki/Phyllis_Fox](https://en.wikipedia.org/wiki/Phyllis_Fox)

------
fjfaase
I bought this book on Friday July 21, 1978 and learned how to program in LISP.

------
aap_
Simply one of the best computer books I know. I think this (or something
similar to it) is the language all those toy-lisp projects should implement
instead of something super minimal. It's actually useful and you learn about
how lisp was actually implemented.

------
mtreis86
Is there a current implementation of 1.5?

~~~
frank2
Code in the book can easily be translated into less than 150 lines of code in
a modern Lisp-like language to yield an interpreter, so someone somewhere
probably has a toy implementation. But almost certainly what implementations
exist are not used to implement anything practical: most languages nowadays
and especially most Lisps after the publication circa 1970 of the description
of the Scheme programming language scope variables lexically (unless the
programmer explicitly declares the variable to be dynamically scoped).

There are a few Lisps that like 1.5 do not have lexically-scoped variables,
e.g., Emacs Lisp before 10 years ago, but they dont suffer from the downward
FUNARG problem that 1.5 has: in 1.5, if you specify an anonymous function as
the argument to another function, you cannot specify any free variables in the
anonymous function, which limits the expressiveness of 1.5. Or something like
that. I am guessing that every one of the dozens of Lisps designed after the
downward FUNARG problem was described does not suffer from the problem.

In summary, the OP is an important milestone in the _history_ of programming-
language design, but the design itself is quite obsolete.

------
andykx
It is really cool that much of this is still relevant over 50 years later.

~~~
turk73
Really? How? I learned LISP back in college, enjoyed programming in it and got
into Clojure for a bit around 2014.

But there's no jobs doing it, so other than having a bit better understanding
of Functional Programming, there's not much there.

I think the problem is the quality of the average software developer is pretty
pathetic right now. Not only can most of them not understand FP, they have
never even heard of LISP.

------
abrax3141
I have two small boxes of books that I’ve carried forward with me for several
decades. Most other books come and go. This, and The Little Lisper, are among
them.

------
nickpeterson
I believe this was mentioned by Alan Kay as one of the programming books he
recommended.

