Akka Classic Essentials with Scala

Recap the Scala features: values and variables, expressions, types and unit, functions, tail recursion, object oriented concepts, generics, case classes, exceptions, and tools like map, for comprehensions, and pattern matching.

Master advanced Scala concepts with partial functions, lifting, and or else, plus type aliases and implicits. Explore implicit values, conversions, and scope rules in relation to Akka and multithreading.

Explore creating and managing threads in the JVM with runnable, start, and join; understand thread safety through synchronized and volatile, and harness Scala futures with map, flatMap, filter and onComplete.

Explore Akka's actor model in code by creating an actor system, defining actors with receive, and sending asynchronous messages via tell using actor references, props, and companion objects.

Explore two akka classic exercises in scala: a counter actor with increment, decrement, and print, and a bank account actor with deposit, withdraw, and statement.

Explore how Akka schedules actors on a thread pool, enqueues messages in mailboxes, and guarantees single-threaded, atomic processing per actor. Understand at most once delivery and per-pair message order.

Explore how Akka actors change behavior over time with a mom and fuzzy kid scenario, using vegetable and chocolate messages and using context become to swap handlers.

Explore Akka's child actors, context-based creation, and guardian hierarchies, then learn actor selection by path and the importance of not exposing mutable state or this reference.

Leverage Akka child actors to implement a master–worker word counting exercise with round-robin task distribution and task IDs. Track original senders with a request map to return correct counts.

Explore actor logging in Akka, using explicit logging or the actor logging trait, with messages at debug, info, warn, and error levels; learn parameter interpolation and async stdout logging.

Learn to test akka actor systems with test kit by creating a test suite, an actor system, and basic specs. Explore asynchronous assertions, expect messages, and perform teardown.

Learn to use Akka TestKit's event filters to intercept log messages in integration tests, illustrated with a checkout flow and configurable log timing.

Learn to start and stop actors in akka classic with scala, using context.stop for children and self, plus poison pill, kill, and death watch for termination awareness.

Learn how Akka supervision controls actor failures to build fault-tolerant systems. Use one-for-one and all-for-one strategies to restart, resume, stop, or escalate, with death watch.

Learn the backoff supervisor pattern in Akka to avoid mass restarts when external resources recover; use exponential delays and randomness to stagger retries for failing actors.

Explore akka schedulers and timers to run code after a delay or at intervals, using schedule once and schedule with interval, plus timers for self messages and cancellation.

Explore Akka routers to delegate work across multiple actors using round robin, pool, and group routing, with manual, config-based, and group approaches demonstrated in Scala.

Learn how Akka mailbox systems manage actor messages by building a custom priority mailbox and a control aware mailbox, then configure dispatchers and observe processing order.

Akka finite state machines simplify complex actor logic using a vending machine controller example, with stateful transitions, messages, and test suites.

Learn to rewrite a vending machine as an Akka FSM, defining vending states and data, using go to, stay, and initialize, with state timeout handling.

Celebrate the shift from threads and locks to actors and messages. Review handlers, supervision, dispatchers, mailboxes, routers, and schedulers as you build robust Scala Akka applications.