Design templates with actors.

The actor-based paradigm is pretty steep. Its ability to scale effectively makes it a paradigm that needs to be evaluated for any parallel system. I have read something about this, and I have a decent idea of ​​the main intentions: manage your expensive operation with messages and several "actors" to minimize expectations due to interaction with the request / response, thereby increasing the throughput of your system. However, I did not have enough impact on the design patterns that people use with actors. I am looking for design patterns for acting systems.

A common example of an actor’s design pattern is a system in which there is an actor-master coordinator and a group of child labor participants. They cope with an expensive operation into smaller pieces, send smaller pieces in the form of messages to a handful of workers, wait for answers from them, and then reduce them all to the result. In some complex examples of this template, participating workers notify the wizard that they are ready for more work, and the master routes to them work more on demand. This provides the right balance of work and is useful when job sizes change quite a bit.

I was looking for literature on more actor-based patterns and could not find any examples other than the above. I have yet to go through Akka Actors project projects, but any pointers would be very helpful.

+6
source share
4 answers

I highly recommend Derek Wyatt " Akka Concurrency " - it focuses on the latest distribution of Akka (2.1) and follows a few best practices for using Akka and many design patterns (emphasizing event driven design). However, he assumes fair information in Scala.

Posts from the Akka Summer of Blog series are also very helpful (some of them are also written by Derek [and one by me]).

+10
source

Check out http://en.wikipedia.org/wiki/Flow-based_programming and http://en.wikipedia.org/wiki/Dataflow_programming first . An actor model is a subset of the programming of data streams, and the implementation of actor models is even more limited.

+3
source

It is worth mentioning the work on enterprise integration templates ( http://www.eaipatterns.com/ ). It is possible that the word "actor" is never mentioned in their work, but the translation from the processor lineup to the actors is trivial, for example, the translation of Poe from English into French. The load balancing patterns, as you described, are the smallest of what you learn there.

+1
source

I found some more event-driven programming literature.

http://www.amazon.com/Event-Based-Programming-Taking-Events-Limit/dp/1590596439/ref=pd_rhf_ee_s_cp_8

A chapter on event-based interaction patterns seems promising

+1
source

All Articles