Shared memory seems yucky for dynamic languages, for the reason I gave above. I had Erlang in mind where I suggested a DB for communication between concurrent processes. Obviously that is not an ultimate-high-performance communication method but I think it would work well for many web apps and versions of standard desktop UIs and such, and databases are already popular storage for such apps.

But maybe you are talking about typed languages like Cilk. I really haven’t given that issue a lot of thought, and I don’t know enough about parallel algorithms, their implementations, and how they are used in applications to say much of anything about it.

Integer codes sounds HPC to me — floating point is often too slow I think we use ’symbolic’ or ‘branching’ codes.

Workers make sense for the short-term because the www has a weird tendency to standardize early and it’s the path of least resistance, but shared memory is sort of inevitable. The real question is *how*. I’m not a fan of transactions for typical application code and as the defacto performance mechanism (agree that a persistence layer is important — still unclear how to really persist apps well at a framework level). Cilk++ is making cool leaps for shared memory abstractions (reducers are awesome!). I’m still not sure what it means to allow GC, HOFs, etc. in such an environment, but suspect that’s the camp to be looking at.

Task parallelism seems necessary for “integer codes” (or whatever you want to call the large class of applications that don’t have much data parallelism). Non-sharing worker threads look like the most likely parallelism construct to win out on the real web. I suspect most non-systems programs can do fine without shared memory or explicit locking, instead relying on separate worker threads and maybe a transactional database for communication and storage.

With the two languages I mentioned, I definitely imagined one should be able to call the other, but not free mixing. I think that can be made safe fairly easily, but getting good error messages requires some of the techniques from gradual typing, especially with function arguments.

If you go with JavaScript, the question still remains. Building blocks or end-user abstractions? E.g., I’ve found Cilk-style task parallelism to be the cleanest general model (as opposed to, say, data parallelism, which isn’t general), but you won’t get that on top of a typical implementation of worker threads.

A further question.. what about correctness? Workers are appealing because they’re isolated, though I suspect something like Zach’s sharing qualifiers work would be good too. Workers would be indepndent and need no qualifiers, and fancier (finer sharing) would use it. Or.. you can punt on that too

Btw, I assume for the mixed language bit you assume calls can go between the two, a la gradual or soft typing.

[for 'with' being bad: it introduces a dynamic scope, making analyses for optimization or security hard, and, arguably, confuses programmers for similar reasons. kind of a vague answer.]

Count me in the other group. I much prefer typed languages. I so wish there was a typed language on the web. While your at it how about real object oriented. I’d like to run Java/C# without an external VM. I guess google web toolkit may be the best thing for now. But I have not used it.

Also, ‘with’ seems to widely acknowledged as bad in some way, but what are all the problems with it? Is it just performance? Or something else?

– Personal supporting anecdote: I find every language in the ML family completely incomprehensible, not because of the semantics, but because of the near-total absence of grouping punctuation. You get chains of function applications written as “foo bar baz quux blurf snort glorple” and it takes extra mental effort to remember which things are called on what. It doesn’t help that the conversion of functions of more than one argument to a chain of curried functions is exposed in the syntax – I understand why that’s done but it should be hidden away where humans don’t have to think about it.