As I write this, it is roughly 10 years since I started the Akka project. I created Akka out of my own curiosity and need, scratching an itch to build better distributed systems on the JVM after years of being let down by EJBs, CORBA, and RMI. I knew that I was on to something good early on in the project but I could never imagine its incredible success and adoption—all the things people are using Akka for is quite mind-boggling and humbling. It’s been an incredible journey, through which I’ve learned so much and met so many amazing people, some that have become close friends.
Now, 10 years is a long time; but it all started long before that. When Carl Hewitt invented the Actor Model in the early 70s he was way ahead of his time. Through the concept of autonomous processes he called actors, he defined a computational model embracing non-determinism—assuming all communication being asynchronous. Non-determinism might sound like a bad thing but is actually what enables concurrency, which together with the concept of stable addresses to stateful isolated processes allows actors to be decoupled in both time and space, supporting distribution, mobility, and location transparency.
Today, the world has caught up with Hewitt’s visionary thinking; multi-core processors, cloud computing, mobile devices, and the internet of things is the norm. This has fundamentally changed our industry and the need for a solid foundation to model concurrent and distributed processes is greater than ever. I believe that the Actor Model provides the firm ground we so desperately need in order to build complex distributed systems that are up for the job of addressing today’s challenges—adhering to the Reactive principles of being responsive, resilient, and elastic. This is the reason I created Akka; to put the power of the Actor Model into the hands of the regular developer.
The Reactive principles that Akka stands on are not new but can be traced back to the ’70s and ’80s and the groundbreaking work by Jim Gray and Pat Helland on the Tandem System, and Joe Armstrong and Robert Virding on Erlang. However, as with Hewitt, these pioneers were ahead of their time, and it was not until the past 5-10 years that the technology industry at large was forced to rethink current best practices for enterprise system development and learned to apply the hard-won knowledge of the Reactive principles to today’s world of distributed systems and multicore architectures.
While it’s clear that Akka stands firmly on the shoulders of giants, I do believe that we have pushed the envelope in some areas ourselves—sometimes through the adoption of, and productive collaboration with, current research in distributed systems. Examples include:
Akka Typed (bringing type-safety to actors)
Akka Persistence (enterprise-grade implementation of event sourcing and CQRS, that has helped popularize the concepts)
Akka Streams (type-safe high-throughput low-latency streaming, work that also lead to the creation of the Reactive Streams specification and JDK Flow API)
Akka Multi-DC (a unique and pragmatic blend of strong and eventual consistency for cross-datacenter CRDT-based event log replication)
Alpakka (reactive stream-native integration library)
How we improved on the Erlang failure management story by adding mandatory parental supervision (while still allowing actors to ‘watch’ each other’s health cross-hierarchy).
Of course, along the way we have also tried a bunch of ideas that turned out less than good: Transactors (bridging STM and actors), Typed Actors (an OO-style proxy-based actor, not to be confused with Akka Typed above), Agents, !! & !!! (look those up :-)), durable actor mailboxes (backed by BookKeeper) , and ZooKeeper-based clustering comes to mind.
It’s been a fun ride. I’m deeply grateful for so many things, but if I would pick one single thing, it would be our incredible community—Akka would be nothing without its passionate, helpful, and generous community. Looking forward to where the next 10 years will take us. Happy hAkking!
Before you go, check out this 10-Year Akkaversary Magazine—a commemorative guide of white papers, blog posts, and articles that have shaped the Akka journey. It’s a collector’s edition of hand-picked content from Akka thought leaders, experts, and contributors that you will not want to miss.