The Akka/Apache Pekko Bundle

Everything you need to become an expert Akka/Apache Pekko developer. Master Akka/Apache Pekko with Scala and distributed JVM applications through clear lessons, practical exercises, and a smooth learning curve. Ideal for those with some programming experience, this bundle will take you from zero to hero.

Take this course

Goal

Think distributed systems differently.

You know Akka and the actor model - one of the most powerful abstractions of concurrent programming we’ve had, even though it’s not new. Use actors instead of threads and locks, go immortal with event sourcing, reactive with streams, distribute everything with remoting and clustering, build large scale distributed systems like they did all over the place.

This series is for the Scala programmer who needs to work with Akka and needs a clear path to mastering it. Rock the JVM has - to my knowledge, and I’ve searched way past the second page on Google - the only such path in existence.

This bundle contains

300+ live runnable examples
150+ exercises with solutions
10000+ lines of code written from scratch, more than most engineers push in a year
(I have exactly 10423 lines on camera, which I’ll share with you 100%)
Access to a growing private community on Slack
~50 hours of HD content (soon downloadable)
(Soon) takeaway slides
All updates and additional material for free, for life

”Show me the path.”

If you came here thinking, “I want to learn Akka, just show me a step-by-step way to do it, and I’ll follow”, this is it. There’s little else for me to say. More than 4000 people have taken this journey and they speak:

I’ve heard guys working years with scala saying that the Akka Streams library is so complex that only the lightbend folks that write it can use it. I’ve given it a try in the past, but after going beyond basic sources, sinks and flow i was like WTF!!. Daniel once again nails it, explains so nicely every single details, and spreads some light into such a hard topic. This course is so advanced that you will probably have to go through it 2 or more times, but after you do, daniel presents everything so nicely that you will definetely be a master of Akka Streams. Honestly Daniel is like my Scala Guru. (Giannis P. on Akka Streams, Feb. 2019)

The course is awesome!! As expected of course from Daniel, a great teacher going in depth for all concepts and explaining the WHYs and not just the HOWs. Currently on my journey to become a true master of the Akka world, can’t wait to continue with the rest of the series. Thanks for helping us rock Daniel!! (Kyriakos T. on the Akka series, Jan. 2020)

There are >1000 reviews like that, and that’s on Udemy. The version you’re looking at is even better and with exclusive new material.

This path is literally what you need to follow to be good at Akka, and it’s the only series on the web of this scale and complexity.

Skills You'll Learn

After this Akka/Pekko masterclass, you will be equipped to

work with the actor model in projects of any size or complexity
stream data effortlessly with the Streams library and tools
deploy your own reactive HTTP servers and clients

With the Akka (or Pekko) toolkit, you will be able to write backends of any complexity, for any company, distributed or local.

Akka and Pekko features we cover

Full coverage of the actor model
- thread model limitations
- actors and OOP
- actor interactions with messages
- changing actor behavior
- spawning child actors
- deploying actor hierarchies
- managing system guardians
- logging
- configuration
- managing actor lifecycles
- actor supervision in case of failure
- restoring functionality
- scheduling
- timeouts
- workload parallelization
- dispatchers
- mailbox configuration
- stashing messages for later use
- interaction patterns e.g. pipe or ask
- full testing
Reactive Streaming
- stream components
- materialization
- backpressure
- testing components and streams
- Graph DSL and custom stream architectures
- control graph cycles
- custom stream components
- interaction with external services
- fault tolerance and error recovery
- parallelization
- runtime management
- customizing component shapes, logic or materialized values
Servers and microservices
- low-level HTTP processing
- URLs, headers, payloads, responses
- manipulating JSON
- handling paths
- extracting query parameters
- routing and composition
- file uploads/downloads
- WebSockets
- JWT authorizations
- handling rehections
- error recovery
- streaming input/output
- client mode

In short, everything you need to write backends of any complexity with Akka (or Pekko, its open-source sibling).

Additional perks:

Full access to all the code written during the courses — over 10000 lines of Scala!
Invitation to join a private Slack community, where you’ll get exclusive updates, opportunities, and discussions
Access to all slides for easy reference
Free updates and expansions, no expiration date

Meet Rock the JVM

Daniel Ciocîrlan

I'm a software engineer and the founder of Rock the JVM.

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.

Included Courses

Akka/Apache Pekko Essentials with Scala

Say goodbye to threads, locks, and headaches: meet the Actor Model and discover a smarter approach to concurrent and distributed coding — classic actors also available
Akka/Apache Pekko Streams with Scala

Harness the power of reactive streams using Akka/Apache Pekko Streams with Scala: learn to implement scalable, data-rich systems efficiently, writing in a few lines what takes others thousands to achieve
Akka/Apache Pekko HTTP with Scala

Build microservices in minutes using Akka/Apache Pekko HTTP with Scala: Develop stream-based REST APIs, backends, and microservices with ease, sending and receiving JSON effortlessly using a powerful server DSL
Akka Classic Essentials with Scala

Become a Akka Classic developer by mastering the essentials of Akka Classic with Scala using our comprehensive, hands-on course
Akka Classic Persistence with Scala

Embrace a new approach to persistence and storage with Akka Persistence and Scala, a solution that perfectly complements the Actor Model
Akka Classic Remoting & Clustering with Scala

Unlock the power of large-scale, reactive distributed systems with Akka Classic Remoting & Clustering with Scala, and experience unparalleled scalability and resilience in your applications
Akka Classic Serialization with Scala

Don't waste months on ineffective Java serialization: boost your Akka system's performance with Akka Classic Serialization with Scala using Avro, Kryo, or Protobuf

Take this course now!