Go Developer Beginner to Expert

Variables, constants, control flow, and the fact that every type has a usable zero value: 0, "", nil, and a struct with all fields zeroed. Designing around zero values rather than constructors is idiomatic and removes a lot of nil checking.

Understand that a slice is a view over a backing array with length and capacity. append may or may not allocate, and two slices can share memory, which is the source of most surprising mutation bugs.

Methods on types, and when a receiver should be a pointer: when you mutate, or when the struct is large. Mixing both on one type is a lint warning worth heeding.

No implements keyword: a type satisfies an interface by having the methods. Keep interfaces small, define them where they are consumed rather than where the type lives, and accept interfaces while returning structs.

Return errors, do not throw them. Wrap with fmt.Errorf("...: %w", err) to preserve the chain, then inspect with errors.Is and errors.As. Learn this before adopting an error library.

Type parameters and constraints, added in 1.18. Useful for containers and a handful of helpers. Most Go code does not need them, and reaching for them early usually produces something an interface did better.

Write a server with http.ServeMux and handlers, and a client with a configured http.Client. Note the default client has NO timeout, which is a production incident waiting to happen.

io.Reader and io.Writer are the most important abstractions in the language. Composing them means streaming through a pipeline instead of buffering a whole file in memory.

Struct tags, omitempty, and the difference between a missing field and a zero value. Use a pointer or json.RawMessage when that distinction matters.

time.Duration arithmetic, tickers, and using time.Since for elapsed time rather than subtracting wall clocks, which can jump.

Structured logging in the standard library since 1.21. A JSON handler to stdout is all a container needs, and it removes a dependency most projects used to carry.

A goroutine costs a couple of kilobytes, so a goroutine per request is normal. The runtime multiplexes them across OS threads itself. There is no GIL and no single event loop to block.

Channels transfer ownership of data. Buffered versus unbuffered, closing, and select. The idiom worth internalising early: if you are only protecting shared state, a sync.Mutex is simpler and clearer than a channel.

Cancellation, deadlines and request-scoped values. Any function doing I/O takes a context as its first parameter. Without this, a cancelled request keeps working and you cannot shed load.

WaitGroup to wait for a set of goroutines, Mutex and RWMutex for shared state, sync.Once for one-time init, and errgroup for a group where the first error cancels the rest.

Run go test -race in CI, always. It finds data races that no code review reliably catches, and a race that has never fired is not a race that is absent.

An unbounded go f() per item is a goroutine leak and a way to exhaust a downstream dependency. Use a fixed pool reading from a channel, or a semaphore, so concurrency has a ceiling you chose.

A goroutine blocked forever on a channel is a leak the garbage collector cannot help with. go.uber.org/goleak in tests, and the /debug/pprof/goroutine endpoint in production.

The dominant Go idiom: a slice of cases, one loop, t.Run for subtests so failures name themselves. This replaces most of what other ecosystems use a framework for.

Because interfaces are implicit and defined at the consumer, a hand-written fake is usually less work than a mocking library. Depend on a small interface, pass a fake in a test.

httptest.NewRecorder to exercise a handler without a socket, and httptest.NewServer to give a client a real endpoint to talk to.

go test -bench with b.N, and built-in fuzzing since 1.18. Fuzzing pays off immediately on anything that parses untrusted input.

Compare output against a checked-in file, regenerated behind a -update flag. Well suited to templates, generated code and serialisation.

Since 1.22 http.ServeMux handles method and path patterns, so a routing library is genuinely optional. Start with the standard library and add chi or echo only when you can name the missing feature.

Middleware is a function taking an http.Handler and returning one. Logging, recovery, auth and timeouts all compose this way, with no framework involved.

signal.NotifyContext plus server.Shutdown(ctx) so in-flight requests finish before the process exits. Without it, every deploy drops connections and the errors look like someone else's fault.

database/sql with pgx, and SetMaxOpenConns set deliberately. The default is unlimited, which will exhaust your database before your service notices.

The Go community leans away from heavy ORMs. sqlc generates typed code from real SQL, keeping the query readable and the result typed.

Worth learning for service-to-service work: a schema, generated clients, and streaming. Overkill for a public API that a browser will call.

go mod tidy, semantic import versioning, and why go.sum belongs in version control. Minimal version selection means Go picks the lowest version satisfying all requirements, which is different from most package managers.

cmd/ for binaries, internal/ for packages that must not be imported externally (the compiler enforces it). Resist the elaborate layouts circulating online until the project needs them.

go vet catches real mistakes and ships with the toolchain. Add staticcheck via golangci-lint in CI and fix what it reports rather than suppressing it.

Stringer for enums, mockgen, sqlc, protoc. Committing generated code is the Go norm, so builds do not depend on generator availability.

GOOS=linux GOARCH=arm64 go build produces a binary for another platform with no toolchain gymnastics. This is how one laptop builds for Graviton.

CGO_ENABLED=0 go build -ldflags="-s -w" gives a static binary with no libc dependency, which a FROM scratch image can run alone. Images under 15 MB with almost no attack surface are routine.

Build in the golang image, copy only the binary into the final stage. Copy go.mod/go.sum and run go mod download before the source, so the dependency layer caches.

//go:embed puts templates, migrations and static files inside the binary, so deployment stays a single file.

Stamp a version with -ldflags="-X main.version=...", or read runtime/debug.ReadBuildInfo(). Being able to ask a running binary what it is saves real time in an incident.

A slog JSON handler to stdout, with a request ID carried in the context so every line for one request can be found together.

Import net/http/pprof behind an internal port and you can capture a CPU or heap profile from a live process. Combined with go tool pprof, this is the best profiling story of any mainstream runtime.

http.Server needs ReadHeaderTimeout and WriteTimeout; http.Client needs a Timeout. The zero value means wait forever, and a hung upstream then exhausts your goroutines.

Go is garbage collected with a low-latency collector. GOMEMLIMIT (1.19+) is what keeps a container from being OOM-killed, and it matters more than GOGC tuning for most services.

otel-go with context propagation, exporting to X-Ray, Tempo or Jaeger. Because context already threads through your code, adding spans is mostly mechanical.

Separate liveness (is the process wedged) from readiness (can it serve, are its dependencies reachable). A readiness check that always returns 200 is decoration.