Learn Go from scratch: a book-by-book path to concurrent, production services
This curriculum takes you from zero Go knowledge to building production-quality backend services and CLI tools in four tightly sequenced stages. Each stage builds directly on the last — first internalizing Go's syntax and idioms, then mastering its unique concurrency model, then hardening code with testing and tooling, and finally studying real-world architecture patterns used in professional Go services.
Foundations: Syntax, Types & Idioms
BeginnerRead, write, and understand idiomatic Go — variables, functions, structs, pointers, interfaces, and error handling — well enough to build small standalone programs.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day (mix of reading and active coding)
- Go syntax fundamentals: packages, imports, declarations, and the blank identifier
- Variables, constants, and Go's type system (built-in types, type declarations, type conversions)
- Functions: parameters, return values, named results, variadic functions, and defer
- Pointers: address-of and dereference operators, pointer receivers, and when to use pointers vs. values
- Structs: field declarations, embedding, methods, and receiver types
- Interfaces: defining interfaces, satisfying interfaces implicitly, type assertions, and interface{} for polymorphism
- Error handling: the error interface, error wrapping, and idiomatic error checking patterns
- Goroutines and channels: concurrent execution, communication between goroutines, and basic concurrency patterns
- Explain the difference between value receivers and pointer receivers on methods, and when you would use each.
- What does the blank identifier (_) do in Go, and how is it used in practice?
- How do interfaces work in Go, and why is implicit interface satisfaction considered idiomatic?
- Write a function that returns multiple values, including an error, and explain how to handle it idiomatically.
- What is the purpose of defer, and how does it relate to cleanup and error handling?
- Describe the relationship between pointers, slices, and maps in Go, and how they differ in terms of mutability.
- How do goroutines and channels enable concurrent programming, and what is a common pattern for coordinating them?
- What is the difference between a type assertion and a type switch, and when would you use each?
- Work through all code examples in "The Go Programming Language" chapters 1–7, typing them out and running them locally; modify each to test your understanding.
- Build a command-line tool that reads user input, processes it with custom functions, and returns results with proper error handling.
- Create a struct representing a real-world entity (e.g., Book, User, BankAccount) with methods, including at least one pointer receiver.
- Write a program that defines an interface (e.g., Reader, Writer, Shape) and implement it with multiple concrete types; use type assertions to handle them.
- Implement a simple concurrent program using goroutines and channels (e.g., worker pool, fan-out/fan-in pattern).
- Refactor a procedural program into one using idiomatic Go patterns: proper error handling, pointer receivers where appropriate, and interface-based design.
Next up: Mastering these foundational concepts—syntax, types, methods, interfaces, and error handling—equips you to understand Go's concurrency model and standard library in depth, preparing you to build production-grade applications and explore advanced patterns like reflection and code generation.
The canonical, authoritative introduction to Go co-written by a core language designer. It builds vocabulary and mental models — types, interfaces, packages — that every later book assumes you have.
Complements the Donovan book with a highly visual, example-driven style that reinforces syntax and idioms through hands-on exercises, making abstract concepts like interfaces and methods concrete before moving on.
Concurrency: Goroutines, Channels & Sync
IntermediateUnderstand Go's concurrency primitives — goroutines, channels, select, sync primitives, and the race detector — and apply them correctly to avoid data races and deadlocks.
▸ Study plan for this stage
Pace: 4–5 weeks, ~40–50 pages/day, with 2–3 days per week dedicated to hands-on coding exercises
- Goroutines as lightweight concurrency primitives: creation, lifecycle, and the Go scheduler's M:N model
- Channels as typed, safe communication mechanisms: buffered vs. unbuffered, directional channels, and closing semantics
- The select statement for multiplexing channel operations and handling timeouts
- Synchronization primitives (sync.Mutex, sync.RWMutex, sync.WaitGroup, sync.Once, sync.Cond) and when to use each
- Common concurrency patterns: worker pools, fan-out/fan-in, pipelines, and error handling across goroutines
- The race detector as a tool for identifying data races and the memory model guarantees in Go
- Deadlock detection and prevention through proper channel usage and synchronization discipline
- Context package for cancellation, timeouts, and passing request-scoped values across goroutines
- What is the difference between buffered and unbuffered channels, and when should you use each?
- How does the select statement work, and what happens when multiple channels are ready simultaneously?
- What are the key differences between sync.Mutex, sync.RWMutex, and sync.Once, and when is each appropriate?
- How can you use the race detector to identify data races, and what are common patterns that cause them?
- Describe a worker pool pattern and explain how channels and goroutines coordinate work distribution and result collection
- What are the conditions for a deadlock, and how can you design your channel and synchronization code to prevent it?
- How does context.Context enable cancellation and timeout propagation across a tree of goroutines?
- Create a simple goroutine that sends integers to an unbuffered channel and a main goroutine that receives them; observe blocking behavior
- Build a worker pool with a fixed number of goroutines processing tasks from a work queue using channels
- Implement a fan-out/fan-in pattern: split work across multiple goroutines and merge results back into a single channel
- Write a pipeline of stages (e.g., generate → filter → transform) where each stage runs in its own goroutine and communicates via channels
- Implement a timeout mechanism using select with time.After; then refactor to use context.WithTimeout
- Create a concurrent map access scenario, run it with the race detector (go run -race), identify the race, and fix it using sync.Mutex or sync.RWMutex
- Build a rate limiter using a buffered channel and demonstrate how it throttles concurrent requests
- Implement a graceful shutdown pattern where a context cancellation signal cleanly stops multiple goroutines and waits for them to finish
Next up: This stage equips you with the mental models and practical skills to write safe, efficient concurrent systems in Go; the next stage will likely deepen your ability to apply these primitives to real-world scenarios such as building concurrent servers, handling I/O concurrency, and optimizing performance under load.
The definitive deep-dive into Go's concurrency model. It introduces goroutines and channels from first principles, then covers pipelines, fan-out/fan-in, and the sync package in exactly the order needed to build reliable concurrent services.
Testing, Tooling & Idiomatic Design
IntermediateWrite table-driven tests, benchmarks, and fuzz tests; use the standard toolchain (go vet, go generate, modules); and structure packages and APIs the way experienced Go engineers do.
▸ Study plan for this stage
Pace: 4–5 weeks, ~25–30 pages/day (focusing on Chapters 13–16 of "Learning Go")
- Table-driven tests as a Go idiom for organizing and scaling test cases
- Writing and interpreting benchmark tests with go test -bench to measure performance
- Fuzz testing to discover edge cases and security vulnerabilities automatically
- Using go vet, go fmt, and goimports to enforce code quality and style
- The go generate command for automating code generation workflows
- Module management with go.mod and go.sum for reproducible dependencies
- Package design principles: cohesion, naming, and API surface minimization
- Idiomatic error handling and the error interface in production code
- What is a table-driven test and why is it preferred in Go over writing separate test functions?
- How do you write a benchmark test and what do the metrics (ns/op, B/op, allocs/op) tell you?
- What is fuzz testing and how does go test -fuzz help you find bugs you might not anticipate?
- How do go vet, go fmt, and goimports improve code quality, and when should you run them in your workflow?
- What is the purpose of go generate and how do you define and invoke generation directives?
- How do you manage dependencies with go.mod and go.sum, and what does 'tidy' do?
- What makes a Go package idiomatic in terms of naming, exports, and API design?
- How should you design error types and handle errors idiomatically in Go?
- Refactor an existing set of separate test functions into a single table-driven test with at least 5 test cases covering happy paths and edge cases
- Write a benchmark for a function that processes strings or slices; run it with -benchmem and interpret the allocation metrics
- Create a simple fuzz test (using Go 1.18+ fuzzing) for a parsing or validation function; run it and document at least one edge case it discovers
- Run go vet, go fmt, and goimports on a multi-file package and fix all reported issues; document what each tool caught
- Write a go generate directive that creates a simple code artifact (e.g., a constants file or mock); verify it runs correctly
- Create a new module from scratch, add a dependency, run go mod tidy, and inspect the resulting go.mod and go.sum files
- Design a small package (3–4 exported functions) following Go idioms: clear naming, minimal API surface, and cohesive responsibility; have a peer review it
- Implement custom error types for a domain (e.g., validation errors) and write tests that verify error wrapping and type assertions work correctly
Next up: This stage equips you with the testing, tooling, and design discipline needed to write maintainable, production-grade Go code; the next stage will likely deepen your understanding of concurrency patterns, performance optimization, and building larger systems where these practices become essential.
A modern, opinionated guide to idiomatic Go that dedicates strong coverage to testing, modules, and tooling — filling gaps left by older books and preparing you to write production-grade code.
Discussion
Keep reading
Paths that share books, cover the same subject, or open a related topic.
