In contrast, using MutationObserver results in correct behaviour on all modern browsers and relatively minimal delays — between 0.002ms and 0.007ms according to an OS X only micro-benchmark I did last month [2].
And, yes, it would be great if we could call a builtin instead of hacking on top of MutationObserver, but it isn't that ugly:
if MutationObserver
$div = root.document.createElement 'div'
observer = new MutationObserver tick
observer.observe $div, attributes: true
scheduleTick = ->
$div.setAttribute 'class', 'tick'
return
else
scheduleTick = ->
setTimeout tick, 0
return
In conclusion, I agree that a feature like setImmediate would be great. But given IE's broken implementation and a viable workaround in modern browsers, I see no need to rush it. I'd rather they focused on: new features like Object.observe; improving the performance of old features like Object.seal; and finalising some of the ES7 ideas like exposing the event loop![1] http://codeforhire.com/2013/09/21/setimmediate-and-messagech...
I took a less conventional road there: I deliberately violate the A+ spec and let surprises like the ones in the article example happen, in order to get good performance without hacks/bloat. Typically, promise resolution is usually done asynchronously anyways (otherwise, why bother using promises?), so this caveat would only be a problem in some serious case of misuse.
In any case, surprises are fixable in application space (i.e. just move lines of code around), but performance degradation due to some deep implementation detail in the promise API / browsers not playing ball is nearly impossible to fix unless you switch to a non-conformant promise library (in which case, you'd have to fix the surprises anyways - assuming you had any cases of misuse to begin with).
asap(callback);
which will push to an array of callbacks that you need to execute and then call a loop if one isn't currently active: function asap(cb) {
callbacks.push(cb);
setTimeout(flushQueue, 5);
}
Flushqueue will run all the callbacks from the queue in a loop, then empty it function flushqueue() {
if (flushing) return;
flushing = true;
for (var k = 0; k < callbacks.length; ++k) {
callbacks[k]();
}
flushing = false;
}
Now if some of the callbacks schedules a new function to execute using asappromise.then(function first(x) { return alreadyResolvedPromise.then(function second(y) { return y.some.property; }); });
then when "promise" resolves, first()'s execution will push a new function to the queue, changing queue.length, causing that loop above to cause one more iteration - but only after first is complete.
(If you don't nest the callbacks, then the push will happen before flushqueue even starts executing)
The code above is overly simplified but I think its enough to demonstrate the idea. (Huge thanks Stefan Penner for explaining it to me :D)
"... always require at least one more iteration of the event loop to resolve. This is not necessarily true of the standard callback approach."
as the article states. A fully synchronous chain of 20 operations wont take 100ms - it will only take 5ms
This is true in the scenario of a linear chain, e.g. `.then(foo).then(bar)`, but the spec also requires that the following should work (for interop purposes, among a few other scenarios):
.then(function() {return someOtherpromise.then(doSomething)})
So you might incur other harder-to-track-down penalties if you're doing interop between libraries somewhere, or if the promise chain has dependencies on the data provided by upstream resolvers.If its from another library, then that other library may be using its own scheduler and you will loose those 5ms either way...
My point was that violating the A+ spec instead of getting into the whole rabbit hole of timer clamps is not as unreasonable as one might think, and that doing so doesn't incur delays in any of those scenarios.
If these guarantees can be offloaded to a library then thats really great, as I don't have to keep them in mind anymore, freeing my brain to think about the specific problem I'm trying to solve. One less thing to check for when debugging too.
There is also the bonus feature that stack overflows wont happen, which enables liberal use of recursive promise functions. (On the other hand, memory usage might still explode, so its not quite that easy... :D)
Firefox has just shipped native promises, and you can use them to polyfill setImmediate instead ;)
Also, note that yield/generators are entirely synchronous, and cannot be used as a scheduling mechanism of any sort.
The setImmediate polyfills attempt a bunch of ugly fallbacks, including (depending on which one you use): yield/generators, MutationObserver, postMessage/MessageChannel, onreadystatechange, and finally setTimeout (the slowest).
IMO the browser vendors should just give in and add setImmediate – if ever there was a need for it, this is it. But maybe they consider ES6 features a good enough substitute, I don't know.