Understand Go by watching memory & runtime happen.
Pointers, backing arrays, goroutines, and channel handshakes — visualized as step-by-step interactive memory layouts and runtime state machines. Designed for complete beginners and systems engineers leveling up.
⚡ Explore Concurrency →0x104000!
Choose Your Tailored Learning Track
Filters above eliminate cognitive overload. Jump directly to what matters for your experience level.
Go Basics
From zero syntax to writing idiomatic Go. Zero values, control flow, functions, portable shadowing traps, and the error != nil call stack.
Core Go Concepts
Structs & method receivers, slice headers vs backing arrays, map bucket internals, interface dynamic dispatch, and the classic nil interface gotcha.
Concurrency & Channels
Master Go's flagship superpower. Operating M:N scheduler, unbuffered rendezvous handshakes, buffered queues, select multiplexers, and worker pools.
Advanced Runtime
Type parameters (generics), val/ptr constraints, Context cancellation propagation tree, table-driven tests, and sub-nanosecond memory benchmarks.
Kubernetes Operators
Build custom controllers using controller-runtime. Custom Resource Definitions (CRDs), level-triggered reconcile loops, mutators, and leader election.
REST APIs with Gin
Enterprise web APIs, Radix tree routing, struct tag binding & validation, middleware call-chains, structured JSON logging, and MongoDB client pipelines.
gRPC Microservices
Ultra-low latency microservices with Protobuf v3. Unary calls, server-streaming, client-streaming, bidirectional multiplexing, and interceptor-chains.
Coding Interviews
Top high-frequency systems coding challenges: LRU Cache with Double-Linked Lists, concurrent token bucket rate limiters, and fan-out worker pools.
Goroutine M:N Runtime Scheduling vs Sequential Thread
In Go, each go func() allocates a lightweight ~2KB dynamic stack (vs ~2MB OS thread).
Step through the timeline to see how the Go runtime multiplexes $N$ goroutines onto $M$ OS threads using $P$ logical processor contexts.
Checkpoint Quiz: Test Your Memory Intuition
Test your mental model. Answer with real-time feedback and dynamic memory breakdown diagram.
a := []int{1, 2, 3}, then take a sub-slice b := a[:2] and run b[0] = 99. What happens to a[0]?
Why text explanations aren't enough
Go is deliberately simple in syntax, but its runtime behavior (memory allocation, slice headers, channel locks, scheduling) is full of subtle gotchas.
A slice is a 3-word struct pointing to an array. When two slices point to the same memory, mutations silently bleed over. We show the exact memory addresses.
Understand how unbuffered channel handshakes force synchronized rendezvous between goroutines via internal hchan.lock, and how buffer queues avoid contention.
Why does err != nil return true even when the error pointer is nil? Seeing the two-word (type, value) interface tuple makes it crystal clear.
Every code sample has its real compiler stdout captured verbatim. Panic stack traces, deadlocks, and benchmark numbers are 100% genuine.
Skip straight to Concurrency & Internals
Goroutines and channels are usually the part of Go that intimidates developers coming from Python, Java, or Rust. An animated timeline genuinely helps more than a chapter of text.