Learn Go

Install Go, write hello world, and use go run, go build, go fmt and go vet.

How Go code is split into packages, how imports work, and what makes a program executable.

Declare variables with var and :=, meet Go's basic types, zero values and explicit conversions.

Declare compile-time constants, use untyped constants, and build enumerations with iota.

Go's three control structures: if with an init statement, the single for loop, and switch.

Declare functions, return several values, use variadic parameters, and treat functions as values.

Fixed-size arrays, the dynamic slices built on them, and how len, cap, append and slicing behave.

Create, read, update and delete map entries, test for presence with comma-ok, and iterate.

Strings as immutable UTF-8 bytes, runes as code points, and the strings and strconv packages.

Group fields into struct types, create values with composite literals, and compare and copy them.

Take addresses with &, dereference with *, and use pointers to share and mutate values.

How append grows the backing array, when two slices alias each other, and how to avoid surprises.

Attach methods to your types and choose between value and pointer receivers.

Describe behaviour as a set of methods, satisfied implicitly; type assertions, type switches and any.

Compose types by embedding structs and interfaces, and understand method promotion and its limits.

Return errors as values, add context with %w, and inspect them with errors.Is and errors.As.

Schedule cleanup with defer, understand panics, and recover from them at boundaries.

Manage dependencies with go.mod and go.sum, go get, go mod tidy, versions and workspaces.

Write tests with the testing package, organise them as tables with subtests, and run them with go test.

Start concurrent work with the go keyword and understand what goroutines are and cost.

Send and receive values between goroutines with unbuffered and buffered channels, close and range.

Wait on several channel operations at once, add timeouts, and do non-blocking sends and receives.

Wait for a group of goroutines, protect shared state with Mutex and RWMutex, and run setup once.

Propagate cancellation, timeouts and request-scoped values through call chains with context.Context.

Compose goroutines and channels into pipelines, fan-out/fan-in, and cancellable stages with errgroup.

Bound concurrency with a fixed pool of workers reading a job channel, collect results and errors, and pace work.

Encode and decode JSON with encoding/json, control field names with struct tags, and stream data.

Build an HTTP API with net/http's ServeMux routing patterns and call services with a configured client.

Write functions and types with type parameters, use constraints like comparable and cmp.Ordered.

Write and consume Go 1.23 iterators: iter.Seq, iter.Seq2, yield, and the iterator helpers in slices and maps.

Inspect types and values at run time with reflect.TypeOf and ValueOf, read struct tags, and set fields.

What a data race is, why it's undefined behaviour in practice, and how go test -race finds them.

Measure performance with testing benchmarks and benchstat, then find hot spots with CPU and heap profiles.

How the Go runtime multiplexes goroutines onto OS threads: run queues, work stealing, syscalls, preemption.

Happens-before, what synchronisation guarantees visibility, and why racy programs have no reliable meaning.

How the compiler decides stack vs heap, reading -gcflags=-m output, and techniques to cut allocations.

How Go's concurrent mark-sweep GC works, the GOGC and GOMEMLIMIT knobs, and how to observe and tune it.

How interface values are represented (itab/type + data), the cost of boxing and dynamic dispatch, and the typed-nil trap.

Step outside the type system with unsafe.Pointer, follow its rules, and call C code with cgo at a known cost.