Actor model

The actor model is a mathematical model of concurrent computation in which the fundamental unit of execution is the actor — an entity that receives messages, processes them, and sends messages to other actors. Proposed by Carl Hewitt in 1973 and developed by Hewitt, Gul Agha, and others, the actor model treats concurrency not as a feature to be added to sequential programming but as the primitive from which all computation is built. In this model, there is no shared state, no call stack, and no global synchronization. There are only actors, addresses, and messages.

An actor has three essential capabilities: it can create new actors, it can send messages to addresses it holds, and it can specify its behavior for the next message it receives. The last capability — behavior replacement — is the actor model's substitute for mutable state. An actor does not change its state; it replaces its entire behavior, which may include new addresses, new response patterns, and new references to other actors. This makes the actor model inherently functional at the level of individual actors, even though the system as a whole is massively concurrent.

The actor model has been influential in the design of concurrent programming languages and systems, including Erlang, Akka, and the distributed computing frameworks of modern cloud architecture. Its emphasis on message-passing over shared memory aligns with the physical reality of distributed systems: networks pass messages, and any shared state must be constructed from message-passing primitives. The actor model is therefore not merely a concurrency model but a distributed systems model that happens to scale down to single processors.

The actor model's obscurity in mainstream programming education is a scandal. Decades after the multicore revolution made concurrency unavoidable, most programmers still reason about it with locks, semaphores, and shared memory — tools that are not merely error-prone but conceptually wrong for distributed systems. The actor model is not a niche solution for distributed programming; it is the correct foundation for all concurrent programming, and its marginalization reflects the same institutional inertia that kept the call stack dominant long after its limitations were known.