Loading learning path...
Progress from threads and synchronization to transactional concurrency, replicated logs and causal state. Apply the foundations to bounded queues, commit rules, stale writers and failure recovery.
The curriculum and complete lessons are free with an account. Optional practice resources and Ono usage follow your plan’s allowances.
Distinguish three layers: in-process synchronization, transactional state, and distributed coordination. Repository tasks model deterministic state transitions; they do not replace stress-testing real parallel code.
How to study: Work in order. Predict the result before opening a visualizer, implement before reading the editorial, and explain the invariant and edge cases after each exercise. Repository and review activities are paired: fix the behavior, then assess a proposed change independently. Choose a supported language or repository environment; you do not need to repeat every environment. Existing completion of shared content counts toward this path.
Check your understanding: • Draw a failing interleaving before proposing a lock or transaction boundary. • Explain why a stale leader, concurrent sibling or expired receipt must not overwrite authoritative state. • Review the difference between a successful response, a committed entry and a durable visible effect.
Process Definition
Context Switching: The Heart of Multitasking
Thread Fundamentals
Threading Models: Mapping User and Kernel Threads
Concurrency Concepts
Fork-Join Model
Thread Pools
Asynchronous Programming
Common Concurrency Patterns
Race Conditions
The Critical Section Problem
Requirements for Solutions to the Critical Section Problem
Mutex Locks: Mutual Exclusion Primitives
Spinlocks
Compare-and-Swap: Foundation of Lock-Free Concurrency
Futex: Fast Userspace Mutex
Atomic Operations: The Indivisible Units of Concurrency
Thread Safety
Design Concurrent HashMap
Semaphore Concepts
The Producer-Consumer Problem
Readers-Writers Problem
Monitor Concept
Condition Variables: Synchronization for Complex Coordination
Signal Semantics in Condition Variables
Understanding Deadlock Concepts
Necessary Conditions for Deadlock
Deadlock Prevention Strategies
Deadlock Detection and Recovery
Design Thread-Safe Blocking Queue
Design Multi-threaded Merge Sort
Producer-Consumer Pattern
Thread Pool Pattern
Read-Write Lock Pattern
Future and Promise Pattern
Double-Checked Locking Pattern
Immutable Objects for Concurrency
Active Object Pattern
Design a Pub Sub System
Conflict Serializability
Understanding the Lost Update Problem
Isolation Levels
Two-Phase Locking Protocol
Multi-Version Concurrency Control (MVCC)
Snapshot Isolation: Consistent Views for Concurrent Transactions
Unit of Work Pattern
Pending credit holds allow the account to overcommit
Subtract pending credit commitments
An unsuccessful credit capture changes account balances
Capture reserved credit only once
Stale document saves overwrite a newer edit
Reject saves based on an old document version
An old custody screen overwrites a newer sample revision
Transfer only the current sample revision
What Is a Distributed System?
Fallacies of Distributed Computing
Time in Distributed Systems
Ordering and Causality in Distributed Systems
CAP Theorem: Understanding Distributed System Trade-offs
Consistency Models in Distributed Systems
Strong Consistency
Eventual Consistency
Causal Consistency
Quorum-Based Replication
The Consensus Problem
Leader Election
Raft Consensus Algorithm
Distributed Locking
Coordination Services
Compare last log terms before log lengths
Compare last log terms before log lengths
Truncate conflicting uncommitted suffixes
Truncate conflicting uncommitted suffixes
Require a current-term entry for leader commit
Require a current-term entry for leader commit
Repair higher-term stepdown and one-vote guards
Repair higher-term stepdown and one-vote guards
Keep acknowledgements monotonic and follower commits bounded
Keep acknowledgements monotonic and follower commits bounded
Design a Consensus Protocol (Raft / Paxos)
Conflict Resolution Strategies
CRDTs (Conflict-free Replicated Data Types)
Data Synchronization Patterns
Join vector clocks componentwise by maximum
Join vector clocks componentwise by maximum
Retain versions absent from an unaware replica
Retain versions absent from an unaware replica
Record deletion as a causal tombstone version
Record deletion as a causal tombstone version
Separate actor counters from visible value deduplication
Separate actor counters from visible value deduplication
Require stable tombstone coverage and a valid frontier
Require stable tombstone coverage and a valid frontier
Delivery Guarantees
Message Ordering in Distributed Systems
Outbox Pattern
The Saga Pattern: Managing Distributed Transactions
Retry with Backoff: Building Resilient Distributed Systems
Failure Injection
Failed notification commits leave a delivered message
Deliver queued notifications only
Failed release journals leave a partially published room
Isolate the editorial transaction draft
Design a Distributed Database (Cassandra / DynamoDB)
Design a Distributed Task Scheduler
Complete this path to earn a personalised certificate. You choose whether to make it public.