Actor
An actor is an independent entity or participant that performs actions, maintains or pursues state or goals, and interacts with other entities or systems.
BDD in Action, Second Edition
An actor is a person, system, or process that interacts with the system under test and pursues goals through activities and abilities.
- How it is used
- Identifies stakeholders in impact mapping and participants whose goals and activities organize Screenplay tests.
- How deep it goes
- Defines actors and shows task performance, abilities, and Cast configuration through worked automation examples.
- Examples
- Uses flight booking, loan approval, and Playwright-backed actor configuration to distinguish goals, participants, and abilities.
- What you can do after
- Build it from scratch: identify actors and goals, then configure actors to perform reusable business tasks in tests.
Akka in Action, Second Edition
An actor is an independent computational entity in the actor model that encapsulates state and behavior and communicates through asynchronous messages.
- How it is used
- Builds concurrent and distributed applications from small message-driven components that can scale across available resources and servers.
- How deep it goes
- Explains creation, messaging, mailboxes, behavior, state, supervision, remote references, recovery, and testing, while deferring distributed and clustered mechanics.
- Examples
- Uses deposit-and-state wallet variants, conversation and mentions components, supervisors, and isolated or multi-actor test scenarios.
- What you can do after
- Builds message-driven components with private state, asynchronous communication, configurable placement, and supervisory failure responses.
Functional Design and Architecture: Examples in Haskell
A concurrent actor is an independent computational entity that receives requests, updates private state, and produces responses or effects.
- How it is used
- Organizes reactive simulator components that independently process data, retain state, and interact through protocols.
- How deep it goes
- Defines actor properties and develops a threaded simulator actor with an MVar request–response implementation.
- Examples
- Uses spaceship sensors, controllers, navigation devices, and a simulator supporting run, start, and shutdown requests.
- What you can do after
- Build it from scratch as a threaded simulator actor using an MVar request–response protocol.
Read how Functional Design and Architecture: Examples in Haskell explains actor →
Functional Programming in Scala, Second Edition
An actor is a computational component that communicates through asynchronous messages and processes them according to its internal state.
- How it is used
- Uses actors to coordinate asynchronous results while implementing a non-blocking parallel computation API.
- How deep it goes
- Defines message processing and demonstrates map2 coordination, but defers the subtle implementation details of a complete actor runtime.
- Examples
- Demonstrates a string echoer and an actor that combines two asynchronous Par results.
- What you can do after
- Apply it via a Scala actor implementation to serialize concurrent messages and coordinate asynchronous callbacks.
Read how Functional Programming in Scala, Second Edition explains actor →
Object-Oriented Software Design in C++
An actor is a person, external system, or other entity that interacts with an application in a use case.
- How it is used
- Uses actors to identify external participants and connect them to application use cases during requirements analysis.
- How deep it goes
- Defines actors and their diagram relationships, then elaborates their goals, triggers, actions, and outcomes in use case descriptions.
- Examples
- Shows librarians, customers, and a database system interacting with a book catalogue application.
- What you can do after
- Apply actors in UML use case diagrams and descriptions to specify who or what initiates and participates in application behavior.
Read how Object-Oriented Software Design in C++ explains actor →
Software Design for Python Programmers
An actor is a person, system, or other entity that interacts with an application through a use case.
- How it is used
- Clarifies external participants and their interactions while defining application requirements through use cases.
- How deep it goes
- Defines actors, distinguishes them from application functionality, and applies them to diagrams and detailed use case descriptions.
- Examples
- Uses librarians, customers, database systems, and a customer-driven book catalogue search as concrete examples.
- What you can do after
- Evaluate application requirements by identifying external participants and documenting their triggered action sequences.
Read how Software Design for Python Programmers explains actor →
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
An actor is a person, group, or system whose actions can contribute to achieving a business goal.
- How it is used
- Maps people, roles, systems, and other entities that participate in domain processes and interactions.
- How deep it goes
- Defines actor notation and demonstrates interactions, but stops short of implementation details or formal behavioral specifications.
- Examples
- Uses salespeople, legal teams, customers, doctors, contracts systems, approval systems, and prescription services in workflow models.
- What you can do after
- Apply it via EventStorming and Domain Storytelling to model responsibilities, interactions, and process sequences.
Related concepts
- message passinguses · A technique in which computational entities exchange messages to communicate or propagate information, often coordinating work or updating state.
- distributed systempart of · A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
- concurrencykind of · Concurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.
- concurrency primitivekind of · A concurrency primitive is a fundamental mechanism, construct, or protocol for coordinating concurrent execution and controlling access to shared state or resources.
- Akkaused by · Akka is an open-source toolkit for building concurrent, distributed, and resilient applications on the JVM using actor-based abstractions.
- Actix Webimplemented by · Actix Web is a Rust web framework for building asynchronous HTTP servers, web applications, and services.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.