Concurrency support?

Nicolas Cannasse ncannasse at motion-twin.com
Tue Jun 27 00:12:00 PDT 2006


>>There's been a lot of creativity in the past years about the way of
>>using continuations. I think we can except new paradigms in the future
>>as well. As a compiler writer, I prefer to be able to directly use
>>call/cc in the generated code and libraries instead of rewrapping and
>>sometimes abusing the standard ES4 library.
> 
> 
> This gets to the heart of an issue that Nicolas has discussed with me  
> in private email: is ES4/JS2 likely to be a high-level language used  
> by programmers who write large parts of their programs by hand, or is  
> it likely to be a mid-level or "variable level" safe target language  
> whose programs compilers generate based on other inputs (haXe, Google  
> GWT, etc.)?

Although I would support that, this is of course not what I'm proposing.

ES4 already has the goal of being an high level language, and Brendan
clearly explained to me why this is important for people on board at TG1.

What I'm proposing is to open the black box. For instance let's compare
two possibilities regarding the current continuations subject :

a) call/cc is available on the native side only. Some native libraries
(threads, coroutines, generators) are using it - with care - for their
implementations.

b) same than (a), but call/cc is also available as a "lowlevel" function
that can be called from any ES4 program.

It's just a matter of offering maximum access to users of the system. In
that case, "offering" is of course different from "promoting". There
should be one clearly promoted way of getting things done, yet I don't
see any reason for forbidding other usage possibilities.

The success of a language is greatly influenced by the stuff good
programmers will comeup with, and how it will impress the community.
While it's very good to focus of the average user case when designing
APIs and writing documentation, somehow locking the system and saying
"there is one single way to do things that we decide" can result in
frustration for future ES4 "hackers" that want to do things differently.

I clearly understand that this is not the only thing at stake with
call/cc and continuations. There is also design/implementations concerns
which I fully understand. But I think this way of thinking when
designing a language or implementing a library can be applied to a lot
of other different topics.

Of course, I'm biased there but I think this way of thinking is shared
with a lot of people outside.

Nicolas




More information about the Es4-discuss mailing list