Design Patterns with Actors

The actor based paradigm is pretty cool. Its ability to scale effectively makes it a paradigm to must-evaluate for any concurrent system. I have done some reading about it, and have a decent idea about the core intent: drive your expensive operation with messages and multiple "actors" to minimize waits due to request/response interactions thereby increasing the throughput of your system. However, I have not had sufficient exposure to the design patterns people use with actors. I am looking for design patterns for actor based systems.

A common example of an actor design pattern is a system where there is a master-coordinator actor and a bunch of child worker actors. They master maps the expensive operation to smaller chunks, sends the smaller chunks as messages to the bunch of workers, waits for responses from them and then reduces them all to the result. In some sophisticated examples of this pattern , the worker actors notify the master that they are ready for more work, and the master routes to them more work on demand. This ensures proper balance of work and is useful when job sizes vary quite a bit.

I searched around for literature on more actor based patterns and couldn't find any examples other than the one above yet. I am yet to go through Akka Actors project samples, but any pointers would be very useful.

Upvotes: 9

Answers (5)

Arnold Schrijver

Reputation: 3753

I just gave a more elaborate answer to a similar question, but I will summarize here the resources I found most interesting regarding the Actor model.

Design Patterns:

Meet the Top Akka.NET Design Patterns (language-independent description)
Akka Interaction Patterns (good concepts, quite Akka-specific)
Applied Akka Patterns (O'Reilly book, good conceptual overview, Akka-specific codez)

Reactive Actors & DDD:

Using the Actor Model with Domain-Driven Design (DDD) in Reactive Systems (the Vaughn Vernon way)
DDD, Event Sourcing and Actors (the Alexey Zimarev twist to the architecture)

Proto Actor (project by one of Akka's creators with help from Alexey Zimarev). I find this project easier to comprehend than Akka, which is very elaborate (I have no affiliation to them, but considering use):

And then searching on Github actor-model topic may yield interesting stuff.

Some more book recommendations I found in the QCon Video Actors or Not: Async Event Architectures:

Enterprise Integration Patterns by Gregor Hohpe and Bobby Woolf: That's right, this book from 2003 is still relevant.
Reactive Messaging Patterns with the Actor Model by Vaughn Vernon that applies the EAI patterns specifically to actor designs.

Upvotes: 2

Dave Griffith

Reputation: 20515

It's worth mentioning the work on Enterprise Integration Patterns (http://www.eaipatterns.com/) here. It's entirely possible that the word "actor" is never mentioned in their work, but the translation from queue processors to actors is trivial, like translating Poe from English to French. Patterns for load balancing like you describe are the least of what you'll learn there.

Upvotes: 1

adelbertc

Reputation: 7320

I highly recommend Derek Wyatt's "Akka Concurrency" book - it is focused on the latest Akka distribution (2.1) and goes over several best practices of using Akka and lots of design patterns (emphasizing event-driven design). It does assume a fair bit of knowledge in Scala however.

The posts from the Akka Summer of Blog series is also really helpful (several of them are also written by Derek [and one by me]).

Upvotes: 11

vishr

Reputation: 995

I found some more literature on event-based-programming.

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

The chapter on event based interaction patterns seemed promising

Upvotes: 1