Free through lesson 3

Go for Beginners

From setting up your environment through variables, control flow, slices and maps, functions and pointers, structs and interfaces, error handling, splitting packages, generics, concurrency and testing. Fifty lessons that take you to the point where you can assemble a tested tool using nothing but the standard library. Every piece of code and result shown was produced by actually running Go 1.27.1.

Start from lesson 1 Unlock every course

Curriculum

The 50 lessons are grouped into seven chapters. Working through them in order is the best way, but you are welcome to dip into whatever interests you. Note: this cannot run inside the browser, so try it with your own go run or the Go Playground (go.dev/play).

Chapter 1 — Fundamentals (lessons 1–9)

You get to grips with how Go runs and get to the point of executing it yourself with go run. You cover variables, zero values, numbers and strings and standard input, and how to read compiler errors.

What Go is (setting up and Hello World)

Go's three defining traits, and installing it. Running the four lines that start at package main and func main() with go run.

Free

Output with fmt, and comments

When to use Println, Print, Printf and Sprintf. Reading format verbs, and what %!d(string=…) means.

Free

Variables, types and type inference

When to use var and when :=. There are zero values, so an uninitialised variable does not exist. Types never convert automatically.

Free

const and iota

Values you never change are const. Producing a sequence with iota and adding your own type and a String() method to make a Go enum.

Numeric types and operators

Dividing two integers truncates. int and float64 cannot be mixed. Overflow wraps around silently.

String basics (string, byte and rune)

A string is UTF-8 bytes. len() returns the byte count. The difference between byte and rune, and how to slice non-ASCII text.

Working with strings using the strings package

Search, transform, split, trim and join. Organising the strings functions by purpose, and speeding up concatenation with Builder.

Standard input and strconv

Reading a line with bufio.Scanner and converting with strconv. Conversion functions return a value and an error — this is Go's rhythm.

Reading compiler errors, and go vet

Read an error starting from file:line:column. The seven most common messages and their fixes, and what go vet is for.

Chapter 2 — Control flow (lessons 10–15)

You cover conditionals and repetition: if without parentheses, switch that does not fall through, for as the only loop, and breaking out with labels. You finish by assembling a number-guessing game.

Branching with if

No parentheses, and the condition must be a bool. Receiving an error with an if that has an initialiser, and keeping nesting shallow with early return.

Comparison and logical operators

A comparison produces a bool value. Short-circuit evaluation is what makes a nil check work, and you never compare floats with ==.

switch statements and type switches

A switch that does not fall through without a break. Without a condition, with an initialiser, fallthrough, and the type switch.

for loops

There is no while and no foreach. The four faces of for, and integer range from Go 1.22.

break, continue and labels

When to use break and when continue. Labels for leaving a nested loop from the inside, and the trap of a switch inside a for.

[Project] A number-guessing game

Bringing random numbers, loops and input checking into one program. Start from a version with a fixed answer and add features.

Chapter 3 — Data structures (lessons 16–24)

You gather data with arrays, slices, maps and multiple dimensions. The crux of Go — that a slice shares its underlying array — is taken on head-on here, and you finish by aggregating sales data.

Arrays

The length is part of the type. Zero values are there the moment you declare it, and passing it to a function copies the whole thing. Which is why real code uses slices.

Slice basics

A slice is a triple of pointer, length and capacity. Slice it or pass it to a function and the underlying array is still shared.

append, and capacity (len and cap)

Always assign the result of append back. The difference between len and cap, and the trap where spare capacity lets you clobber the original.

Working with and sorting slices

The slices package from Go 1.21. Sort sorts in place. Filtering and transforming are written with for and append.

Map basics

A missing key gives you the zero value. The comma-ok idiom distinguishes a stored 0 from a missing key. The range order changes every time.

Maps in practice

Aggregation is one line: m[key]++. Output in key order, grouping, standing in for a set, and the fact that a map passed to a function is shared.

Getting the most out of range

What you get back depends on what you range over. The range value is a copy. The loop variable change in Go 1.22, and iterators.

Multidimensional slices

Building a table as a slice of slices. make happens in two stages, outer then inner. Writing aggregation by row and by column.

[Project] Aggregate sales data

Make one record a type, collect them in a slice, add into a map, repack and sort. All four stages of aggregation in one program.

Chapter 4 — Functions (lessons 25–32)

You give a piece of work a name and pull it out. Multiple return values and (result, error), variadic parameters, closures, defer, and on to pointers and recursion.

Function basics

The type comes after the name. There are no default arguments. A capital initial means exported, lowercase means package-private.

Multiple and named return values

(result, error) is the Go convention. The mechanism that stands in for exceptions, and where named return values earn their place.

Variadic parameters

...T only on the last parameter. Inside, it is a slice. Spreading a slice into it shares the original array.

Function values and closures

Functions are values too. Take one as a parameter to swap out part of the work; return one to close over configuration.

defer

Schedule the release as soon as you acquire. Last-in-first-out execution order, and the trap that the arguments are fixed where you write it.

Pointer basics

Only two things to learn: & and *. There is no pointer arithmetic and no manual freeing. Reading through a nil pointer panics.

Pointers and functions (versus passing by value)

Every argument is passed by value. Passing a pointer means passing an address as a value. Which is why slices are shared.

Recursive functions

Write the base case first. Naive recursion gets fast with memoisation. Its real home is walking nested data.

Chapter 5 — Types and interfaces (lessons 33–37)

You create your own data types. Structs and methods, embedding rather than inheritance, and interfaces with no implements keyword. You go as far as plugging your own types into the standard library's machinery.

Struct basics

A struct instead of a class. Write field names in the literal. It is a value, so it is copied, and you construct it with a New… function.

Methods and receivers

You choose the receiver's name. Use a pointer receiver if it changes state. Calling one on a copy from range changes nothing.

Struct embedding

Write just the type to embed it. Fields and methods are promoted, but this is not inheritance — and that is the decisive difference.

Interface basics

Implicit implementation with no implements keyword. The consumer defines it, small. An interface holding a nil is not nil.

Interfaces in practice

Stringer, error, io.Writer and sort.Interface. Writing a single method puts you on the standard machinery.

Chapter 6 — Errors and data (lessons 38–43)

You learn systematically how failure is handled in a language with no exceptions. Wrapping with %w, panic and recover, files and JSON. You finish by designing an inventory system with structs.

error and the basics of error handling

Check err immediately after the call. errors.New and fmt.Errorf, sentinel errors and errors.Is.

Wrapping errors, errors.Is and errors.As

Wrap with %w each time you cross a layer. Use %v and you can no longer test for it. errors.Is for values, errors.As for types.

panic and recover

The first line of the message is the cause. The four you see most and how to prevent them, and turning one into an error with defer plus recover.

Reading and writing files

ReadFile and WriteFile for small files, bufio.Scanner for large ones. Once opened, defer f.Close() immediately.

Working with JSON

Only exported fields are converted. Choose the key names with tags, and pass a pointer to Unmarshal.

[Project] Inventory management with structs

Separating the type for one record from the type for the collection. map[string]*Item, a New… function, %w, and output in key order.

Chapter 7 — Towards real work (lessons 44–50)

You cover splitting packages, generics, concurrency and testing. Finally you pull all 50 lessons together and see what to learn next.

Packages and Go modules

One directory is one package. The import path is the module name plus the directory. internal cannot be used from outside.

Generics

[T any] removes the per-type copy-and-paste. any can do nothing, so add a constraint. If a concrete type is enough, prefer it.

goroutines and sync.WaitGroup

Just add go and another flow starts running. Everything dies when main returns, so wait with a WaitGroup.

Channels

A channel both passes values and synchronises timing. The sender closes it. The worker pattern is the standard shape.

select and sync.Mutex

select handles whichever arrives first. Timeouts, cancellation, protecting shared data, and detection with -race.

Writing tests with testing

There is no assert. Compare with an if and call t.Errorf. Table-driven tests and subtests, Example functions, and -cover and -race.

Wrapping up and what to learn next

Organising all 50 lessons along seven axes, and building a server and a task management CLI with the standard library alone. Including where to go next.

Once you have finished all 50 lessons, look at Rust for Beginners, another compiled language that leans towards safety, or learn to ship in containers with Docker for Beginners. Membership unlocks every course.