This eight-week study plan helps experienced programmers learn Go through retrieval, tested exercises, and one evolving project. By the end, you will be able to structure, test, build, and explain a small Go service instead of only recognizing syntax.
Works with Go 1.22 and later. The example was executed with Go 1.24.7 on Windows amd64.
Study by producing evidence every week
Reading creates familiarity; writing and testing reveal whether you can use an idea. Each week should end with a program, test, benchmark, or written design explanation that another developer can inspect.
Keep the complete Go tutorial as the reference path. Use the practical beginner course for connected project work and this guide to schedule it.
Week 1: toolchain, modules, functions, and errors
Install Go, confirm the version, create a module, and learn go run, go test, go fmt, and go build. Write functions that return errors for invalid input. Avoid global state so tests can call the functions directly.
Deliverable: a command that reads arguments, validates them, and prints a result. The first Go program provides the starting point.
Week 2: slices, maps, structs, and methods
Model a small domain such as tasks, orders, or log entries. Use slices when order matters and maps for keyed lookup. Add methods only when behavior belongs to a type.
This word-frequency example combines a function, map, loop, strings, and deterministic assertions without introducing I/O too early.
package main
import (
"fmt"
"strings"
)
func frequencies(text string) map[string]int {
counts := make(map[string]int)
for _, word := range strings.Fields(strings.ToLower(text)) {
counts[word]++
}
return counts
}
func main() {
counts := frequencies("Go tests make Go changes safer")
fmt.Println("go:", counts["go"])
fmt.Println("tests:", counts["tests"])
}Output observed with Go 1.24.7:
go: 2
tests: 1Extend it by stripping punctuation, sorting output, and adding table-driven tests. Each extension introduces one concern.
Week 3: packages and boundaries
Split code when a package has a clear responsibility, not because a diagram says every project needs layers. Keep the executable small and move domain behavior behind package functions. The Go project structure guide shows how modules, packages, cmd, and internal fit together.
Deliverable: a module with a command, one internal package, and tests.
Week 4: interfaces and dependency direction
Learn that interfaces are satisfied implicitly. Define a small interface at the consumer when a second implementation or test boundary exists. Practice accepting behavior and returning concrete types.
Deliverable: replace an in-memory dependency with a test double through a one- or two-method interface.
Week 5: HTTP and JSON
Build an HTTP handler using net/http, validate method and input, limit request bodies, return consistent JSON errors, and test with httptest. Configure timeouts before calling the service production-ready.
Deliverable: create, fetch, and list one resource with handler tests.
Week 6: concurrency and cancellation
Learn goroutines, channels, mutexes, sync.WaitGroup, and context through bounded work. Every goroutine needs an exit condition. Run the race detector against concurrent tests.
Deliverable: process a fixed queue with a worker limit and cancellation.
Week 7: profiling and operational behavior
Add structured logs, health endpoints, graceful shutdown, benchmarks, and a CPU or memory profile. Learn to measure before optimizing.
Deliverable: explain one measured bottleneck and the effect of one change.
Week 8: build and review the capstone
Run formatting, vet, tests, race detection, and the build from a clean checkout. Write a README that explains boundaries, failure modes, commands, and tradeoffs. Ask another developer to run it without your help.
The Go tools guide provides a compact quality loop for this review.
Use a repeatable study session
A productive 60-minute session can be:
- Ten minutes recalling the previous concept without notes.
- Fifteen minutes reading one focused source.
- Twenty-five minutes implementing or changing code.
- Ten minutes running tests and writing what failed.
Record questions and wrong predictions. Those are more useful than a list of pages completed.
Common mistakes
Collecting resources instead of finishing projects
Choose one reference path and one project for eight weeks. Add a resource only when it answers a specific blocked question.
Copying code before predicting behavior
State the expected output or error first. Then run the program and explain any difference.
Avoiding the standard library
Frameworks are easier to evaluate after you understand HTTP handlers, contexts, JSON, tests, and errors underneath them.
What next
Begin with the first Go program, then organize it using Golang file structure and learn the build loop in Go compilation and execution.