The document discusses the actor model, which is a pattern for simplifying concurrent applications. It allows for asynchronous communication between objects known as actors, where each actor's state can only be modified by one thread at a time. This approach avoids issues with traditional concurrency using multiple threads and shared objects, which can be difficult to build efficiently while maintaining consistent state. An example in Scala demonstrates how to define an actor to handle connection and disconnection messages.

1. Actor Model

2. Google thinks this is an Actor Model

3. Actor model is a pattern to simplify
writing efficient concurrent applications

4. Concurrency: Writing applications
where different parts could run in
parallel

5. Traditional approach to concurrency
Multiple threads and Shared Objects

6. void Session::onConnectionRequest(conn) {
anvil.validateToken(conn.token);
this.addConnection(conn);
}

7. void Session::onConnectionRequest(conn) {
anvil.validateToken(conn.token);
this.addConnection(conn);
}
void Session::onDisconnectionRequest(conn) {
this.removeConnection(conn);
}

8. Publisher::onDisconnect() {
scoped_lock lock;
if (subscriber != NULL) {
subscriber.setPublisher(NULL);
}
}
Publisher::setSubscriber() {
scoped_lock lock;
subscriber = NULL;
}
Subscriber::onDisconnect() {
scoped_lock lock;
if (publisher != NULL) {
publisher.setSubscriber(NULL);
}
}
Subscriber::setPublisher() {
scoped_lock lock;
publisher = NULL;
}

9. Traditional concurrency
It is difficult to build efficient applications while
maintaining consistent state

10. Fundamentally, the biggest challenge that
SendGrid faces in development is concurrent
programming. While what we do isn’t rocket
science, doing it at a scale of over 500
million messages per day is extremely
challenging (I’ve done rocket science, this
is way harder).

11. Solution 1: ad-hoc solutions and fix bugs
forever

12. Solution 2: rendition

13. Solution 3: Actor Model

14. Actor Model concurrency approach
Asynchronous communication between objects
Object state is only modified from one thread at
a specific time

15. Multiple threads
and Shared
Objects

16. Actor Model

17. Example
sealed trait SessionMessage
case object ConnectMessage extends SessionMessage
case object DisconnectMessage extends SessionMessage
class Session extends Actor with ActorLogging {
def receive = {
case ConnectMessage => log.info("Connecting")
case DisconnectMessage => log.info("Disconnecting")
}
}
object Demo extends App {
val system = ActorSystem("MySystem")
val session = system.actorOf(Props[Session], name="session1")
session ! ConnectMessage
session ! DisconnectMessage
}

18. Bonus Track
supervision
persistency
distribution