Chapter 1. Introduction

We are in the midst of a rapid evolution in how we build computer systems. Applications must be highly responsive to hold the interest of users with ever-decreasing attention spans, as well as evolve quickly to remain relevant to meet the ever-changing needs and expectations of the audience.

At the same time, the technologies available for building applications continue to evolve at a rapid pace (see Figure 1-1). It is now possible to effectively utilize clusters of cores on individual servers and clusters of servers that work together as a single application platform. Memory and disk storage costs have dropped. Network speeds have grown significantly, encouraging huge increases in online user activity. As a result, there has been explosive growth in the volume of data to be accumulated, analyzed, and put to good use.

Figure 1-1. It’s a New World

Put simply, science has evolved, and the requirements to serve the applications built nowadays cannot rely on the approaches used over the past 10–15 years. One concept that has emerged as an effective tool for building systems that can take advantage of the processing power harnessed by multicore, in-memory, clustered environments is the Actor model.

Created in 1973 by noted computer scientist Carl Hewitt, the Actor model was designed to be “unlike previous models of computation... inspired by physics, including general relativity and quantum mechanics.”

The Actor model defines a relatively simple but powerful way for designing and implementing applications that can distribute and share work across all system resources—from threads and cores to clusters of servers and data centers. The Actor model is used to provide an effective way for building applications that perform tasks with a high level of concurrency and increasing levels of resource efficiency. Importantly, the Actor model also has well-defined ways for handling errors and failures gracefully, ensuring a level of resilience that isolates issues and prevents cascading failures and massive downtime.

One of the most powerful aspects of the Actor model is that, in many ways, actors behave and interact very much like we humans do. Of course, how a software actor behaves in the Actor model is much simpler than how we interact as humans, but these similar behavioral patterns do provide some basic intuition when designing actor-based systems.

This simplicity and intuitive behavior of the actor as a building block allows for designing and implementing very elegant, highly efficient applications that natively know how to heal themselves when failures occur.

Building systems with actors also has a profound impact on the overall software engineering process. The system design and implementation processes with actors allows architects, designers, and developers to focus more on the core functionality of the system and focus less on the lower-level technical details needed to successfully build and maintain distributed systems.

“In general, application developers simply do not implement large scalable applications assuming distributed transactions.”

Pat Helland

In the past, building systems to support high levels of concurrency typically involved a great deal of low-level wiring and very technical programming techniques that are difficult to master. These technical challenges drew much of the attention away from the core business functionality of the system because much of the effort had to be focused on the functional details.

The end result was that a considerable amount of time and effort was spent on the plumbing and wiring, when that time could be better spent on implementing the important functionality of the system itself. When building systems with actors, things are done at a higher level of abstraction because the plumbing and wiring is already built into the Actor model. Not only does this liberate us from the gory details of traditional system implementations, it also allows for more focus on core system functionality and innovation.


Technology adoption is rarely cyclical; however, in case of the Actor model (created in the early 1970s) the spotlight is swinging back to this unique approach to distributed, concurrent computation. As Forrester Research points out in “How To Capture The Benefits Of Microservice Design” (2016), the Actor model is receiving “renewed interest as cloud concurrency challenges grow” in enterprises building microservices architectures.

This report is targeted toward decision makers in the enterprise and provides some high-level insight into how actors and actor systems can be used to create lightweight business systems that evolve quickly, that can scale, and that can run without stopping. Inside, you’ll read how the Actor model’s proven approach to concurrent computation is the best way to build distributed systems correctly from the start, allowing your teams to focus on the business logic of your applications instead of wiring together low-level protocols, in turn helping you accelerate time-to-market while keeping infrastructure costs low.

Get Designing Reactive Systems now with O’Reilly online learning.

O’Reilly members experience live online training, plus books, videos, and digital content from 200+ publishers.