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 how the standard thread model fails encapsulation, introduces synchronization pain, and complicates delegation and debugging. Embrace actors with Akka to simplify concurrency.

Explore the Akka actor model, modeling code as message driven actors you can't access directly, using asynchronous messaging to simplify object interactions and address threading challenges.

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 Akka actors in Scala, building simple actors, handling immutable, serializable messages, using context, self, and sender to communicate in a non-blocking, asynchronous system.

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.

Discover how to revert to previous actor behaviors in akka using context become with true or false, build a stack of message handlers, and use unbecome to pop back.

Learn to change actor behavior with context become by rewriting stateful actors as stateless receive handlers. Explore a counter exercise and a simplified voting system to demonstrate the pattern.

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.

Configure akka with inline strings and external files, explore namespaces and multiple actor systems, and load json, properties, and conf configurations with log level examples.

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.

Explore test probes in Akka with Scala, using test kit to simulate master-slave word-count flow, sending work, handling work completed, and reporting results.

Learn how to implement timeboxed assertions with within and receive while to validate timed Akka test kit scenarios, and use test probes to verify actor behavior.

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

Explore synchronous testing of Akka actors using test actor refs and the calling thread dispatcher. Learn how this approach ensures deterministic message handling before assertions, reducing flaky tests.

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.

Explore the actor lifecycle in Akka classic with Scala, detailing actor instances, references, and paths, and explain start, suspend, resume, restart, and stop with lifecycle hooks.

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.

Explore how dispatchers control message handling in an actor system, configure custom dispatchers with thread pools and throughput, attach them to actors as execution contexts for futures and blocking calls.

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.

Learn how to implement stash in Akka with a resource actor: stash messages in closed state, switch to open with context become, and unstack all to replay messages.

Learn the ask pattern to obtain a reply from an actor using the question mark. Process futures with oncomplete or pipe, and avoid mutating state to preserve encapsulation.

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.