Overall Objectives

Compiled Learning Objectives

At the end of the sprint, you should be able to do the following things. Make sure to check you can do them all, and if not, go back and keep practicing until you can.

Threads and Concurrency (Prep)

• Explain why we use concurrency.
• Explain why web applications are concurrent by default.
• Define a race condition.

Memory Models (Prep)

• Suggest orders of magnitude for the speed of different read operations.

Intro Reading (Prep)

• Define concurrency.
• Differentiate between parallelism and concurrency.
• Start multiple concurrent threads of execution (either threads or goroutines).
• (If in Go): Define a channel.
• (If in Go): Send information between goroutines using a channel.

Single-variable Concurrency (Prep)

• Identify thread safety issues when updating a single variable.
• Explain how += operations can cause bad writes in the presence of threads.
• Describe (at a high level) three approaches to fixing single-variable thread-safety issues.

Atomics (Prep)

• Define an atomic operation.
• Use an atomic operation to avoid a race condition when modifying an integer.
• Explain how an atomic operation avoids a read-modify-write race condition.
• Define the term ‘memory barrier’/‘fence’ in the context of memory models.

Mutexes (Prep)

• Solve a race condition with a mutex.
• Define a critical section.
• Identify the critical section in concurrent code.
• Explain the risks of mis-identifying the critical section, and releasing locks early.
• Choose between using mutexes and atomics.

Deadlock (Prep)

• Define deadlock.
• Identify causes of deadlock in code.

Re-entrance (Prep)

• Define re-entrance.
• Explain how a re-entrant lock can avoid deadlock.
• Identify sources of deadlock when using non-re-entrant locks.

Project: Cache with Stats (Prep)

• Implement thread-safe code.

Optimising Locks (Prep)

• Evaluate trade-offs between using a mutex and a read-write mutex.
• Shard locks to reduce contention.
• Propose the trade-offs of loosening API guarantees.

Computing Cache (Prep)

• Avoid concurrency problems with message passing instead of locking.

Comparing Implementations (Prep)

• Identify trade-offs in different code implementing the same interface.
• Evaluate the expense of operations in code.
• Identify sources of lock contention in code.