Akka Classic Persistence

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
    • PostgreSQL
    • Cassandra
    • 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!

Your Instructor

Daniel Ciocîrlan
Daniel Ciocîrlan

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 February 2024, I've taught Java, Scala, Kotlin and related tech (e.g. Cats, ZIO, Spark) to 100000+ students at various levels and I've held live training sessions 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 35000 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.


Frequently Asked Questions

How long is the course? Will I have time for it?
The course is ~7 hours in length, with lectures around 20 minutes each. I recommend at least 1 hour of focused learning at one time. You can easily do this in a weekend if you're committed.
What's a typical lesson like?
Code is king, and we write it from scratch. In a typical lesson I'll explain some concepts, either briefly on a diagram or directly in the code. We then run live examples, and usually I'll finish the lesson with some exercises, which I then solve on camera after you've tried them yourself.
Can I expense this at my company?
Of course! You'll get a detailed receipt with your purchase, including VAT (if applicable to you), which you can take to your employer to reimburse. Most (wise) companies will reimburse courses like this.
Is this course hard?
This course was designed to give you a challenge, but not too much that it becomes frustrating. In case you struggle with something, we have a whole group on Slack for discussions, and I'm responsive.
I've never written Scala or Akka before. Should I take this course?
You should take the beginner Scala and Akka training first. We also have ~40 minutes of Scala/Akka overview at the beginning of the course, but that won't give you the skills you need if you've never seen this before.
I'm comfortable with both Scala and Akka and I want to make my actors live forever. Should I take this course?
Yes! This course is for you.
Daniel, I want to join but I can't afford it.
For a while, I offered discounts for the Rock the JVM courses to whomever needed them. But then I looked at the stats: almost nobody who took them actually completed any course. The full-price students were 3x as likely to complete the course. So I'm not offering discounts anymore. This course will pay off if you commit.
What if I don't like the course?
Then I want to give your money back. Email me at [email protected] with your receipt, and I will refund you. Less than 1% of the Rock the JVM students have refunded a course, and the refund took less than 72 hours.