[Haskell] What would Haskell middleware look like?

[Paul Johnson]

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.