Hero roadmap: the whole course on one page
All 50 lessons
The course below runs from setup to capstones in fifty steps. Lessons 01 to 40 are listed by number only, and every link opens the course index at Go course. The integrator will replace these placeholders with exact lesson addresses.
Lessons 01 to 10: first steps.
- Lesson 01: What is Go and where it runs
- Lesson 02: Install Go and check the version
- Lesson 03: Your first Go program
- Lesson 04: Modules with go mod
- Lesson 05: Variables
- Lesson 06: Constants
- Lesson 07: Types
- Lesson 08: Numbers
- Lesson 09: Strings
- Lesson 10: Conditions with if
Lessons 11 to 20: core language.
- Lesson 11: Switch in Go
- Lesson 12: Loops with for
- Lesson 13: Arrays in Go
- Lesson 14: Slices in Go
- Lesson 15: Maps in Go
- Lesson 16: Functions in Go
- Lesson 17: Errors as values
- Lesson 18: Pointers in Go
- Lesson 19: Structs in Go
- Lesson 20: Methods in Go
Lessons 21 to 30: standard library.
- Lesson 21: Interfaces in Go
- Lesson 22: Embedding instead of inheritance
- Lesson 23: Generics in Go
- Lesson 24: Packages and imports
- Lesson 25: The go toolchain
- Lesson 26: Testing with go test
- Lesson 27: Advanced errors
- Lesson 28: defer in Go
- Lesson 29: Strings, bytes and runes
- Lesson 30: Time in Go
Lessons 31 to 40: tools and practice.
- Lesson 31: JSON
- Lesson 32: Files and IO
- Lesson 33: HTTP servers
- Lesson 34: HTTP clients
- Lesson 35: Context
- Lesson 36: Goroutines
- Lesson 37: Channels
- Lesson 38: select and sync
- Lesson 39: CLI: args, flags, env
- Lesson 40: Logging
Lessons 41 to 50: advanced topics and capstones.
- Lesson 41: Regular expressions
- Lesson 42: Sorting
- Lesson 43: Concurrency patterns
- Lesson 44: Databases with database/sql
- Lesson 45: Benchmarks and profiling
- Lesson 46: Toolchain and CI
- Lesson 47: Project layout
- Lesson 48: Capstone: wordfreq CLI
- Lesson 49: Capstone: JSON API server
- Lesson 50: Hero roadmap: the whole course on one page
How to practice
Reading builds vocabulary, but typing builds skill. Work through every lesson with an editor open, type each program by hand, run it, and break it on purpose to see the error messages.
Change one thing at a time after the example works: new input, new limits, new order. Small edits teach faster than big rewrites because every result maps to exactly one decision.
The classic drill below prints numbers with word swaps for multiples. Type it, run it, then extend the rules and cover the new branches with a table test.
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 15; i++ {
switch {
case i%15 == 0:
fmt.Println("fizzbuzz")
case i%3 == 0:
fmt.Println("fizz")
case i%5 == 0:
fmt.Println("buzz")
default:
fmt.Println(i)
}
}
}
1
2
fizz
4
buzz
fizz
7
8
fizz
buzz
11
fizz
13
14
fizzbuzz
Two capstones, revisited (48+49)
The course ends with two projects that reuse everything before them. Rebuild each one from an empty folder without peeking, and compare the result with the lesson only at the end.
Start with Lesson 48: Capstone: wordfreq CLI, which turns flags and standard input into ranked word lists. Then build Lesson 49: Capstone: JSON API server, which serves the same counting logic over HTTP with tested JSON handlers.
Where to go next
Graduation means reading real code and writing small tools every week. The Golang hub collects the next references for that habit.
- Install Go on Linux — set up a fresh machine in minutes.
- Declare variables — revisit the basics with fresh eyes.
- Find the type of a variable — inspect values during debugging.
- Pointers — sharpen the mental model behind references.
- Constants — lock values that must never change.
- Go documentation — learn to read the standard library on your own.
Next: Go course
Article author: Arthur Isaev
