Actors are a popular way to write concurrent & distributed programs. Immutable messages are passed between actors which do the required processing, avoiding the difficulties inherent in sharing data among threads/processes.
Tuplespaces (best exemplified in current times by JavaSpaces) are a way to decouple cooperating processes by using pattern-matching to share immutable and persistent data objects.
Many distributed algorithms can be modelled as a flow of objects between participants.
Or, if you prefer, substitute “parallel” for “distributed” and “messages” for “objects”.
So what do you get if you combine the pattern-based communication of tuplespaces with the message processing paradigm of actors? Loosely-coupled actors.
Actually, as I see it, you get two things:
- An easier way to write tuplespace programs: the actor DSL provides a formalism for describing reading, writing, and consuming of tuples and the behaviour associated with these operations.
- Pattern-based communication between actors with no explicit reference to each other: actors are decoupled in both (address)space and time (since messages are persistent objects.)
In both cases, a (hopefully) better way to write concurrent programs.
To the best of my knowledge, no one has tried this yet.
Note: I wrote a longer piece on this topic yesterday with more explanation and references. For those wanting a little more…