Mediaspace scheduled maintenance: Aug 25, 2026 07:00 - 12:00 AM. During this time, videos will be temporarily unavailable. Check status updates.

Lecture

Message Processing Semantics

Related lectures (32)

Actor Messaging Semantics

Covers the semantics of message processing in Akka actors, emphasizing actor encapsulation and collaboration.

The Actor Model: Principles of Reactive Programming

Covers the Actor Model, emphasizing asynchronous message passing and changing an Actor's behavior.

Reactive Programming: Scalability

Covers the principles of reactive programming with a focus on scalability and various routing strategies.

The Actor Model: Principles of Reactive Programming

Introduces the Actor Model, explaining actors' identity, behavior, and asynchronous message passing.

Concurrency with Futures

Explores futures as a structured approach to concurrency, simplifying parallel tasks and input-output operations.

Asynchronous Programming with Futures

Explores asynchronous programming with futures, showcasing benefits, challenges, and efficient implementations.

Asynchronous Programming: Callbacks and Failures

Covers the concept of asynchronous programming and how to handle dependencies and failures.

Concurrency Semantics and Verification

Explores concurrency semantics, recursive functions, loops, interleaving modeling, and interpreter verification.

Concurrent Stack: Implementation

Explains the reference implementation for a concurrent stack and the importance of handling concurrency issues.

Parallel Computation: Tasks

Explores parallel computation using tasks for concurrent execution and demonstrates their implementation in practice.

Distributed Actor Communication

Explores the impact of network communication on actors and covers distributed actor communication, clusters formation, and remote deployment.

Concurrency with Executors

Covers the basics of concurrency properties, Executors, Runnable objects, ForkJoinPool, task completion handling, execution contexts in Scala, and simplifying task execution.

Actors: Evolution and Implementation

Covers the evolution of Actors, challenges of modern CPUs, parallel programming risks, and synchronization tools in Scala.

One-place Buffer: Monitor-based Implementation

Discusses the implementation of a one-place buffer using monitors in a concurrent environment.

Akka Streams: Programming Reactive Systems

Covers Akka Streams basics, stream stages concurrency, materialized values, and more.

Monitors: Synchronization and Cooperation

Explores monitors as a synchronization construct providing mutual exclusion and cooperation among threads, with examples like the one-place buffer.

Concurrency and Parallelism: Queue

Explores thread safety, synchronization, and concurrent collections in Scala, focusing on a lock-free concurrent queue implementation.

Concurrency Basics: Threads and Synchronization

Covers the basics of concurrency, focusing on threads and synchronization, including thread joining and challenges of non-deterministic execution.

Testing Akka Typed Behaviors

Covers the challenges of testing actors and demonstrates the Akka Typed Behavior Test Kit.

Concurrency Properties: Basics and Locks

Explores concurrency properties, race conditions, and the basics of locks.