What I was saying is, if I run this program through V8 right now (with its theoretical future support of setTimeout() included), then what will happen:

function fn() {
 print("hello");
}
for (var i=0; i<10; i++) {
 setTimeout(fn,i*1000);
}

That for-loop will finish very quickly (probably <1 ms). Would V8 (or any other JS engine) "finish" in the sense that the calling embedding code thinks this program is completely finished, and it returns back control to the C/C++ embedding layer when:

a) right after the for-loop finishes; OR
b) after only the first call to `fn`, since it's timeout was effectively 0, and so would have been immediately after the main program finished; OR c) after all of the queued up calls to `fn` have finished, about 9 seconds later?

(a) is the right answer because the event loop is run by the embedding, not v8. IMnsHO.

OK, so what I was asserting in my earlier email is, I'd prefer that if setTimeout() were going to be added to the official language spec, and in fact directly implemented in the engines, that instead of making the embedder's job harder (ie, me), that the engine entirely encapsulate and manage the event loop.

I realize I'm certainly in the vast minority with that opinion, but I'm simply saying that not everyone who embeds JavaScript deals with life in an asynchronous/isosynchronous mindset. We're not all clones of Node.js. My embedding is entirely synchronous, and always will be, for its use case. Which means that if we introduce asynchronicity/isosynchronicity at some level, like in the actual JavaScript layer (with setTimeout(), etc), then at some higher level, like the engine (my preference), or my embedding (not my preference), "blocking" behavior has to be written so that I can maintain the external synchronicity that my embedding provides. Namely, I have to be able to ensure that program A is totally done before program B runs.

Could I figure out event-loop semantics in my C/C++ layer, assuming the V8 API exposed some API way to determine if events were still unfulfilled, and basically provide the event-loop functionality *per-program* in my embedding? Sure, I guess I could always learn how to code that stuff. Or, I could simply go to extra work to disable any such native functions so that code running through my embedding cannot create isosynchronous conditions.

Neither of those two are very preferable scenarios to me. What I like about my embedding of V8 right now is, I don't have to worry about those details, so my embedding is straight-forward and simple.


In other words, to put it simply, if program A can call setTimeout(), and I want to run program A and then program B, I have to be able to make sure that I don't try to run program B until everything is fully finished in A. As V8 stands now, there's no way to do anything non-synchronous, so when A finishes, I know it's totally finished. I'm concerned that there'd be some new way with setTimeout()'s that this wouldn't be true.

This is not true today with V8 in Chrome, precisely due to setTimeout!

It's not true in Node either.

I'm not sure where you think it's true. V8 embedding in something without setTimeout or anything like it, sure. But then you can't write simple time-based programs, set alarms, etc., so back in the door comes setTimeout or a workalike...

If I embed V8 in a simple C/C++ program, and I try to run a snippet of JavaScript that calls `setTimeout(...)`, the V8 engine complains and says that setTimeout is undefined. Ergo, my assertion that setTimeout() is *not* in core V8, but must be added to V8 by the Chrome/Chromium embedding.

As I said above, I don't currently go to that extra trouble, because for my embedding use-case, such functionality is more trouble than it's worth.

What I'd simply prefer not to be forced into is some day the core engine (by virtue of the core JS spec requiring it) of something like V8 having setTimeout() defined, and *forcing* the embedding to have to deal with the event-loop. Not everyone who does JS embedding needs such constructs.

Perhaps my complaint is more an engine/embedding complaint than a JS spec complaint. Perhaps what I'm saying is, I'd want for there to be an easy way for embedding with V8 (or any other engine) to be able to turn off/disable isosynchronous APIs so that the embedding wasn't forced to deal with the event-loop.

--Kyle


_______________________________________________
es-discuss mailing list
[email protected]
https://mail.mozilla.org/listinfo/es-discuss

Reply via email to