Building Scalable Applications with the Actor Model Greg Shackles Principal Engineer, Olo @gshackles github.com/gshackles 

Scaling: Up or Out? 

Moore’s Law 

OK fine, let’s get concurrent! 

Multithreaded Programming
 
 Theory 

Multithreaded Programming
 
 Practice 

Oh right, concurrency is hard... 

Amdahl’s law The theoretical speedup is always limited by the part of the task that cannot benefit from the improvement. 

The Actor Model A better concurrency abstraction 

What is an actor? Mailbox Behavior State 

What can an actor do? ! Send messages ! Create other actors ! Change behavior 

Messages ! Invoke actor behavior by sending it a message ! Messages are ○ Immutable ○ Processed one at a time, in order 

Creating other actors 

Everything is an actor 

Behavior ! Switch how an actor will handle its next message ○ Referred to as becoming something ! User actor in a chat system can become: ○ Authenticating ○ Authenticated ○ Unauthenticated ○ ...and so on 

! Actors are only referenced by address ○ Think: phone numbers, email addresses ! Code doesn’t know or care where the actor is ! Scaling from one node to thousands becomes configuration Location Transparency 

Reactive Systems reactivemanifesto.org Responsive Message Driven Elastic Resilient 

No content

C#: Create a message public class Greet
 {
 public string Who { get; } public Greet(string who)
 {
 Who = who;
 }
 } 

C#: Create an actor public class GreetingActor : ReceiveActor
 {
 public GreetingActor()
 {
 Receive(greet =>
 Console.WriteLine($"Hello {greet.Who}");
 }
 } 

var system = ActorSystem.Create("my-system"); var greeter = system.ActorOf("greeter"); greeter.Tell(new Greet("World")); C#: Send a message 

F#: Create a message type Message = | Greet of string 

F#: Create an actor let handleMessage (mailbox: Actor<'a>) msg = match msg with | Greet who -> printf "Hello %s" who | _ -> () 

let system = ActorSystem.Create("my-system") let greeter = spawn system "greeter" (actorOf2 handleMessage) greeter

Supervision ! An actor can respond to subordinate actor failures with a directive to: ○ Resume the subordinate ○ Restart the subordinate ○ Stop the subordinate ○ Escalate to its own supervisor ! Actors are cheap, let them crash 

Example Supervision Strategy protected override SupervisorStrategy SupervisorStrategy() => new OneForOneStrategy( maxNrOfRetries: 10, withinTimeRange: TimeSpan.FromSeconds(30), decider: Decider.From(ex => { if (ex is ArithmeticException) return Directive.Resume; else if (ex is NotSupportedException) return Directive.Stop; return Directive.Restart; })); 

! Categories of messaging patterns: ○ At most once ○ At least once ○ Exactly once ! Default is at-most-once delivery ○ i.e. no guaranteed delivery Message Delivery Reliability 

! Special type of actor that routes messages to its routees ! Built-in routing strategies ○ Round robin ○ Broadcast ○ Random ○ Consistent hashing ○ Tail chopping ○ Scatter-gather first-completed ○ Smallest mailbox Routers 

Actor system topology is just configuration 

Configuration
 
 Router akka.actor.deployment { /webhook-worker-pool { router = round-robin-pool nr-of-instances = 5 } } 

Configuration
 
 Remoting actor { provider = "Akka.Remote.RemoteActorRefProvider, Akka.Remote" deployment { /remoteecho { remote = "akka.tcp://DeployTarget@localhost:8090" } } } remote { helios.tcp { port = 0 hostname = localhost } } 

Configuration
 
 Clustering akka { actor.provider = "Akka.Cluster.ClusterActorRefProvider, Akka.Cluster" remote { helios.tcp { port = 8081 hostname = localhost } } cluster { seed-nodes = ["akka.tcp://ClusterSystem@localhost:8081"] roles = ["crawlerV1", "crawlerV2"] role.["crawlerV1"].min-nr-of-members = 3 } } 

Demo github.com/gshackles/akka-samples