Akka Essentials with Scala

Meet the Actor Model. Dive into a better way of thinking concurrent and distributed code.


Think concurrency differently.

If you're reading this, you've probably heard about Akka or the actor model. It's one of the most powerful abstractions of concurrent programming we've had, even though it's not new. No more creating threads, no more locking, double-locking, deadlocks and concurrency problems. With actors, you can write heavily concurrent and distributed systems quickly, without the usual headaches. As such, massively parallel and distributed backends all over the place are powered by Akka.

This course is for the Scala developer willing to tap into the actor model and a new way of thinking parallel and distributed code.

After this course, you'll be able to:

  • write parallel code with actors instead of threads and locks
  • manage actors in hierarchies
  • adopt the "let it crash" philosophy with supervision
  • configure Akka for anything
  • test concurrent applications with actors
  • parallelize and delegate tasks to actors
  • use the best practices in working with the actor model

Plus some extra perks:

  • You'll have access to the entire code I write on camera (all 2863 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:

  • Work with actors instead of threads
    • understand the thread model limitations
    • adopt a new mindset with actors as the fundamental resource
    • learn how actors are closest to the original object-oriented ideal
    • send and receive messages
    • change actor behavior dynamically
    • spawn child actors and actor hierarchies
    • learn about system guardians
    • log messages for easier debugging
    • learn how to configure an Akka application in 5 different ways
  • Test Akka applications
    • use TestKit and assertions
    • use TestProbes
    • write timed assertions
    • intercept actor logs to verify correct functionality
  • Achieve fault-tolerance in parallel applications
    • start and stop actors programmatically and via message passing
    • manage actor lifecycle
    • create supervisor strategies to recover from failure
    • use the Backoff Supervisor pattern to access an external resource that failed
  • Deeply understand and use the Akka infrastructure
    • schedule messages and
    • manage timeouts
    • parallelize and distribute tasks to workers with Routers
    • use custom dispatchers for underlying thread management
    • use custom mailboxes to process messages on your own terms
  • Learn advanced techniques
    • stash messages for later use
    • use finite state machines (FSM) as its own DSL for highly stateful actors

all with live runnable examples and practiced with exercises.


Course Overview

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 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.


Frequently Asked Questions

How long is the course? Will I have time for it?
The course is ~12 hours in length, with lectures around 20 minutes each. I recommend at least 1 hour of focused learning at one time.
How is a usual 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?
I've designed the course 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 before. Should I take this course?
You shouldn't. The course is for Scala programmers. Even though we do a bit of a recap at the beginning of the course to make sure we're all on the same page, that part is not enough to give you confident skills with Scala if you've never seen it before.
I don't know how threads work. Should I take this course?
I don't recommend it. You should at least understand what threads are and how a normal computer can do multiple things at the same time.
I'm comfortable with Scala and threads and I'm curious about this actor model. Should I take this course?
Yes! This course is made 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.