# Mission: The Go Programming Language

## Why
Walk into a Go interview able to explain *how the language works and why it's designed
that way* — not memorised syntax, but a mental model solid enough to reason about
unfamiliar questions and read code fluently. I already work in a large Go monorepo but
came to Go from another language, so the idioms, the type/value semantics, concurrency,
and generics aren't yet second nature. Every concept is anchored to real code in my
team's services — **conversationmgmt**, **notification** (`internal/notification`), and
**spike** (`internal/spike`) — so an abstract rule lands on code I already touch.

## Success looks like
- I can explain Go's value semantics: what's copied vs shared, value vs pointer
  receivers, and why a slice/map behaves the way it does when passed around.
- I can design with interfaces (small, consumer-side) and read/write generics, and say
  when each is the right tool.
- I can reason about concurrency: goroutines, channels, `select`, the `sync`
  primitives, and `context` cancellation — and spot a data race or goroutine leak.
- I can write idiomatic error handling (`%w` wrapping, sentinels, `errors.Is`/`As`) and
  map errors to gRPC status codes the way our services do.
- I can answer the classic Go interview questions (nil interface vs nil pointer, slice
  aliasing, defer semantics, the scheduler, the GC, the memory model) without hand-waving.
- I can write a clean table-driven test with testify mocks like the ones in our repo.

## Constraints
- **Newer to Go** — coming from another language. Lessons don't assume Go idioms are
  internalised, but they *can* assume general programming maturity (loops, types, OOP).
- **Format:** interactive HTML lessons (recall quizzes) + dense Markdown references —
  same format as the [Kafka course](../kafka/index.html). Lives in `docs/golang/`.
- **Broad topic, multi-session:** the roadmap ([index.html](./index.html)) is large and
  covers many parts; lessons are short and arrive part by part.
- **All four pillars in scope:** concurrency & context · idiomatic Go & errors ·
  interfaces/generics/design · testing/tooling/performance.

## Out of scope (for now)
- Deep web-framework specifics (net/http routers, gin) beyond what our gRPC stack uses.
- CGo, assembly, and unsafe-heavy tricks.
- Cloud/deploy tooling — this is about the *language*, not the platform.
- (Revisit if the mission shifts — confirm before changing.)