I’ve always thought that the Actor model of concurrency has good potential for the multi-core future. It was therefore interesting to see all of the recent coverage of Axum (nee Maestro), an Actor based concurrency framework currently being implemented as an incubation project at Microsoft. There was an interesting, and quick, overview talk at the recent Lang.Net symposium.
Basically, actors are isolated into domains, where a domain is a boundary that protects shared state. The actors are tagged as readers and writers by the way that they access this shared state, and the system ensures that only a single writer or multiple readers may execute at the same time within the same domain. Communication happens between the domains using channels, which are a lot like C# interfaces in the that they control the values and messages that may be communicated. They are stronger than interfaces in that they may contain state machine definitions which reflect the patterns of messages that may pass across the channel. The messages may carry values which are passed by value, and the system generates the marshalling code for passing the data, avoiding the need to rely on user defined serialization functions. The system guarantee that only a single writer will be running within the same domain makes it a lot easier to avoid the need for locking within the application code, and the channel patterns make it a lot easier to ensure that the access patterns avoid deadlock in the application code.
Axum is currently implemented as a new language that looks a like C# and which runs on top of the CCR which in turn sits on the CLR.