The Go Language, from the ground up

var, :=, and const; typed vs untyped constants and iota; the numeric types with explicit conversion; and guaranteed zero values.

if with an init statement, the single for loop in all its forms, switch without fall-through, labeled break, and defer.

Functions as first-class values — multiple and named returns, variadic params, closures, higher-order functions, and defer.

& and *, value vs reference semantics, nil, when a function needs a pointer to mutate, and why Go has no pointer arithmetic.

Grouping fields into one type — literals, the zero value, nesting and embedding, struct tags, comparability, and the empty struct.

The (ptr, len, cap) header, append and growth, slicing and the aliasing trap, copy, nil vs empty, and the slices package.

Go's built-in hash table — make and literals, comma-ok, delete, random iteration, sets, nil-map panics, and the maps package.

Strings are immutable UTF-8 bytes — why len counts bytes, indexing yields a byte, ranging yields runes, and strings.Builder.

Functions with a receiver — value vs pointer receivers, method sets and interface satisfaction, methods on any type, and method values.

Implicit satisfaction and structural typing, the (type,value) pair and dynamic dispatch, method sets, any and type switches, composition, stdlib interfaces, design, and the nil trap.

Composition over inheritance — promoted fields and methods, embedding structs and interfaces, overriding, and the embedded-mutex pattern.

Type parameters and constraints — any, comparable, cmp.Ordered, the ~ and union constraints, generic types, and when to use them.

Recovering concrete types from an interface — x.(T), the comma-ok form, the type switch, and when to reach for reflection.

Errors are values you return and check — sentinels, wrapping with %w, and matching through the chain with errors.Is, As, and Join.

defer schedules cleanup, panic unwinds the stack, and recover — only inside a defer — turns a panic back into an ordinary error.

Packages and visibility by case, imports and init order, modules (go.mod / go.sum), and the cmd/internal/pkg project layout.

Inspecting and modifying types and values at runtime with reflect — Type vs Kind, struct fields and tags, and the pointer/Elem rule.