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

Course

CS-206: Parallelism and concurrency

Lectures in this course (61)

Introduction to Concurrency

Covers the basics of concurrency, its importance, and how to write concurrent programs.

Concurrency Basics: Threads and Synchronization

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

Atomic execution: Synchronization in threads

Covers atomic execution in threads, race conditions, shared variables, and synchronized blocks.

Money Transfers: Synchronized Global Log

Explains the synchronized approach to log money transfers in an online banking system.

Concurrency: Deadlock

Covers the concept of deadlock in concurrent programming and provides solutions to prevent them.

One place buffer: Producer-consumer queue

Introduces the concept of a one-place buffer in concurrent programming.

Dining philosopher problem

Presents an algorithm to prevent starvation and maximize philosophers eating simultaneously.

Concurrency Overview

Explores the significance of concurrency in enhancing system performance and responsiveness, emphasizing the need for synchronization and atomicity to prevent race conditions and non-determinism.

Actor Composition: Patterns and Strategies

Explores actor composition, fundamental patterns, result aggregation, risk delegation, and façade strategies in actor systems.

Distributed Actors: Principles and Failure Detection

Explores distributed actors, failure detection in clusters, and lifecycle monitoring for distributed fail-over.

Data-Parallel Operations: Part 1

Explores data-parallel operations in Scala, converting collections, implementing sum, and examining fold operations.

Data-Parallel Operations: Scala Programming

Covers data-parallel operations in Scala programming, focusing on fold operations and aggregate operation.

Data-Parallel Programming: Basics and Mandelbrot Set

Covers data-parallel programming basics and rendering the Mandelbrot set efficiently.

Designing Actor Systems

Explores the design principles of actor systems in reactive programming, covering topics like web clients, timeouts, and actor interactions.

Dining Philosophers Problem

Discusses algorithms to prevent starvation and maximize philosophers eating simultaneously.

Eventual Consistency: Actors and Data Structures

Explores eventual consistency, actors in Scala, and the importance of suitable data structures for achieving consistency in distributed systems.

Concurrency with Executors

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

Parallel Computation: Tasks

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

Amortized Conc-Tree Appends

Explores constant time appends in Conc-Trees and counting in a binary number system.

Fold Reduce Operations

Explores fold (reduce) operations in parallel programming using Scala, covering associative operations, expression trees, parallel reduction, and array reduction.