Akka is the Ideal Runtime for Building Reactive Applications on the JVM
Imagine building concurrent, distributed applications with ease and confidence. Akka, and the Actor model, ensures entire systems are not brought down by failures, but rather heal and adapt on their own.
Akka decouples business logic from low-level mechanisms such as threads, locks and non-blocking I/O, and liberates developers from the hariest challenges of managing the state and location of services.
Message-driven Runtime for Reactive Applications
Akka is an Actor-based runtime for managing concurrency, elasticity and resilience on the JVM with support for both Java and Scala.
In Akka, the communication between services is a first-class citizen, with messaging primitives that optimize for CPU utilization, low latency, high throughput and scalability (hardened from years of contributions from the open source community).
From its earliest origins powering high volume financial services environments, Akka’s footprint has grown across online gaming, retail/e-commerce, media and every major industry. Today, Akka is also highly leveraged in Internet of Things applications, where fine-grained failure management and messaging between microservices are table stakes for production deployments.
We're delivering the future of money to over 148 million people worldwide. Using Scala and Akka, we can rapidly develop, test, and deliver services that are reliable and performant at massive scale.
Message-Driven Runtime is the Foundation to Reactive Applications
In Akka, your business logic is driven through message-based communication patterns that are independent of physical locations. Whether your Actors live on the same thread, a different machine, or a different datacenter—the semantics are the same. You focus on the business logic while Akka handles the lower level plumbing to give your applications Reactive characteristics:
Resilience is a core tenet of Reactive applications, yet is often the most overlooked. With Akka, you get resilience for free as part of the model. Akka provides fault-tolerance based on supervisor hierarchies. Every Actor can create other Actors, which it will then supervise, making decisions if they should be resumed, restarted, retired or if the problem should be escalated. Instead of trying all things possible to prevent an error from happening, this approach lets you embrace the reality of unplanned errors. It means you can adopt a pragmatic ‘Let It Crash’ philosophy, with the confidence that the impacted components will be reset to a stable state and restarted upon failure.
Threads and non-blocking I/O are complex and error-prone to build by hand, which means they waste your time. With Akka's implementation of the Actor concurrency model, you are freed to focus on your application's business logic and let Akka think about scaling up.
Scalability and Elasticity
Scale out on multicore servers and multiple nodes using Akka makes application elasticity and true scale on demand a reality. On commodity hardware, you might run several million Actors—a huge step up from mere thousands of threads in a traditional Java application.
Scala & Java APIs
In keeping with the pragmatism of the rest of the Typesafe Reactive Platform, Akka has a APIs for both Java and Scala. This means smooth interoperability, and no need to learn or adopt Scala at all. Akka can run standalone on a JVM or deployed in your existing Java Application Server.
Akka Code Samples & Tutorials
Hello Akka Activator Template
Akka is a toolkit and runtime for building highly concurrent, distributed, and fault tolerant event-driven apps. This simple application will get you started building Actor based systems in Java and Scala. This app uses Akka 2.2, Java 6, Scala 2.10, JUnit, and ScalaTest.DETAILS
Hello Akka (Java 8) Activator Template
This simple Akka application uses Java 8 and Lambdas for a concise Reactive programming model with Actors.DETAILS
Reactive Stocks Activator Template
The Reactive Stocks application uses Java, Play Framework, and Akka to illustrate a reactive app. The tutorial in this example will teach you the reactive basics including Reactive Composition and Reactive Push.DETAILS
Akka Reading Materials
DZone Refcard for Akka
This Refcard covers theoretical issues briefly, then dives in to defining and creating actors and messages, actor hierarchies, fault-tolerance and self-healing, and more.DOWNLOAD NOW
Akka In Action
Akka in Action is a comprehensive tutorial on building message-oriented systems using Akka. The book takes a hands-on approach, where each new concept is followed by an example that shows you how it works, how to implement the code, and how to (unit) test it.DOWNLOAD NOW
Reactive Design Patterns
Reactive Design Patterns is a clearly-written guide for building event-driven distributed systems that are resilient, responsive, and scalable. Written by the authors of the Reactive Manifesto, this book teaches you to apply reactive design principles to the real problems of distributed application development.DOWNLOAD NOW
Jonas Bonér on Reactive Systems Anti-Patterns
InfoQ asked Jonas Bonér, Typesafe CTO and original author of the first Reactive Manifesto, some questions about his vision of “Reactive” applications. Jonas offered his thoughts about both desirable features of reactive applications and what is not reactive programming.READ NOW
Akka Videos & Webinars
Deep Dive into the Typesafe Reactive Platform - Akka and Scala
In this episode of the "Deep Dive in to the Typesafe Reactive Platform" series, Nilanjan Raychaudhuri walks you through building Reactive apps with Akka and Scala. He will expand on both projects and outline how they support the Typesafe Platform.WATCH NOW
Tuning and Monitoring Akka
Jan and Alex show how they measured and tuned an actor system and a Play Framework application in a major financial services organization. The talk explores the challenges of monitoring mission-critical systems, especially under heavy load. Presenters show the driving principles of finding out what Akka and Play actually do, and how to ideally design and tune your code.WATCH NOW
Intro To Akka Persistance
Patrik Nordwall hosts "Intro To Akka Persistence." Akka Persistence is a new module in Akka 2.3 that adds actor state persistence and at-least-once message delivery semantics to Akka.WATCH NOW
Introducing Reactive Streams
In this webinar, Roland Kuhn presents Reactive Streams, showing you how to handle data flow the right way!WATCH NOW
Akka Success Stories
Sub 20ms Response - Ticketfly
Ticketfly crafted a powerful reserved seating engine (something that is notoriously complicated to build because of its rapidly changing state), that could scale easily, handle bursty and unpredictable traffic patterns and compete with online ticket scalpers. The Reactive non-blocking system allows visitors to find and allocate seats, under load, in less than 20ms. The system has very good performance without having to try very hard to achieve it.READ THE CASE STUDY
75% Faster - Lucidchart
1000 node 2400 Akka Cluster In 4 Minutes - Google
Typesafe has been working together with the Google Cloud Platform team to test our Akka Cluster on Google Compute Engine. The goal was to push our runtime to its limits and gain insight into how to scale systems on this platform. The results are jaw dropping—reaching 2400 nodes as well as starting up a 1000 node cluster in just over four minutes.READ THE BLOG POST
100x Bursty Traffic Increase - Gilt Groupe
Over the course of a few seconds, Gilt’s traffic can increase by as much as 100x. Essentially, they need to have the e-commerce infrastructure almost at Amazon scale for at least 15 minutes every day. Most days this happens exactly at noon EST, and until a couple of years ago, noon was a stressful time every day. Nowadays it’s usually a non-event—in part because of Typesafe. This Q&A with architect Eric Bowman describes Gilt Groupe's journey from Rails to Reactive.READ THE BLOG POST
Here are some additional ideas on how to get started:
Visit the Typesafe Resource Center or Go Typesafe
Read the full documentation
Visit the community website
Follow Akka on Twitter
Participate on Stack Overflow
Join the Mailing List
Contribute at GitHub
If you plan to develop a commercial application, your business could benefit from a relationship with Typesafe. The Typesafe Together annual subscription program is designed to mitigate risk and ensure the successful launch and operation of your application by delivering certified builds and amazing service throughout the entire project lifecycle—from prototyping to production.LEARN MORE ABOUT SUBSCRIPTIONS