Akka Persistence with Scala
Embrace a different way of thinking persistence and storage. As it happens, it fits the Actor Model like a glove.
Hello, Event Sourcing.
At this point, I won't need to pitch Akka to you - no more threads and locks, we use Actors instead, this model is used all over the place in highly distributed systems, etc. etc. The next logical phase of the model is: how can we really adopt the "let it crash" philosophy and still keep the system up to date and not lose in-memory state?
Akka Persistence is the answer. This course is for the Scala & Akka developer who needs to make their system long-lived and fault-tolerant.
After this course, you'll be able to:
- use Event Sourcing, a new technique for storing data
- use actors that never "truly" die
- manage actor state recovery
- use snapshots for speedy recovery
- avoid the common pitfalls while working with persistent actors
- integrate various storage systems with Akka, including Postgres and Cassandra
- write your own custom data serialization
- write robust architectures by detaching the business logic (domain) model from the data model
- think long-term about your system events with Event Adapters
- implement the CQRS pattern
Plus some extra perks:
- You'll have access to the entire code I write on camera (all 1276 lines of it)
- You'll be invited to our private Slack room where I'll share latest updates, discounts, talks, conferences, and recruitment opportunities
- (soon) You'll have access to the takeaway slides
- (soon) You'll be able to download the videos for your offline view
Skills you'll get:
Use Event Sourcing, a new technique for storing data
- use Persistent Actors
- manage Persistent Actors state and recovery
- know the difference between a Command and an Event
- use various persisting techniques, including async persisting
- use snapshots for quick state recovery
Integrate production-ready stores
- local stores with LevelDB
- plus custom serialization techniques (advanced)
Use advanced patterns and best practices
- effectively decouple the domain model from the data model
- use Event Adapters for the long term
- implement the CQRS pattern with Akka Persistence Query
Avoid crucial mistakes which can break your system
- breaking actor encapsulation because of improper persisting
- journal failures
- recovery failures
- journal corruption
- losing snapshots
- messing up the event order
all with live runnable examples and practiced with exercises.
Get started now!
I'm a software engineer and the founder of Rock the JVM. I started the Rock the JVM project out of love for Scala and the technologies it powers - they are all amazing tools and I want to share as much of my experience with them as I can.
As of June 2021, I've taught Java, Scala and related tech (e.g. Akka, Cats, Spark) to 41000+ students at various levels and I've held live trainings for some of the best companies in the industry, including Adobe and Apple. I've also taught university students who now work at Google and Facebook (among others), I've held Hour of Code for 7-year-olds and I've taught more than 20000 kids to code.
I have a Master's Degree in Computer Science and I wrote my Bachelor and Master theses on Quantum Computation. Before starting to learn programming, I won medals at international Physics competitions.