The Standard Library & Tooling

Formatting and streaming — the fmt verbs you'll actually use, width/precision flags, the Stringer/Formatter hooks, and the tiny io.Reader/io.Writer interfaces (plus io.Copy, MultiWriter, TeeReader) that everything plugs into.

The text toolkit — searching and transforming with the strings package, O(n) assembly via strings.Builder, the parallel bytes package and bytes.Buffer, strconv for number⇄string conversion, and the unicode/utf8 view of multibyte text.

Pattern matching in Go — compile once with MustCompile, match/find/replace, capture groups (named and numbered), the linear-time RE2 engine and what it deliberately can't do (no backreferences), and when plain strings functions are the better tool.

Turning Go values into JSON and back — Marshal/Unmarshal, struct tags and omitempty, decoding into structs vs maps, streaming Encoder/Decoder, custom Marshaler/Unmarshaler, and json.RawMessage for deferred decoding.

Data-driven text generation — actions, fields and pipelines, if/range/with control flow, custom funcs, and why html/template's context-aware auto-escaping is the one you must use for the web.

Instants, durations and the famous reference layout — formatting and parsing, time arithmetic and zones, the monotonic clock, measuring elapsed time, and timers vs tickers (and how to stop them).

Reading and writing files with os — whole-file vs streaming, OpenFile flags and permission bits, directories and FileInfo, portable paths via path/filepath (and filepath.WalkDir), and the os entry points (args, env, std streams, Exit).

Build command-line tools with the flag package — typed options with defaults, binding with Var, positional args, subcommands via FlagSet, custom flag.Value types, and env-var fallbacks.

Log key-value attributes with log/slog — Text vs JSON handlers, levels and thresholds, slog.With and slog.Group for context, typed attributes and LogAttrs for the hot path, and why structured logs beat fmt.Println in production.

Running external programs from Go — exec.Command, Run vs Output vs Start, capturing stdout/stderr, streaming and pipes, context timeouts, environment and working directory, and why there's no shell (and why that's a security win).

The testing package and go test — writing TestXxx functions, Errorf vs Fatalf, t.Helper, and the got/want convention that runs with go test ./...

The idiomatic Go pattern — a slice of named cases looped through t.Run subtests, with t.Parallel, so one test scales to dozens of inputs.

Native Go fuzzing — FuzzXxx with f.Add seeds and f.Fuzz, how a fuzzer hunts for panics and broken properties, and go test -fuzz.

Measuring speed with BenchmarkXxx and b.N — reading ns/op, B/op and allocs/op, and the classic += vs strings.Builder comparison.

One tool does it all — build, run, test, format, vet, and document Go code, plus embed files and cross-compile static binaries from a single command.

Dependency management in depth — go.mod and go.sum, go get / mod tidy, semantic versioning, minimal version selection, replace directives, workspaces, and vendoring.

Measure before you optimize — capture CPU, heap, and goroutine profiles with runtime/pprof or net/http/pprof, then read hot paths in go tool pprof.

Catch data races automatically — -race instruments memory accesses to flag concurrent unsynchronized reads/writes, prints the two conflicting goroutines, and points at the fix.