Courses

Go

Go for Working Engineers

Go for an engineer who already ships in another language. What a Go build actually produces, how modules and the toolchain decide which compiler runs, the language from zero values to generics, errors as ordinary values, the concurrency model and the race detector, the tooling that gets a binary out of the door, and two programs built end to end that settle which kind of work Go is for. Written against Go 1.26 and checked on 13 August 2026.

6 modules · 5 hr 29 min of reading

3 of 29 lessons are open to read without an account, and a free account opens the other 26. Creating one costs nothing: there is no paid plan, no tier and nothing to buy.

Start readingHow this is checked

1. Module 1

   Open to read

   Orientation

   What the Go runtime and toolchain actually give you, how modules and toolchain selection work, and the habits that make Go code look like Go rather than like translated Java.

   3 lessons · 33 min

   The runtime and the toolchain

   • What Go actually is
   • Modules, versions and the toolchain that downloads itself

   Working in Go

   • Reading Go, and laying out a project

2. Module 2

   Free account

   The language

   The core repertoire in seven lessons: values and zero values, text, slices and maps, structs and methods, interfaces, functions and iterators, generics and where they stop.

   7 lessons · 1 hr 21 min

   Values and data

   • Values, constants and the zero value
   • Strings, bytes and runes
   • Slices, maps, and the aliasing trap

   Types and behaviour

   • Structs, methods and embedding
   • Interfaces, and why nobody declares that they implement one

   Functions and generics

   • Functions, defer's cousins and the new iterators
   • Generics, and the four things they will not do

3. Module 3

   Free account

   Types, errors and resources

   Errors as ordinary values, wrapping and inspection, deferred cleanup and panic boundaries, the JSON boundary where external data becomes typed data, and time as a value you format, parse and measure with.

   5 lessons · 54 min

   Errors as values

   • Errors are values, and there is no catch
   • Wrapping, inspecting and designing errors

   Resources and data

   • Defer, panic, and cleaning up properly
   • JSON, struct tags and the data boundary

   Time and the clock

   • Time, durations and the clock

4. Module 4

   Free account

   Concurrency and IO

   Goroutines, channels and select; context, deadlines and cancellation; worker pools, shared state and the race detector; files, streams and subprocesses.

   4 lessons · 46 min

   The concurrency model

   • Goroutines, channels and select
   • Context, deadlines and cancellation that propagates

   Coordination and IO

   • Worker pools, shared state and the race detector
   • Files, streams and subprocesses

5. Module 5

   Free account

   Shipping it

   Tests that earn their place, benchmarks and fuzzing and fake time, the formatter and analysers and linters, and turning a package into a stamped static binary that logs.

   4 lessons · 45 min

   Testing

   • Tests that earn their place
   • Benchmarks, fuzzing and tests that do not wait

   Tooling and release

   • Formatter, analysers and the one linter you need
   • Building, embedding and logging

6. Module 6

   Free account

   Capstones

   Two programs built end to end, chosen for what Go is actually good at. loganalyse is a batch CLI that ships as one static binary with its assets inside it. jobd is a long-running service that runs work on a bounded pool and drains cleanly when it is asked to stop. The module closes by naming the jobs Go is the wrong tool for.

   6 lessons · 1 hr 10 min

   loganalyse, the shipping story

   • loganalyse, part one: from a directory of logs to a report
   • loganalyse, part two: parallel parsing, and one binary you can post to someone

   jobd, the concurrency story

   • jobd, part one: a service that accepts work
   • jobd, part two: a bounded pool, and telling a client to slow down
   • jobd, part three: draining cleanly, then breaking it on purpose

   Choosing a language

   • When to reach for Python instead