learn

Learn Go

One lesson per concept, in order, from what Go is to a capstone. Every lesson ends by pointing at the challenges that drill it, so reading turns into typing on the same page.

22 lessons~5h 25m of reading63 challenges

Start lesson 01 Just solve

What Go isWhy Go exists, what a program is made of, and how to read your first one.~8m read2 challenges
Values and variablesconst, var and :=, the zero value every type starts at, and enumerations built from iota.~10m read3 challenges
Basic typesGo's numbers, strings, bools and runes, why every conversion is explicit, and what a string really holds.~12m read3 challenges
Control flowGo's if, switch and its single for loop: no parentheses, no truthiness, no accidental fallthrough.~12m read3 challenges
FunctionsMultiple return values, named results, variadic parameters, and functions as values that close over state.~14m read3 challenges
Defer, Panic and RecoverScheduling cleanup that runs on every exit path, and the two-value machinery Go keeps for the failures that are not error values.~13m read3 challenges
Slices and ArraysThe three-word slice header, the gap between length and capacity, and why two slices can quietly describe the same memory.~14m read3 challenges
MapsGo's hash table: the comma-ok lookup, the nil map that reads but cannot be written, random range order, and grouping with map[K][]V.~13m read3 challenges
Strings and FormattingThe strings package instead of methods, strconv for parsing, strings.Builder instead of += in a loop, and the fmt verbs worth memorising.~14m read3 challenges
StructsGo's only aggregate type: named-field literals, value semantics, embedding instead of inheritance, and the rules that decide whether == compiles.~14m read3 challenges
Methods and PointersReceivers are ordinary parameters: which one you pick decides whether a method can mutate, what an interface will accept, and when a nil pointer is still usable.~15m read3 challenges
InterfacesA type satisfies an interface by having its methods, and nothing else: no declaration, no registration, and one famous trap where a nil pointer is not a nil interface.~16m read3 challenges
ErrorsGo has no exceptions: failure is a value returned alongside the result, wrapped with context on the way up, and inspected with errors.Is and errors.As.~17m read3 challenges
GenericsType parameters let one function or one type work for many element types, with the compiler still checking every call: constraints say what a T is allowed to do.~18m read3 challenges
Packages and ModulesA package is a directory, a module is a tree of them with a name, and capitalisation is the only visibility keyword Go has.~16m read2 challenges
JSON and Encodingencoding/json works by reflection, which explains every rule it has: exported fields only, tags for names, and two interfaces for when a tag is not enough.~18m read3 challenges
GoroutinesA goroutine is a function running independently, and nothing waits for it. The whole concept is one keyword, one type, and one rule about who owns which piece of memory.~16m read3 challenges
ChannelsA channel is a typed pipe with synchronisation built in. Learn what blocks, who closes, and how select turns waiting into a choice, and the rest of Go's concurrency is composition.~18m read3 challenges
Sync PrimitivesChannels move values between goroutines. Sometimes goroutines need to share the same memory instead: a counter, a cache, a one-time setup. sync.Mutex, sync.RWMutex and sync.Once are the three tools that make that safe.~16m read3 challenges
ContextEvery long-running job needs a way to be told to stop: a request is abandoned, a deadline passes, a server shuts down. context.Context is the one value Go passes down a call tree to carry cancellation, a deadline, and the handful of request-scoped values that belong with them.~17m read3 challenges
TestingGo ships its test runner, its benchmark harness and its coverage tool in the toolchain, and gives you no assertion library at all. What you get instead is one shape - a table of cases, a loop, a subtest each - plus the helpers, the cleanup and the measurement rules that keep it honest.~18m read3 challenges
CapstoneTwenty-one concepts, and no real program uses one of them at a time. This is how they fit together: a pipeline of small functions with values between them, errors that carry the context to be acted on, an interface at the seam where the work stops caring what happens next, and the rules that keep a concurrent program's output the same on every run.~16m read2 challenges

Loading lessons