I've noticed that many other languages have a middleware to handle
distribution and concurrency issues. Haskell has STM for shared-memory
concurrency, but there is no mechanism (AFAIK) for distribution. So
I've been having a think about what one might look like.
The primary requirements seem to me to be:
* Transactions:
STM is great, and the concept should work for distributed computation as
well. So you should be able to say something like:
atomic $ do { send message1 remote1; send message2 remote2}
Both remote1 and remote2 processes will have world-visible state
modified by the messages, but either they both happen atomically or
neither happens.
* Pi Calculus
I've been reading a bit about this, and I think I see the basic ideas.
The middleware operations should have a formal semantics specified in
the Pi calculus, on the grounds that its the best formalism currently
available. That way we can prove that the operations preserve desirable
properties.
* Replication
If you want a reliable distributed system you absolutely have to have
replicated tasks. Haskell's strict control over side effects is a big
strength here: the headache for reliable replication has always been
threads doing non-deterministic stuff that gets them out of sync. How
does the IO monad interact with this? Replicated threads cannot be in
the IO monad because that doesn't guarantee determinism, but they need
to interact with the real world somehow.
* Configuration management
Another big headache for middleware. If you are not careful it can turn
out that the only way to upgrade a component in the system is to upgrade
all the components simultaneously, which is not really an option in a
big system that has to stay up 24x7. Component names are not the right
place for version numbers, and you need some formal definition of upward
compatibility. Could XML have a place here? It does let you do duck
typing. Or can we come up with something stronger?
* Serialization of circular data structures. "show" is fine for
non-looping structures, but what about:
let
x = 1 : y
y = 2 : x
Can we find a way of transmitting such a structure?
Thats all I can think of for now.
Paul.
_______________________________________________
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell
