Paul Graham Makes "On Lisp" Available Online

entrox writes: "Paul Graham made his infamous book On Lisp available as PostScript on the web. The book is out of print and the queues for used copies on Amazon are pretty big, so this comes as a godsent for every Lisp programmer and people who would like to take a look at some neat features of Lisp. What sets this book apart is that it doesn't focus on things you could do in other languages, but rather on more extravagant techniques like making the language suit your application and not the other way around."

Cool!

[jpt.d]

Now maybe I can learn a totally wierd language. Might be useful someday...

I wonder... would this be my 21st or 22nd language learned?

Don't knock it

[brenfern]

Many ideas that would be seen as cutting-edge nowadays were in Lisp 40 years ago. For example, check out how Lisp can express data hierarchies and implement domain-specific languages far better than XML (e.g. look at the mess of XSL and look how DSSSL could have been).

This sort of technology was ignored back then as nobody thought they needed it, and totally forgotten about. Trust me, Lisp is more than just a historical curiosity!

A Great Book on a Great Language

[HaveNoMouth]

Graham's book is the definitive work on Common Lisp's macro facility, itself one of the prime features that make Common Lisp (not Scheme; there's a big difference) the most powerful language on the planet [norvig.com].
If your only exposure to Lisp has been a one-semester course that covered Scheme, you don't know Common Lisp. Try it before you judge it. Open-source versions are CMUCL [cons.org] for most Unix/Linux platforms and OpenMCL [clozure.com] for Linux/PPC and Darwin/MacOSX. The full language spec and reference is online [xanalys.com].

Now if somebody would just write as good a book for CLOS [cmu.edu]...

Macro LISP? Oh God.

[fm6]

...Common Lisp's macro facility, itself one of the prime features that make Common Lisp ... the most powerful language on the planet.

Oh great. It's not enough to dispense with all the syntactic sugar [wikipedia.com]. The code's still too readable! Let's add a pre-processor!

Re:Macro LISP? Oh God.

[Anonymous Coward]

fud

Lisp macros are an entirely different beast than the text substitution C style stuff you're probably thinking of. Most of the lisp operators are really macros.

As for readability, look at the indentation and let your editor keep track of both the parens and the indentation. If you do that, and don't have problems with prefix notation, it's extremely readable.

Re:Macro LISP? Oh God.

[diaphanous]

I think you may be confusing Scheme and Common Lisp. Scheme was designed to have a minimal syntax and semantics (for example mandating optimized tail recursion and providing little syntactic sugar for expressing iterative processes, or using continuations in preference to exceptions) while Common Lisp is a huge language with plenty of sugar

Re:Macro LISP? Oh God.

[fm6]

Well, I do know a lot less about CL than about Scheme. But I always thought the whole point of Lisp was to keep the syntax as simple as possible. Why else would you want to live with such a weird notation?

Re:A Great Book on a Great Language

[molofaha]

You might want to try SBCL [sourceforge.net] instead of CMUCL. It's a fork of CMUCL, with the major advantage being that compiling from scratch works without major tweaking.

Re:A Great Book on a Great Language

[entrox]

Now if somebody would just write as good a book for CLOS

Try Sonya Keene's book: Object Oriented Programming in Common Lisp [amazon.com]. It's a VERY good resource for CLOS programming.

Lisp macros are a hack

[cpeterso]

Lisp needs macros because it does not support lazy evaluation of function parameters, like Haskell. Lisp macros are used to create function-like operators that evaluate their parameters conditionally. Sounds like a hack to bandaid a language deficiency.

Re:Lisp macros are a hack

[J. Random Software]

Not every macro argument is an evaluable sexpr. Macros also let you invent domain-specific syntax.

This is a great day

[joto]

Well, not that this book is going to make any newcomer to lisp understand much more of it. But Grahams book has been, and is, the greatest introduction to what lisp is all about (after you've learned the basics, which can be taught from e.g Grahams other book (Ansi Common Lisp)). It is quite sad that On Lisp has been unavailable for such a long time.

I would much prefer a paper version myself, but at least making it available makes a lot of sense. I hope various lisp-vendors (Franz, Xanalys) sponsor him somewhat to avoid the losses...

Re:is this book low quality?

[Graspee_Leemoor]

Firstly I would like to point out that Mr. Graham was probably not lying when he made this statement- he was mistaken; there is a difference.

Secondly, the book with the "lie" you mention is "ANSI COMMON LISP"- a different book to the one being discussed here. ('On Lisp' came first).

Thirdly- "Ansi Common Lisp" is my favourite computer book ever and in my opinion is very good for learing lisp.

Fourthly- given the abusive nature of your "friend" I feel it is only fair to nitpick and point out that the supplied C file won't compile- that is unless /. did something weird with the name of the include file in angle brackets.

graspee

Re:is this book low quality?

[bradleybear]

Your proposed C function does not implement addn.
As you point out yourself, you cannot store the result of addn(2) and expect it to work later (for example, if you called addn(3), the stored version of addn(2) would become addn(3).

You then propose to make up a closure in C by using a struct. For example,

struct addn_closure {
int (*f)(int x, int y);
int x;
};

Then instead of doing
(addn(2))(3)
you would have to do
struct addn_closure *f = addn(2);
f->f(f->y, 3);

This is nothing like doing
int (*f)(int) = addn(2);
f(3);

It doesn't count as a function unless you can call it like a function.

You cannot write the function addn() in C so that it is
- reasonably free of side effects, and
- works using normal C function calling.

Note: gcc provides a downward function passing facility that lets you do something like this (using "trampolines") That is not standard C, and it doesn't let you write a function that returns a function.

To be fair, old versions of lisp couldn't do this very well either. It wasn't until around 1977 that lisps with lexical closures started appearing. Of course it wasn't until about 1985 that optimizing C compilers started producing correct code :-)

Sorry

[sinserve]

I pasted the text twice; the input form is too short to type in, so I used a text editor.

Emacs actually :-D

Ignore the sig, it is an artifact from my days of
VI zealotery, and is now dried in the concrete.
I hate it, the same way I hate the disco tatoos from my yout ;-)

Lisp, Arc, Cross-platform/implementation libraries

[sethdelackner]

While browsing the page for the book, I noticed the author is working on a new lisp dialect called "Arc". I hope they manage to fix the niggling thing that keeps me from really trying Lisp: freely available MATURE cross platform libraries for threads, GUI toolkit, and networking.

Hell, I would settle for just a GUI toolkit!

The "CLIM" (the standard Lisp gui toolkit) has a free implementation, but it is unfinished.
Garnet [cmu.edu], has been abandoned by CMU (the developers).
XIT [uni-stuttgart.de] hasn't been modified in 6 years.
Winterp [cybertribe.com] is its own mini-Lisp and is Unix-specific.

Why out of print..

[Suppafly]

If there is such a demand for this book, why not put it back in print or perhaps sell the online version? granted giving it away is pretty cool..