Lambda the Ultimate

Here's an old post from my own blog for some background on the evolution of the implementation and the technique in general.

See the Getting Started page to try it out yourself. There are also alternative implementations using ATCT "serializable threads" (with Jython integration in one version).

Just having tail-call elimination is great for BeyondJS because BeyondJS's flow control is based on function calls (it is, after all, a functional library ;-)

With regard to the continuations extension a few quick observations:

1. Standard JavaScript implements an arguments object that aside from containing a collection of all a function's argument values, also provides caller and callee properties. These are references to the calling function and the function being called respectively. It's interesting continuations where implemented using new Continuation rather than a continuation property on the arguments object. This is nitpicking of course.
2. Interesting that you apparently don't need a try statement for catch(break) and catch(continue). Indeed, the use of catch may be less than ideal given its existing role for exceptions.
3. It's a shame IMO that you still can't access a scope, as preserved by the continuation object as an object, e.g.

You would be able to travel up the scope using a parent property on the scope, or something like that. You actually don't need continuations for this, it scope could simply be added a property on callee.

IMO getContinuation() functionality seems to be something they should have provided out-of-the-box.

And BTW BeyondJS does work on a previous version of Rhino. I will have to download this one to test it.

Who needs the PLT webserver, right?

It would be a shame not creating a toy-demo of migratable agents in this interpreter :-)

This is a great idea. There's a ton of interesting patterns that can be implemented with migratable continuations.

See Kelsey, et al.'s work with this on Kali Scheme...

Some of the applications and implementation techniques we have looked at using Kali Scheme include:

    User-level load balancing and migration.
    Incremental distributed linking of code objects.
    Parameterized client-server applications.
    Long-lived parallel computations.
    Distributed data mining.
Executable content in messages over wide-area networks (e.g. the World-Wide Web)

Well, not exactly, it come from a problem we had during a last year course, the prof. wanted us to make a toy migratable agent (to find the best price for an article in a group of supermarket) in java , wich lack facilities to make one (without putting a toy virtual machine over the java virtual machine off-course).

thanks for the links, I never thought in this area before.

edit : reading the wiki, more precisely WhatIsFlow , I just think that there is no mean to say that the "one" that stored the continuation (apache instance, physical processor, database connection used, instance of the JS virtual machine, etc.), is the "one" that will deserialize it and "continue" it, yelding an intrinsic migration. This is very interesting.

http://www-spi.lip6.fr/~queinnec/Papers/webcont.ps.gz

This is great to see.