Learn Go the way it is meant to be written — the toolchain, types and zero values, slices and maps, structs and methods, interfaces, errors as values, and generics — every snippet compiled and run against Go 1.26.
What Go is and the values that shaped it, the shape of the smallest program, and the built-in toolchain — run, build, module, format, vet, test — that comes with the language rather than bolted on. Compiled and run against Go 1.26.5.
Declaring things in Go — var, the short := form, multiple assignment, block scope and the shadowing trap, constants and iota — anchored on the idea that every declared variable starts life at its type's zero value. Compiled and run against Go 1.26.5.
The built-in types — the numeric family, bool, and a first look at string — plus the two rules that surprise newcomers most: Go converts no number for you, and integer overflow wraps in silence. And why untyped constants get to bend those rules. Compiled and run against Go 1.26.5.
Functions in Go — multiple return values (the habit that makes error handling work), named returns, variadics, and closures — plus defer, the cleanup mechanism that runs in LIFO order on return, evaluates its arguments early, and keeps cleanup next to acquisition. Compiled and run against Go 1.26.5.
Go has a single loop keyword, an if that can carry its own setup, and a switch that never falls through by accident. What that minimalism buys you, how each form works, and the edges worth knowing. Compiled and run against Go 1.26.5.
Arrays are values; slices are a window onto an array. Once you see the pointer-length-capacity header, append's reallocation and the shared-backing-array aliasing gotcha stop being mysteries. The most gotcha-heavy topic in Go, taught by running it. Compiled against Go 1.26.5.
Go's hash table, taught by its edges: the comma-ok idiom that separates absent from zero, iteration order that is deliberately randomized, reference semantics, the nil-map write that panics, and the empty-struct set idiom. Compiled and run against Go 1.26.5.
A Go string is an immutable sequence of UTF-8 bytes, not a sequence of characters — indexing gives you a byte, len gives you a byte count, and range gives you code points. What that means in practice, and how to build strings without quadratic surprises. Compiled and run against Go 1.26.5.
Structs are Go's way of grouping data, and embedding is how it builds bigger types from smaller ones — promotion, comparability, the always-usable zero value, and why Go composes instead of inheriting. Compiled and run against Go 1.26.5.
Methods in Go attach to any named type, not just structs, and the one decision you make on every method — value receiver or pointer receiver — controls whether mutations stick. The mechanics, the consistency rule, and the auto-address convenience that makes it all feel seamless. Compiled and run against Go 1.26.5.
What a pointer is in Go, the & and * operators, why there's no pointer arithmetic, new(T) versus &T{}, the nil-dereference panic, automatic struct dereference, and the one question that actually decides when to use one. Compiled and run against Go 1.26.5.
Structural satisfaction with no implements keyword, why small interfaces win, io.Reader and io.Writer, the empty interface any, the type-value pair inside every interface value, the typed-nil trap, type assertions and type switches, and accept interfaces / return structs. Compiled and run against Go 1.26.5.
Why Go treats errors as ordinary return values, the if err != nil pattern and its tradeoff, creating errors with errors.New and fmt.Errorf, wrapping with %w and matching with errors.Is and errors.As, sentinel and custom error types, and what panic and recover are actually for. Compiled and run against Go 1.26.5.
Type parameters on functions and types, the constraint system (any, comparable, and the ~ underlying-type element), type inference that lets you omit the type argument, and — honestly — when generics are the wrong tool. Compiled and run against Go 1.26.5.
How Go code is organized: packages (one directory, exported by capitalization, init functions, no import cycles), modules (go.mod, versions, go get, go.sum, go mod tidy), the compiler-enforced internal/ directory, the standard project layout, and go doc for your own code. Compiled and run against Go 1.26.5.