Where to go next
Key takeaways You now know enough Go to read and write real programs. To keep growing: write idiomatic Go (formatted, explicit errors, small interfaces), lean on the tooling and standard library, and build small real things — a CLI, a tiny server, a parser. The best next step is a project, not another tutorial.
This is the last lesson, and it’s about momentum. You’ve covered the language, its concurrency model, and how real code is organized. Here’s how to turn that into fluency.
Write idiomatic Go
Go rewards writing code the community way:
- Let
gofmtandgo vetrun on save — never argue with the formatter. - Handle every error explicitly — the
if err != nilyou met in functions & errors is the norm, not a burden. - Keep interfaces small and accept them, return concrete types.
- Name things clearly and briefly — short names for short scopes, descriptive names for exported APIs.
The classic references — A Tour of Go, Effective Go, and Go Code Review Comments — are short and worth reading once you’ve written a little.
A project ladder
Fluency comes from building. A rough progression:
| Step | Build | Exercises |
|---|---|---|
| 1 | A CLI that reads a file and prints a summary | packages, os, io, errors |
| 2 | A program that fetches and parses JSON | net/http, encoding/json, structs |
| 3 | A tiny web server with a couple of routes | net/http, handlers, interfaces |
| 4 | A worker that does several tasks at once | goroutines, channels, sync |
| 5 | A contribution to an open-source Go project | reading real code, tests, review |
Step 5 can be GopherTrunk itself — its contribution guide and test-first bug-fix policy are a great place to practice.
Keep the ecosystem close
- The standard library first — most of what you need is already there.
pkg.go.devdocuments every public package, standard or third-party.- The race detector and tests keep concurrent code honest as it grows.
- The community — the Go blog, forums, and conference talks — is welcoming and unusually focused on clarity.
Where this fits
Go is one skill in a bigger picture. Pair it with the Linux command line, Git, and deployment modules and you can build, version, and ship a real service. Add the DSP module and you have everything GopherTrunk is built from. You’re ready — go build something.
Quick check: what's the most effective next step after this module?
Recap
- Write idiomatic Go: formatted, explicit errors, small interfaces, clear names.
- Grow by building — climb a ladder from a CLI to a concurrent service.
- Keep the standard library,
pkg.go.dev, and the race detector close. - Combine Go with Linux, Git, DSP, and deployment to build something real like GopherTrunk.
That’s the module — from your first program to reading and writing real Go. Keep the glossary handy as a reference.
Frequently asked questions
What should I build to practice Go?
Start small and command-line — a tool that reads a file and prints a summary, a tiny HTTP server, a program that fetches and parses some JSON. Each exercises packages, error handling, and the standard library. Then add concurrency with a program that does several things at once. Building real, small things beats reading more theory.
What does idiomatic Go mean?
Idiomatic Go is code written the way the Go community expects — gofmt-formatted, errors handled explicitly, small interfaces, clear names, no cleverness for its own sake. The documents “Effective Go” and “Go Code Review Comments” capture the conventions. Reading real code (like the previous lesson) is the fastest way to absorb them.