Advanced Go and Concurrency Course

Lesson 1 • Functions and Error Handling

Teaches variadic functions, closures, and Go's explicit error pattern. Correct error propagation is required for all production code in later chapters.

Lesson 2 • Core Types and Control Flow

Covers primitive types, composite literals, and control structures. Provides the vocabulary needed to express algorithms in idiomatic Go.

Lesson 3 • Go Environment Setup and Modules

Install Go, configure workspace, and initialize modules with go.mod. Establishes the reproducible build foundation every subsequent chapter depends on.

Lesson 4 • Structs, Methods, and Interfaces

Defines struct embedding, method sets, and implicit interface satisfaction. These abstractions underpin every concurrent design pattern covered later.

Lesson 1 • The Go Runtime Scheduler

Covers the M:N scheduler, GOMAXPROCS, and work-stealing queues. Understanding scheduling decisions prevents performance surprises in concurrent programs.

Lesson 2 • Goroutine Fundamentals

Explains goroutine creation, stack growth, and the go keyword. Grounds all concurrency work in a precise mental model of lightweight threads.

Lesson 3 • Goroutine Pools and Limiting Concurrency

Implements worker pools to bound resource usage and prevent goroutine explosion. Directly applicable to HTTP handlers and batch-processing pipelines.

Lesson 1 • Select Statement and Multiplexing

Explains select semantics, default cases, and priority patterns. Select is the primary tool for combining multiple concurrent event sources.

Lesson 2 • Channel Mechanics and Semantics

Covers buffered vs. unbuffered channels, send/receive blocking, and channel closing. Precise semantics prevent the deadlocks and panics addressed in later sections.

Lesson 3 • Directional Channels and API Design

Teaches send-only and receive-only channel types for enforcing ownership. Directional types make concurrent APIs self-documenting and compiler-enforced.

Lesson 4 • Advanced Channel Patterns

Covers done channels, heartbeat channels, and tee patterns for observability. Prepares students for the context-based cancellation introduced in the next chapter.

Lesson 1 • Condition Variables and sync.Once

Explains sync.Cond for event-driven waiting and sync.Once for safe initialization. These primitives solve coordination problems channels cannot express cleanly.

Lesson 2 • Mutex and RWMutex Usage

Covers sync.Mutex, sync.RWMutex, and lock-granularity trade-offs. Correct mutex usage is the foundation for all shared-state concurrent data structures.

Lesson 3 • The Go Memory Model

Defines happens-before relationships, synchronization guarantees, and visibility rules. Misunderstanding the memory model is the root cause of most subtle data races.

Lesson 4 • Race Detector and Data Race Elimination

Uses -race flag, interprets detector output, and applies fixes systematically. Race-free code is a non-negotiable requirement for all subsequent advanced chapters.

Lesson 1 • Deadlines and Timeouts

Covers WithDeadline and WithTimeout for bounding operation duration. Timeouts prevent cascading failures in distributed and microservice architectures.

Lesson 2 • Cancellation with WithCancel

Teaches context.WithCancel, CancelFunc invocation, and Done channel polling. Cancellation is the primary mechanism for stopping goroutine trees on demand.

Lesson 3 • Context Values and Metadata

Explains WithValue, key typing, and appropriate vs. inappropriate value usage. Misuse of context values is a common anti-pattern that degrades API clarity.

Lesson 4 • Context Package Fundamentals

Introduces context.Background, context.TODO, and the Context interface contract. Every production Go service passes context as the first argument to all blocking calls.

Lesson 1 • Futures, Promises, and Result Types

Builds a generic Future type using channels and sync.Once for one-shot results. Futures simplify concurrent call aggregation without exposing raw goroutine management.

Lesson 2 • Publish-Subscribe and Event Bus

Implements an in-process pub-sub system with typed topics and backpressure. Pub-sub decouples producers from consumers in concurrent application architectures.

Lesson 3 • Thread-Safe Maps and sync.Map

Compares mutex-protected maps with sync.Map and analyses their performance profiles. Choosing the wrong map type is a frequent source of contention in Go services.

Lesson 4 • Lock-Free Queues and Ring Buffers

Builds lock-free MPSC queues and fixed-size ring buffers using atomics. These structures appear in high-throughput logging, event buses, and network I/O paths.

Lesson 1 • Goroutine and Block Profiling

Uses goroutine and block profiles to find leaks and scheduling delays. Block profiling reveals channel and mutex contention invisible in CPU profiles.

Lesson 2 • Execution Tracer and Runtime Events

Captures runtime traces with go tool trace and interprets scheduler events. The tracer provides microsecond-level visibility into goroutine scheduling and GC pauses.

Lesson 3 • Optimization Strategies and Trade-offs

Applies batching, cache-line padding, and false-sharing elimination to real benchmarks. Optimisation decisions must be data-driven and validated with before/after benchmarks.

Lesson 4 • Memory Profiling and Escape Analysis

Analyses heap allocations, escape analysis output, and GC pressure. Reducing allocations in hot paths directly improves latency and throughput in concurrent code.

Lesson 1 • Deployment and Operational Readiness

Covers health checks, readiness probes, and runtime metric exposure for orchestrators. Operational readiness ensures the service behaves correctly under rolling deployments.

Lesson 2 • Structured Logging and Tracing

Integrates structured logging and distributed trace propagation into concurrent handlers. Observability is essential for diagnosing concurrency bugs in production environments.

Lesson 3 • Concurrent HTTP Server Architecture

Designs handler concurrency, middleware chains, and connection limits for net/http. Proper server architecture prevents goroutine leaks and resource exhaustion under load.

Lesson 4 • Testing Concurrent Services

Applies race detector, httptest, and load testing to validate concurrent service behaviour. Concurrent code requires deterministic tests and stress validation before deployment.