
Already know some of this? A 2-minute test skips the lessons you know.
Take the placement testA free 15-lesson course built from Arpit Bhayani's 2h 17m of YouTube playlist. 2 days at 90 minutes a day, with study notes and a quiz in every lesson. A 2-minute placement test skips what you already know.
Taught by Arpit Bhayani on YouTube. Videos play in YouTube's own player, so the creator keeps every view.
Implement a sequential Go program to count primes up to 100 million, establishing a performance baseline of ~3 minutes 55 seconds.
Parallelize the prime count by splitting the range into equal batches per thread, observing a speedup to ~1 minute but unfair workload distribution due to increasing prime-check cost.
Implement a shared atomic counter so threads dynamically grab the next number to check, achieving fair ~51-second runtime across all threads.
Create a TCP server that listens on a port, accepts a single connection, reads the request, processes it, writes an HTTP response, and closes the connection.
Modify the server to run an infinite loop so it continuously accepts and handles requests one after another.
Apply thread pools to limit resource usage, connection timeouts to prevent hung connections, and OS backlog tuning to queue pending connections.
Learner will be able to explain how count++ compiles to multiple assembly instructions (load, increment, store) and how thread interleaving at the micro-operation level causes lost updates.
Demonstrates how concurrent goroutines incrementing a shared counter without synchronization produce incorrect results due to non-atomic read-modify-write operations.
Understand why standard queues are not thread-safe and the need for concurrent queues in multi-threaded environments.
Identify practical use cases like thread pools and batch processing, and understand the performance trade-offs of pessimistic locking.
Build a runnable C program that spawns six threads competing for locks on three records to reliably reproduce a deadlock hang.
Implement a global ordering rule (e.g., numeric ID) so every thread acquires locks in the same sequence, guaranteeing deadlock freedom.
Understand how pessimistic locking serializes access to critical sections and why it becomes a throughput bottleneck under high contention.
Inspect generated assembly to see the cmpxchg instruction, understand its atomic execution guarantee, and learn how compilers map atomic operations to hardware primitives.
Understand the memory, context-switching, and stability issues caused by creating a new thread for every incoming request.