This has some nice effects for web programming. You can encode a continuation into a dynamically produced page as a URL, and when that URL is followed the continuation is invoked, so control passes back to where the function that produced the page was called. This makes the process of sending out a page over HTTP and getting back a response a single function call.

You get more control than that, though, because the continuations are values, so access to them, their lifetime etc, can be managed.

For instance, something like an order form, which may have multiple steps, but where the order can only be placed once, is made a real headache by such things as the “back” button and the “open in new tab/window” option.

This kind of thing still flusters many successful websites. Making continuations first class helps with this problem. The state(s) of the interaction is saved between pages transparently, so all of the stages can be accessed at any time in a seamless manner, until the order has completed. Then the application can destroy the continuations associated with all the intermediate steps, making them inaccessible. So things like accidental double orders or other confusions are less likely to happen.

I don’t know of any websites that have actually used this, but I think it has promise nevertheless.

For more about this, see:

http://www.cs.brown.edu/~sk/Publications/Papers/Published/khmgpf-impl-use-plt-web-server-journal/paper.pdf

Some people mentioned Arc, but it is very new, and is actually a new dialect of lisp built on top of Scheme. The idea is to make a language that could last 100 years. It was just released in kind of a pre-alpha state.

I have been experimenting with Weblocks, and would recommend it if you are interested in using Common Lisp to develop web sites. It makes use of Lisp’s ability to pass continuations in order to present a persistant state. Moreover it automatically handles browser and version compatibility, including the ability to replace Ajax behaviors with page reloads if the browser does not have javascript or has it disabled.

Rob

“Now I do almost exclusively web-based programming. Is there some reasonably straightforward and practical way to use Lisp to construct smart web pages? If so, I would be very pleased to try it.”

You could have a look at Arc : http://arclanguage.org. It’s a new dialect of Lisp targetting at web apps. It’s rather new and still under active development,but if you are just interested in learning how Lisp could be used for web apps, you should definitely give it a try.

You might try looking up Weblocks, which uses Lisp to do websites. It looks pretty powerful..

Try http://www.paulgraham.com/arc.html.

Also http://www.lispcast.com/ is a very good intro to web programming using CL.

Martin

Another example: If you understand what “x = 2″ really, really means, and the basic operations, you already understand all of conventional algebra. (That is, what is taught in K-12, not what a real mathematician would call “algebra”.)

(I actually think that this is where conventional math education goes most wrong, right here at the beginning; kids have a fuzzy conception of equals, and simply never recover from that. Without that, the kids are right, they are just wasting their time learning useless things.)

Too many kids learn the equality symbol as a directional operator, the majority I daresay. They will agree that x => 2, but if we take this fact and rewrite “2 + 2 = 4″ with “x + x = 4″, they will object that you can’t do that.

But of course you can. You can do whatever you want with an equality relation. You aren’t limited to some officially-sanction numerical recipes/magic and the simplication (meta-)operation… but that’s exactly how most people learn equality.

Once you understand, really understand that you can do anything you want to an equation, as long as you do it to both sides (correctly), algebra goes from mystifying to obvious, and instead of being an arcane collection of magical tricks, becomes an accelerated session of sharing the work of centuries to put together what we now teach as algebra.

A lot of people who would be reading this probably understand this so well already they can’t even conceive of the misapprehension I’m speaking of, but it’s the only explanation I have for some of the things I’ve seen “in the field”.

Similarly, in college, I took the “advanced” calculus. And the first thing that happened in my advanced calculus is that we spent three or four weeks working with the limit, until we had that thing down cold. And then yet more time working directly with the integration and differentiation equations and deriving all the shortcuts from scratch, repeatedly. It sounds like a waste of time, but A: If you’ve got a professor throwing every limit edge case he’s ever seen at you it’s harder than you think and B: after that, standard calculus isn’t mysterious any more. Ironically, at, say, week 4, we seemed to be way behind the “normal” calculus class, but in fact it’s only an illusion that the other class was ahead of us, in a way, because they were learning the sanctioned magic and we were learning calculus.