Go — Cradle to Mastery

Go was created at Google in 2007 by Robert Griesemer, Rob Pike and Ken Thompson because large C++ codebases had become painfully slow to compile and hard to reason about. Understanding that origin explains almost every Go design decision you will meet later — including the ones that look like omissions.

A correct Go install and a configured editor is the difference between a smooth first week and a frustrating one. This lesson covers installation on all three platforms, the go command, and getting gopls working in your editor.

Go is statically typed with no implicit conversions — a design choice that catches a whole class of bugs at compile time. This lesson also covers zero values, which Go uses instead of null for most types and which shape how idiomatic Go structs are designed.

Go has exactly one loop keyword. There is no while, no do-while, and no ternary operator. This lesson shows how for covers every looping case, and how Go's switch is more capable than C's — no fall-through by default, and it can switch on types.

Two Go habits start here. Functions return multiple values — which is why Go returns errors instead of throwing them — and defer schedules cleanup at the point you acquire a resource, so it cannot be forgotten later.

Slices are where most newcomers get bitten. A slice is a view onto a backing array, so appending can either mutate shared data or silently copy it depending on capacity. Understanding length vs capacity now prevents a category of confusing bugs later.

Maps are Go's built-in hash table and appear in nearly every real program. Two things matter early: the comma-ok idiom for distinguishing a missing key from a zero value, and the fact that Go deliberately randomises iteration order so you cannot depend on it.

A Go string is a read-only slice of bytes, not characters. len() returns bytes, ranging over a string yields runes, and indexing gives you a single byte. Getting this straight early avoids a classic source of bugs with any non-ASCII text.

Structs are how Go models data, and methods attach behaviour to them. The decision that trips people up is value vs pointer receivers — it determines whether a method can mutate its receiver, and it is not just a style preference.

Go has pointers but deliberately no pointer arithmetic, which removes most of the danger they carry in C. You need them for mutation, for avoiding large copies, and for the pointer receivers you just met.

Nothing in Go says implements. A type satisfies an interface simply by having the right methods, which means you can define an interface for types you do not own. This is the single biggest departure from Java-style OOP and it changes how you design packages.

Go replaces inheritance with embedding: put one type inside another and its methods are promoted to the outer type. It looks like inheritance at the call site but behaves differently in one important way — there is no virtual dispatch to an overridden method.

Go shipped without generics for over a decade, then added them in 1.18 (2022). They are deliberately narrower than C++ templates or Java generics. Knowing when a type parameter genuinely helps — and when an interface was already the right answer — is the useful skill here.

A goroutine costs a few kilobytes, so Go programs routinely run thousands of them. Channels let those goroutines communicate by passing values rather than sharing memory — the idea Go's concurrency philosophy is built on.

select waits on several channels at once, which is how timeouts, cancellation and fan-in are built. And despite the “share by communicating” slogan, sync.Mutex and sync.WaitGroup remain the correct tool for plenty of real problems.

Once you have goroutines doing real work, you need a way to tell them to stop. context is Go's standard answer, and it appears as the first parameter of almost every function in the modern standard library and in most production Go code.

The primitives are simple; assembling them correctly is the skill. This lesson covers the handful of patterns that solve most real concurrency problems, plus the leak and deadlock mistakes that show up when they are assembled wrong.

Go is garbage collected, but its collector is tuned for low pause times rather than raw throughput. Understanding escape analysis — why some values land on the stack and others on the heap — is what lets you reason about allocation in hot paths.

Go has no exceptions. Errors are ordinary values returned alongside results, checked explicitly. It is more verbose than try/catch and that is the intended trade-off — every failure path is visible in the code. Wrapping with %w and inspecting with errors.Is/As is the modern idiom.

Closures power a lot of idiomatic Go — HTTP middleware, functional options, and deferred cleanup all rest on them. The classic trap is capturing a loop variable, which Go 1.22 changed the semantics of, so older code and newer code behave differently here.

range has worked over slices, maps and channels since day one. Go 1.23 (2024) extended it to range-over-function iterators, which is the biggest change to how Go code traverses custom collections in years.

Go's library is deliberately broad, which is why Go projects tend to have short dependency lists. This lesson is a map of the packages worth knowing — fmt, strings, time, os, sort, encoding — so you reach for the standard library before an external module.

Almost every Go service speaks JSON. Struct tags control the mapping between Go field names and JSON keys, and understanding how the encoder treats unexported fields, zero values and omitempty saves a lot of debugging.

io.Reader and io.Writer are two of the smallest and most important interfaces in Go. Once you see how much of the standard library is built to accept them, composing file, network and in-memory streams becomes routine.

This is Go's flagship use case. net/http in the standard library is genuinely production-grade — no framework required — and Go 1.22 added method and wildcard routing to the default mux, which removed one of the main reasons people used to reach for a third-party router.

Go's visibility rule is unusually simple: a capitalised identifier is exported, a lowercase one is package-private. There are no public/private keywords. This lesson covers package layout and the import mechanics that follow from it.

Modules replaced GOPATH in 2019 and are now the only sane way to manage Go dependencies. go.mod and go.sum give you reproducible builds, and Go's minimal version selection resolves dependencies differently from npm or pip in a way worth understanding.

Testing ships with Go — no framework, no assertion library by default. The table-driven test is the dominant idiom, and go test also runs benchmarks, fuzz tests and the race detector from the same command.

Go compiles to one static binary with no runtime to install on the target machine — a large part of why Go and containers fit together so well. Cross-compiling for another OS is usually two environment variables.

The reflect package lets you examine and manipulate types at runtime. It powers encoding/json and most ORMs, but it costs compile-time safety and speed. Worth understanding so you can read library code — and worth avoiding in your own.