When Carl Hewitt invented the Actor Model 50 years ago this year, he was well ahead of his time. Through the concept of Actors, he defined a computational model embracing non-determinism—which assumes all communication is asynchronous. Non-determinism might sound negative, but it’s actually quite positive. It enables concurrency, which, together with the concept of long-lived stable addresses to stateful isolated Actors, allows Actors to be decoupled in time and space, supporting service distribution, location transparency, and mobility.
Today, the world has caught up with Hewitt’s visionary thinking; multi-core processors, cloud and edge computing, IoT, and mobile devices are the norm. This has fundamentally changed our industry, and the need for a solid foundation to model concurrent and distributed processes is more significant than ever. Actors provide the firm ground required to build complex distributed systems that address today’s challenges in cloud and edge computing. This is why I created Akka: to put the power of the Actor Model into the hands of all developers.
As Carl Hewitt once said, “One actor is no actor.” Actors come in systems. They collaborate, replicate, self-organize, and self-heal, not far from biological systems observed in nature. What is fascinating about actor systems is that the harsher, less predictable, and more prone to failure the environment is, the more they thrive. It is the ultimate programming model for tackling the challenges at the edge.
I’ve written before that we should not see the cloud and edge as separate things, “either-or” or “black and white,” but as a continuum. In an ideal world, one should not have to think about cloud and edge differently—design, architect, and develop for each separately. There is too much complexity standing in the way of getting things done that developers have to deal with—finding their way through a jungle of products, libraries, tools, and techniques, and once selected, left with the puzzle of composing them into a single functioning system.
We need to raise the abstraction level and liberate developers, set them free to focus on the essence: writing business logic. This calls for the unification of cloud and edge, a single programming model, runtime, and data fabric that abstracts and manages the underlying details, complexity, and vast differences in infrastructure requirements and the guarantees it can provide.
Enter Akka Edge: a single programming model, runtime, and data fabric for and across the Cloud-to-Edge Continuum. It is a continuation of the work we have done in Akka for the last 14 years, leveraging the power of the Actor Model, which allows you to write your service once and see it run anywhere throughout the whole continuum—from the centralized cloud all the way out to the devices.
Where something will run—on-prem, cloud, edge, or device—should not dictate how it is designed, implemented, or deployed. The optimal location for a service at any specific moment might change and is highly dependent on how the application is being used and the location of its users. Instead, the guiding principles of Akka Edge evolve around data and service mobility, location transparency, self-organization, self-healing, and the promise of physical co-location of data, processing, and end-user—meaning that the correct data is always where it needs to be, for the required duration, nothing less or longer, even as the user moves physically in space.
I’m thrilled to be able to announce the release of Akka Edge. It marks the beginning of the next chapter of Akka’s story, a new and very exciting chapter. And we are just getting started; we continue to have big plans for Akka going forward.
You can find the documentation here—dive into the getting started guide, features, example use-cases, or its design and architecture. As always, let us know what you think.