StratifiedJS: Javascript + structured concurrency
onilabs.comIf you prefer vanilla JS and are only working with Node, you should check out https://github.com/laverdet/node-fibers. I use it in my https://github.com/olegp/common-node package to address the same issues as those tackled by StratifiedJS.
I'm probably missing something, but isn't this race condition galore? As per the front page example:
var news;
waitfor {
news = http.get("http://news.bbc.co.uk");
}
or {
hold(1000);
news = http.get("http://news.cnn.com");
}
or {
hold(1000*60);
throw "sorry, no news. timeout";
}
show(news);
Of course in this case this only means a wasted request. But what in case of side effects?
Ignoring WebWorkers, the underlying Javascript engine is single-threaded, so the problem you describe can't exist. Once you start down a code path, it will continue until it finishes and yields execution.
Further, "hold" is almost certainly a magical statement that actually compiles into a pattern of calls to .setTimeout and various handlers, and has no literal existence, so there probably isn't any point at which the hold is "executed".
You can't actually turn a single-thread runtime into a threaded runtime at the user level. You can apply a series of increasingly sophisticated hacks that may make program like it's multithreaded, but you can't escape the fact you have only one program counter. (This isn't a criticism of the library. It looks quite useful. It just doesn't magically make browser Javascript truly multithreaded.)
This approach is actually quite useful, and is part of what makes the event-based programming style practical. For all the stuff that's going on, you do always have the guarantee that any given event handler will fully execute, and no other hunk of code will be able to observe the half-executed state of any given handler. Without that property you'd basically just be doing conventional multithreading with a really inconvenient code structure.
Ah, this is one of the clever bits of StratifiedJS which differentiates it from a lot of the other async extensions out there.
In the case you describe the CNN request will automatically be cancelled by honoring any try/finally or try/retract clauses in the http.get function. (try/retract is a new SJS thing). To see how cancellation/retraction works check out the slides starting at http://onilabs.com/presentations/ugent/cancellation.html .
After the IcedCoffeeScript post the other day, I found Oni Labs' version -- which I don't remember seeing before -- Stratified CoffeeScript:
Eliminating nested callbacks would be one hell of a feat.
It's not too too hard to do the appropriate transformations--the literature is vast and there are practical implementations today. The hard part is producing readable, debuggable output.
I've whipped up a tiny project with the priorities inverted: readable output at the expense of completeness: https://github.com/lalcmellkmal/nestless
It only does the minimum desugaring to prevent nesting in the common case, no more.