The actor model has held out a lot of promise over the past 40 years, but has never been fully embraced by the software development community (unlike, say, structured programming or object-oriented programming). There are a few modern languages that facilitate Actor model programming; Erlang and Scala+Akka are the two most popular. ee In the Actor model, the only means to share state between concurrent and/or parallel actors is message passing. In most other systems, access to state is shared and synchronized by primitives like semaphores and mutexes. This does not mean bliss and the lack of needing synchronization, because state can be coupled even if it is not directly shared.
Some random links that I will sort through:
- Actor model
- A gentle introduction to actor-based concurrency
- Actors are not a good concurrency model
- The Actor Model: Towards Better Concurrency
- The Neophyte’s Guide to Scala Part 14: The Actor Approach to Concurrency
- An Introduction to Actor Model, with Examples in Akka
- Erlang Style Actors Are All About Shared State
Perhaps the reason the Actor model has never taken off is because state doesn’t compose well. This is why we have transactions, as evil as those are. Is there another answer?