A course grounded in your services
The Go Programming Language, from newcomer to interview-ready
Every concept anchored to real code in conversationmgmt, notification & spike.
You write Go in this monorepo every day, but you came to it from another language — so the idioms, the value semantics, concurrency, and generics aren't reflexes yet. This course builds the mental model an interview tests, from the ground up, pinning each idea to code you already own. It's broad, so it's long: five parts, built one at a time. Lessons are short — one win each. Read them in order.
The whole course at a glance
Five parts, 23 lessons, each pinned to its key interview idea.
Part 1 — Foundations: Go's value model available now
The thing newcomers get wrong most: what Go copies, and what it shares.
1 · The Go mental model
Why Go looks the way it does — simplicity, compilation, values over magic.
ready2 · Types & zero values
Declarations, the static type system, and why the zero value is a feature.
ready3 · Structs: value vs pointer
What's copied vs shared — the single most important Go semantics to master.
ready4 · Slices & maps
The reference-like headers, and the aliasing/nil gotchas interviews love.
readyPart 2 — Methods, interfaces & generics available now
Go's design core — how types plug together. Do them in order.
5 · Methods & receivers
The method-set rule — why *Email, not Email, satisfies our interfaces.
6 · Interfaces
Implicit satisfaction, small consumer-side interfaces — our repo's mockable pattern.
ready7 · The nil-interface gotcha
Why a non-nil interface can hold a nil pointer — the #1 Go interview trap.
ready8 · Composition & embedding
Go's answer to inheritance, all over your Kafka engine and claims types.
ready9 · Generics
Type parameters + the "generics or interface?" decision, via KafkaServicer[T].
Part 3 — Errors & idiomatic Go available now
Errors as values, and the everyday idioms — including a real bug in our own handlers.
10 · Errors are values
%w wrapping, sentinels — and the %v bug in create_email_handler.
11 · errors.Is / errors.As
Comparing & extracting through the wrap chain — how errorx.ToStatusError works.
12 · gRPC status codes
Mapping domain errors to codes.* at the controller boundary, our way.
13 · Idioms
defer, functional options, named returns, zero-value design.
Part 4 — Concurrency & context available now
The biggest interview pillar — and where your Kafka engine finally reads like an open book.
14 · Goroutines
"Concurrency is not parallelism"; the go statement; goroutine leaks.
15 · Channels & select
Buffered vs unbuffered, share-by-communicating, and the ctx.Done() case.
16 · sync primitives
Mutex, WaitGroup, Once — and "channels or a mutex?"
ready17 · context.Context
Cancellation, deadlines, request-scoped values — and our Background() subtlety.
18 · Concurrency patterns
Worker loops, errgroup, graceful shutdown, fan-in, panic recovery.
19 · Data races & the memory model
Happens-before, the -race detector, why our mutex is required.
Part 5 — Testing, tooling & performance available now
The last part — how you prove code works and make it fast, plus the runtime under it all.
20 · Table-driven tests
The Go testing idiom + testify, in our repo's exact t.Parallel/subtest style.
21 · Mocks & interfaces in tests
Testing with no database — how MockEmailRepo and mock_database wire in.
22 · Benchmarks & pprof
Measure, don't guess — b.Loop, -benchmem, profiles, escape analysis.
23 · The runtime
The GMP scheduler and the concurrent GC — why goroutines are cheap.
readyReference shelf
Course mind map ↗
The whole roadmap on one canvas — 5 parts, 23 lessons, each pinned to its key interview idea.
Cheat sheet
Dense revision sheet + interview one-liners.
Glossary
The canonical vocabulary, opinionated.
Repo Go map
Ground truth: our idioms, patterns, file:line.
Resources
go.dev, GOPL, 100 Go Mistakes, Learn Go with Tests.