A model of concurrent computation in which independent entities called actors encapsulate local state, communicate solely by asynchronous message passing, and can create new actors and designate behavior for future messages; there is no shared mutable state between actors in the abstract model.

Principle

Concurrency emerges from locality and asynchronous messaging: each actor processes messages sequentially in its own context, so system‑level concurrency arises from many actors executing independently and interacting only via message sends and actor creation.

Demonstration

A web service can be modeled where a supervisor actor receives incoming requests, spawns a worker actor per request which processes it and sends a response back; failures can be isolated by supervisor strategies that restart or replace faulty child actors without shared‑memory coordination.

Misapplication

Treating actors as lightweight threads with shared mutable variables, assuming synchronous message delivery or global ordering guarantees beyond what the actor system specifies, or building designs that rely on immediate consistency of distributed mailboxes without explicit coordination.

Consequence

When applied correctly, the actor model yields designs with strong locality, scalability, fault isolation, and natural distribution; it encourages eventual consistency, message‑driven architectures, and composition by actor creation and supervision hierarchies.

Reversal

Shared‑memory multithreading models expose shared mutable state with locks or atomic operations, yielding different synchronization concerns; synchronous channel models (CSP) require rendezvous communication rather than asynchronous message passing.

Boundary

The actor model is an abstract computation model; it does not by itself guarantee delivery order, timeliness, persistence, or exactly‑once semantics—these are provided by specific implementations or protocols. The model abstracts away scheduler, mailbox implementation, and network failures unless specified.

Semantic Tension

Tension exists between the actor model and alternative concurrency models (shared memory, CSP, dataflow); another tension is between the abstract model (no shared state) and pragmatic frameworks that augment actors with futures, blocking receives, or implicit shared storage.

Synthesis

The actor model is an asynchronous, message‑oriented concurrency paradigm where isolated actors encapsulate state, interact only by sending messages and creating actors, and thereby enable scalable, distributed, and failure‑aware system design.