My advice still holds: this post is about the future implications of some forms of continuations in asynchronous programming and not your intimate thoughts on me.

My excuses to my readers for being part of this flamewar.

That’s because you have concealed it so magically, I guess.

“You should have at least checked the links, to understand the “loop unrolling” thingy or where the examples came from.”

By all likelihood, I’ve known about loop unrolling since when you could still walk upright under the kitchen table, kemo sabe, and I know it has nothing to do with continuations, perhaps except for in Stephen King stories.

“Sadly, since you didn’t even mention “cooperative threading” (hint: THIS is the point),
continue to discuss only the minor aspect of the formal definition of “Continuations” (which, as you said, is maybe inexact, but not wrong)”

I didn’t, because I gather you know about cooperative threading about as much as you know about continuations — and talking about “the minor aspect of the formal definition of “Continuations”" is like talking about the minor aspect of the formal definition of addition You can’t talk about something if you have no idea what it is.

“and use much more words to state that I’m wrong than to explain why,”

Granted, I haven’t been any more successful in explaining to you why you’re wrong than I would be explaining to a blind man the concept of color. Don’t blame it on me though…

“make me fear that you are more interested in a monologue on you formal knowledge of continuations that on an argumentation on the future implications of some form of continuations in asynchronous programming.”

I can see you’re still missing the point, and looks like you wouldn’t see it if it hit you on the nose. Not that I’ve offered tons of “formal knowledge” here, but in case you’re deluded about that too — formal knowledge isn’t a dirty phrase. Your ravings about future-implications-blah-blah are of little value if you can’t get simple things straight in the first place.

BTW, my advice still holds — more reading and listening, less talking and preaching.

Sadly, since you didn’t even mention “cooperative threading” (hint: THIS is the point),
continue to discuss only the minor aspect of the formal definition of “Continuations” (which, as you said, is maybe inexact, but not wrong)
and use much more words to state that I’m wrong than to explain why,
make me fear that you are more interested in a monologue on you formal knowledge of continuations that on an argumentation on the future implications of some form of continuations in asynchronous programming.

I played around with the thought of answering your questions, but gave it up almost immediately. Those aren’t the right questions. Heck, those questions aren’t even WRONG :)))

The main point of continuations is that they replace the usual call-return model in which we describe program structure. Let’s now revisit some of your questions:

- Aren’t generators a kind of continuation?
- Aren’t continuations an elegant way to do iterators?

Maybe, but who cares? Everything that has to do with execution control can be seen as a kind of continuation, but that would be arbitrarily far-fetched, depending on the case.

The example of *iterator* you gave (not a generator) is just as easily understood in terms of call-return as it is in terms of continuations. Note that, in your discussion, you’re reasoning in terms of call-return (functions, calls, etc.) — where exactly do continuations come in?

Furthermore, the explanation there is just plain wrong, with a lot of uncertainty about who calls what and when, and I’m not going to talk about the loop unrolling reference that you must have thrown in for good measure — it’s so out of place, with simply nothing to do with the “case”.

See, I would gladly send you “corrections”, if only I could reasonably start somewhere. However, it would be much, much more trouble than explaining continuations to someone who has never heard of them — that’s because, pretty much along the lines of what John said above, your post is so wrong it actually makes people dumber.

It is not just the problem of missing the target, because that would imply having aimed at the target in the first place — rather, it is the fundamental problem of preaching what you don’t understand. You’re not in the need of being corrected, you obviously need a radically different approach to knowledge and understanding.

Aren’t generators a kind of continuation?
Aren’t continuations an elegant way to do iterators?
Doesn’t Jetty “continuations” allows to resume only the HTTP connection?
And doesn’t narrativeJS allows to do simple “continuations” without language support?
Doesn’t those “simple continuations” allows to do lightweight cooperative threading?
Aren’t those “simple continuations” (one-shot & escape continuation, call as you like) an easy way to simplify the life with events?

@Madarco: I believe I posted a very good suggestion to you. Hate to tell you twice, but you haven’t the slightest idea of what you’re talking about. There may still be hope for you though — just go and sort this thing out in your head first.