mark nottingham

‘e’ is a new one on me and looks interesting. As I’m sure you know, putting paralell processing support directly into the syntax of a programming language isn’t new and I guess reached the height of fashion back in the 80s when the debate was lightweight (co-routines, Simula and Algol’s tasks, Occam’s ‘par’) versus Ada’s overweight monitors, rendezvous, etc. I was reminded of all this recently, when looking at Ericsson’s Erlang: http://www.erlang.org/

It would be neat to see a mainstream programming language where you have to go out of your way to make a function not reentrant, e.g. make ‘synchronized’ as the default state for a Java method.

Making “synchronized” the default… a further step might be to make variables thread-specific by default. In order to share state between threads, one would have to explicitly declare a variable as shared.

Maybe too far from current Java but perhaps useful would be to prohibit sharing data except for objects specifically designed for sharing. i.e. no need to “synchronize” new kinds of data structures. There could be some small number of shared-memory data structures, perhaps just one: a shared queue.

Aside from a shared “map”-like structure which is discouraged, Erlang provides no sharing whatsoever. A Java-like mechanism that allowed only one shared data structure could also allow that data structure to be used in a distributed mode as well.

On another note, something like E but also something like REST is the Waterken web services model…

http://www.waterken.com/http/www.waterken.com/

And a side-note: apparently an in-progress version of Squeak Smalltalk is being developed to include capabilities based on those in E.

-Patrick

E has the concept of Vats, which are like isolated memory spaces with their own event loops. To communicate with an object in another vat, you have to have a capability to that object, and talking to an object in another vat is no different than talking to an object across the network (including the need for the different syntax). In a more traditional (non-JVM) environment, Vats might merely be processes.

In any case, sharing of data between vats is all explicit. Personally I don’t think there should be any shared data structures; everything should be accomplished using message-passing.

I absolutely agree that talking to remote objects should appear syntactically to be a different thing than talking to something locally. As processors become dual-core and multiprocessor systems become more common, programmers are going to have to become more aware of the data they are sharing, and where. Making it obvious when data should cross a process boundary also makes it obvious how to coordinate it across multiple processors. Explicit is good.