A sequenced checklist of topics to learn and resources to read for developers picking up Go, with a Python → Go mindset bridge baked in. Track your progress, jump between phases, pick up where you left off.
Go is designed to be picked up fast - but truly owning it as a Python developer means understanding where it diverges in ways that matter. This page sequences the topics in the order they make most sense to learn, and points at the best resources for each.
Two minutes of orientation so the rest of the page has context.
Every section in this guide follows the same shape. Get comfortable with these three labels - you'll see them in every tab.
Free, open-source companion Go course covering everything from absolute beginner to shipping idiomatic Go. Each chapter has quizzes and exercises, with full-text search and its own browser-local progress tracking. Whenever you see a "Companion chapters" block in this guide, those pills link directly into specific lessons of this course - the friendliest path through any topic on this page.
select, sync.~half day
6ToolingModules, testing, linting, IDE.~1 hr
7Project layoutcmd/, internal/, capitalization-as-export.~30 min
8Common pitfallsConcrete gotchas Python devs trip on.~20 min
9Hands-on practicePick a kata, ship it.~half day
10ResourcesAnnotated reference list.reference
11Readiness checklist"You'll know you're ready when…"~5 min
The places where Go will actively fight your Python instincts. Read this before writing a line of Go - it's the page's biggest payoff.
A Python developer should leave this section with a mental map, not just trivia.
| Python concept | Go equivalent | Note | Learn more |
|---|---|---|---|
| Classes | Structs + interfaces | Composition over inheritance; no class hierarchy. | 15Structs |
| Duck typing | Implicit interface satisfaction | No implements keyword; if the methods match, it satisfies the interface. |
21Interfaces |
Exceptions (try / except) |
Multiple return values with error |
Errors are values; you check them, you don't catch them. | 23Error handling |
threading / asyncio |
Goroutines + channels | Concurrency is built into the language and runtime. | 24Goroutines |
pip / venv / requirements.txt |
Go modules (go.mod, go.sum) |
Per-project, vendored optional, reproducible. | 18Packages & modules |
| Dynamic typing | Static typing with inference (:=) |
Compiler enforces types; you rarely write them. | 06Basic types |
__init__ / constructors |
New* function convention |
Convention, not language feature. Returns *T (or T, error). |
15Structs |
with / context managers |
defer |
Cleanup runs in LIFO order at function exit. | Go by Example: Defer |
| Decorators | Function wrapping / middleware | First-class functions, no syntactic sugar. | 11Functions |
Optional mypy |
Static typing is the default | Compiler does the checking; no separate tool. | 06Basic types |
_private / __name conventions |
Capitalization controls export | Foo is exported; foo is package-private. |
19Naming & style |
__del__ / garbage hooks |
None - use defer, no finalizers |
Don't try to recreate destructors. | Go by Example: Defer |
The canonical post on Go's error philosophy from one of the language designers. Read this before you write a single if err != nil; it reframes the whole exception-vs-value question Python devs trip on.
The most common source of panics in Go. nil in Go is not the same as None in Python: an interface can be non-nil while holding a nil concrete value. Diagrams included; absolutely worth the half-hour.
The de-facto guide to idiomatic Go. Read after the table; it reinforces the concept-by-concept mapping above.
The unofficial style guide that experienced Go reviewers use. A Python dev wouldn't guess these conventions.
Why Go reads types left-to-right (x int) instead of C/Python's right-to-left convention. Short and surprisingly useful for the moment a Python dev first hits func foo(x int) string.
Get hands on the keyboard with the official tour, then tackle the handful of concepts Python developers most often trip on.
Hands on the keyboard with the official tour.
The canonical starting point. Covers syntax, types, methods, interfaces, and a taste of concurrency. Complete every section - don't skip the hard ones.
Read after the tour. Teaches you to write Go that other Go developers will recognize as idiomatic.
The canonical landing page for everything official. Bookmark this - you'll come back often.
Hello-world walk-through that gets a Go module set up locally. Pair with the Tour for the first hour of hands-on work.
The official explanation of how go build / go test / go install and modules fit together. Surprisingly under-read; covers the mental model the Tour skips.
The handful of ideas Python developers most commonly trip on.
The best "how do I do X" reference. Covers each topic above with runnable examples.
Re-read the interfaces and error-handling sections specifically with code in your editor.
Real production mistakes organized by category. Pairs with this section and the pitfalls section.
The canonical explanation of all three keywords with worked examples. Clear guidance on when panic is appropriate and when it isn't.
Introductory companion to Pike's "Errors are values"; covers the error interface, errors.New, and fmt.Errorf.
The canonical reference on the slice header, capacity, and append aliasing - the exact bug source called out in the Topics list above.
Go's headline feature, plus the toolchain you'll use every day. Project layout sits here too - different enough from Python to warrant its own spot.
Go's headline feature. Hard to fake competence here.
Walk through goroutines, channels, select, and the sync primitives one example at a time.
The "share memory by communicating" mental model, with concrete patterns straight from the language designers.
The talk that taught a generation how to think in goroutines and channels. Watch this once before you ship anything concurrent.
Annotated walk-through of a small concurrent program - the official illustration of Go's central concurrency proverb. Compact, runnable, worth the 15 minutes.
Direct application of select for the timeout / cancellation patterns the Topics list calls out.
Equip yourself to actually work in a Go repo.
Modules, testing, vet, build - all the toolchain documentation lives here.
The current canonical guide for go mod workflows - adding, updating, removing dependencies, replace directives, and vendor. Replaces the older blog posts.
The official editor / IDE roundup, including the recommended VS Code Go extension, GoLand, and notes on gopls.
Operating manual for go test -race. How to run it, how to read its output, and when to turn it on in CI.
Different enough from Python to warrant its own section.
The naming rules and the why behind them. Short, dense, essential.
The packaging conventions a reviewer will hold you to.
The current canonical answer to "what goes in cmd/, internal/, pkg/". Replaces the older community golang-standards/project-layout.
Cross-listed from Foundations - the layout sections are equally relevant here. Covers project structure with the go command's expectations.
A scannable list of gotchas that catch every Python developer at least once, plus a kata to glue everything together.
Concrete gotcha list. Each item is a one-liner; the resources go deeper.
The companion site for this section. Each mistake explained with broken code, correct code, and the why.
Short, dense aphorisms from Rob Pike. Worth reading once, then revisiting whenever you write Go.
Pairs directly with the "maps not safe for concurrent access" pitfall. How to enable the race detector and how to interpret its output.
Glue everything together at least once. Pick one of the suggested katas.
Reference snippets while building. Best companion to keep in a second tab.
Quick experiments without a local setup. Shareable URLs, race detector available.
Exercises from the freeCodeCamp Go course. Useful if you want a structured set of practice problems.
Self-contained kata that exercises HTTP handlers, routing, and JSON. A great "first real Go project" target.
The classic Go wiki tutorial - builds a small webapp end-to-end with the standard library only. Excellent for understanding what you get without a framework.
Every link, in one place - annotated and grouped. Then a self-check to mark the transition from learning to shipping.
Canonical starting point. Runs in your browser, no install.
The authoritative grammar and semantics. Use it when blogs disagree.
Answers to the questions every newcomer asks ("why no generics?", "why no exceptions?", "why nil behaves like that?").
Rob Pike's short, dense aphorisms about how to think in Go.
The best "how do I do X" reference. Use it whenever you're writing Go.
Catalog of real production mistakes. Pairs directly with the pitfalls section.
Full companion course covering everything from installation through a capstone CLI project. Individual chapters are linked from the relevant tabs above.
Two-minute orientation. Embedded on the Overview tab.
Recommended pick for video learners. Diagram-heavy explanations make concurrency and interfaces click.
Another solid Udemy option if Grider's style isn't for you.
Free full course. Companion code: bootdotdev/fcc-learn-golang-assets.
The authoritative reference, co-authored by Brian Kernighan. Dense, precise, full of excellent examples. Use as a deep-dive companion.
Search "Dave Cheney errors are values" to start. Influential thinking on idiomatic error handling.
Mark the transition from learning to shipping Go on the team. You'll know you're ready when…