The slides of my talk at the 2011 European Common Lisp Meeting are here (text / html) alongside some longer notes from which they were produced.

I'm very pleased to have released such chapters as I wrote, as part of the abandoned book Lisp Outside the Box, as PDFs under a Creative Commons license. In addition to the eight chapters which dribbled out while I was still writing, there are three others: 1. Preliminaries 2. Basics 21. Serving HTTP I'm particularly happy with the last of these, as an example of how to throw a mod_lisp webserver together with practically no effort.

This was to have been the title of my invited talk to the European Lisp Symposium in May. Unfortunately the rubbish state of health which has forced me to abandon being an O'Reilly author also means that I can no longer guarantee being able to either write my talk or travel to Lisbon to deliver it. What I've penned here by way of substitution is necessarily abbreviated, but it'll have to do.

Happily, O'Reilly are interested in seeing the project continue. I had a very definite vision of where this book was going but I don't particularly expect anyone else to share it. I'm easy about what happens to my plans and to the words I've scribed. Use them as-is, raid them for useful bits, or bin them and start from scratch. You should expect this to be a lot of work (it took me over 600 hours to get one third of the book to first draft), for minuscule financial returns.

I'm truly sorry about all this, not just for myself (having spent the last two decades advocating Lisp I'm now looking at a change of lifestyle and a permanent back seat - something of a personal culture shock) but also for the Lisp community. I hope I haven't let you down too badly and that something positive comes from this turn of events. Please contact me for further details, but be understanding if my health means I take a little while to get back to you.

Does anybody know of any Common Lisp implementation which does not use ASCII encodings for the graphic standard-characters? In other words, is there an implementation in which the following might return nil?

(loop for c across (format nil " !\"#$%&'()*+,-./0123456789:;<=>?@~
                                ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`~
                                abcdefghijklmnopqrstuvwxyz{|}~~")
      as i from #x20
      always (= i (char-code c)))

(Update 2010-01-02: It's disconcerting how invisible typos can be. I've corrected my original post which contained the words ANSI encodings.)

The second batch of chapters is ready for public consumption.

The first batch of four chapters is ready for public consumption.

Near the beginning of the chapter on "Threads" I say:

The threading substrate is typically implemented by multiple OS (or native) threads but that’s not universally the case. On the other hand it’s almost certain that your lisp image is running within a single OS process. In this chapter I’m going to reflect common usage among lispers and refer to:

• the use of multiple execution strands as multi-processing (abbreviated as MP)
• the objects with which MP deals as threads.

My problem is this: more recent implementations used native threads from day one, and their function names and documentation reflect that. Older lisps (I'm thinking specifically of ACL and LW) originally implemented MP without the benefit of native threads. Neither ACL nor LW has chosen to abandon the use of "process", nor have they chosen to supplement "process" with "thread". (You can imagine various forms of chaos for their users if they did.)

It happens that this chapter is in the section of the book which uses ACL for its examples, so the function names look like mp:process-run-function. I have to say something about this and the quote above is the briefest I thought I could get away with. I am avoiding history lessons.

Does this work? Is my reading of "common usage" correct?

If anyone knows of a Common Lisp implementation for which (eq 3 3) need not be true, could they get back to me? I know what the Spec says about this but have difficulty believing it.

The message of this book is going to be:

you can do more or less "anything" in lisp, and here are some examples.

The message will not be:

here's how to do everything.

As one of my reviewers has put it: The book is not a reference, nor could it be. Common Lisp alone is far too big to cover at reference detail in a book this size and whose subject extends far beyond the language itself. It's more of an informal look at how practical lisp is - as a tool for today's programmer. It will miss stuff out, it will skirt around tricky areas, it will allude sketchily and unevenly to fine details. The reference material is already available - in the HyperSpec, in CLtL2, in Graham and in Seibel, in the documentation with implementations. This book will point to that material, but isn't going to try to reproduce it.

Each topic I've looked at so far could be made the subject of its own book. ("Persistence in Common Lisp - the Definitive Guide"; "Multi-tasking in Common Lisp - the Definitive Guide"; "Memory Management in Common Lisp - the Definitive Guide"; and so forth. Dream on.) In particular, there are going to be several libraries worthy on mention in each chapter, several different solutions to each problem, and it was never an option to give them all proper coverage. I have to limit myself.

By and large I'm choosing one solution under each heading and giving it some fresh air. It's right and proper to include a mix of proprietary and non-proprietary libraries, to show off a variety of lisp implementations, and to filter the candidates so that the book is balanced and "works" as a whole. I'm always grateful for suggestions received and I certainly intend to give mention to worthy alternatives, but I cannot include everything.

Notes:

[1] Chapter overflow

( read more )

[2] Comprehensive Survey

( read more )

Four chapters written and in various stages of review. I really ought to start work on the next one.

The book's website now has a chapter list. This is very much a draft outline: both overall breakdown and specific chapter titles are likely to change over the coming months.

Early chapters introduce Common Lisp and are implementation neutral. The rest of the book revolves around specific proprietary and non-proprietary libraries; each part focuses more or less on a different lisp implementation: Allegro, Clozure, SBCL, LispWorks, Clojure.

I started writing in the middle (because the needs of later chapters will drive the contents of earlier ones). There's a bit more work to do before I can start posting chapters but I hope that won't take long now. I'll blog links here as each one arrives. At some point I intend to come up with solutions to exercises and there'll be links to these too.