Lecture

The Actor Model: Principles of Reactive Programming

Graph Chat

Chat with Graph Search

Ask any question about EPFL courses, lectures, exercises, research, news, etc. or try the example questions below.

DISCLAIMER: The Graph Chatbot is not programmed to provide explicit or categorical answers to your questions. Rather, it transforms your questions into API requests that are distributed across the various IT services officially administered by EPFL. Its purpose is solely to collect and recommend relevant references to content that you can explore to help you answer your questions.

Description

This lecture introduces the Actor Model, which represents objects and their interactions similar to human organizations. The Actor Model is built upon the laws of physics and emphasizes asynchronous message passing. The lecture covers the definition of an Actor, the Actor Trait, creating stateful and stateless Actors, sending messages between Actors, changing an Actor's behavior, and creating/stopping Actors. Examples and code snippets are provided to illustrate the concepts, including how Actors can send messages, create new Actors, and define behaviors. The lecture concludes by explaining the actions an Actor can take upon receiving a message.

Official source

Related concepts (32)

Actor model

The actor model in computer science is a mathematical model of concurrent computation that treats an actor as the basic building block of concurrent computation. In response to a message it receives, an actor can: make local decisions, create more actors, send more messages, and determine how to respond to the next message received. Actors may modify their own private state, but can only affect each other indirectly through messaging (removing the need for lock-based synchronization). The actor model originated in 1973.

Message passing

In computer science, message passing is a technique for invoking behavior (i.e., running a program) on a computer. The invoking program sends a message to a process (which may be an actor or object) and relies on that process and its supporting infrastructure to then select and run some appropriate code. Message passing differs from conventional programming where a process, subroutine, or function is directly invoked by name. Message passing is key to some models of concurrency and object-oriented programming.

Message queue

In computer science, message queues and mailboxes are software-engineering components typically used for inter-process communication (IPC), or for inter-thread communication within the same process. They use a queue for messaging – the passing of control or of content. Group communication systems provide similar kinds of functionality. The message queue paradigm is a sibling of the publisher/subscriber pattern, and is typically one part of a larger message-oriented middleware system.

Message Passing Interface

Message Passing Interface (MPI) is a standardized and portable message-passing standard designed to function on parallel computing architectures. The MPI standard defines the syntax and semantics of library routines that are useful to a wide range of users writing portable message-passing programs in C, C++, and Fortran. There are several open-source MPI implementations, which fostered the development of a parallel software industry, and encouraged development of portable and scalable large-scale parallel applications.

Actor model theory

In theoretical computer science, Actor model theory concerns theoretical issues for the Actor model. Actors are the primitives that form the basis of the Actor model of concurrent digital computation. In response to a message that it receives, an Actor can make local decisions, create more Actors, send more messages, and designate how to respond to the next message received. Actor model theory incorporates theories of the events and structures of Actor computations, their proof theory, and denotational models.

Related lectures (21)

The Actor Model: Principles of Reactive Programming

Introduces the Actor Model, explaining actors' identity, behavior, and asynchronous message passing.

Lock-Free Synchronization: Performance and Scalability

Explores lock-free synchronization for performance and scalability in distributed systems, covering unique identifier generation, messaging queues, and atomic RDMA reads.

Reactive Programming: Scalability

Covers the principles of reactive programming with a focus on scalability and various routing strategies.

Designing Actor Systems

Covers the principles of designing actor systems for reactive programming and explores practical examples like the Link Checker system.

Actor Messaging Semantics