roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Builds interview-depth command of Go, from the language core to the concurrency model interviewers probe hardest. Covers types and syntax, goroutines and channels, error handling, and Go idioms.
1712 of 1712 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 1712 new. 0 cut, outside your plan.
Go loops split less by seniority than by what the program on the other end does: answer requests as a service, or run beside the infrastructure as a tool. Service teams ask about the life of a request: a handler that keeps working after its client has disconnected, a deploy that must not cut off requests already in flight, a connection pool drained by result rows nobody closed. Platform and infrastructure teams, who write the CLIs, agents and controllers, ask what a long-running process does to its host: a goroutine leak that grows for days, a binary cross-compiled for another architecture, a garbage collector made to live under a container's memory limit. Neither side skips the semantics underneath, and the first technical questions are usually shared: what `append` does to a slice two variables share, and why an interface holding a nil pointer does not compare equal to `nil`. Each role roadmap that carries this topic does so for a reason of its own. On the [Blockchain Developer](/roadmaps/blockchain) path, Go is the language of many node clients and chain frameworks, and the questions turn to determinism: Go randomizes map iteration order on purpose, so state-transition code that ranges over a map can leave two nodes disagreeing. A [Server-Side Game Developer](/roadmaps/server-side-game-developer) loop asks about thousands of long-lived connections, with a goroutine or two behind each, and what allocating inside a tick loop does to tail latency once the collector runs. For [DevSecOps](/roadmaps/devsecops), where much of the scanning and signing tooling is itself written in Go, expect TLS configuration, decoding input you do not trust, and how a module's dependencies are checked for known vulnerabilities. Open the one for your role to prepare for the whole loop rather than the language.
Read the [primer on the Go hub](/topics/lang-go) once, before the first question, for why the tree is cut where it is and which sections lean on others. After that, drill: answer a few questions aloud at a time and test each answer against code you can run, since a ten-line program settles most arguments about what a slice or an interface holds. Juniors are judged on whether their model of values survives a follow-up, so [slices, maps and structs](/topics/lang-go-core-language-composites) come first: when `append` reallocates, what a function handed a slice can change in its caller, why a map has to be made before anything is written to it. Middle candidates are separated by whether their goroutines stop. A worker pool that winds down when its caller gives up is a [context](/topics/lang-go-concurrency-context) question as much as a channel one, and it is the code many loops ask you to write. Senior candidates should reach [symptoms in production](/topics/lang-go-performance-diagnosis) early, such as a goroutine count that only climbs or latency spikes that line up with collection, because scheduler and collector questions usually arrive as a symptom to explain, and that answer comes easier from a profile than from memory. Go screens usually stay inside the core language, errors and one short concurrency exercise. If yours is days away, spend the days there: narrow level so it stops at the seniority on the job posting, narrow importance to must know, and put the hours saved into writing that exercise by hand and running it under `go test -race`.
Go loops split less by seniority than by what the program on the other end does: answer requests as a service, or run beside the infrastructure as a tool. Service teams ask about the life of a request: a handler that keeps working after its client has disconnected, a deploy that must not cut off requests already in flight, a connection pool drained by result rows nobody closed. Platform and infrastructure teams, who write the CLIs, agents and controllers, ask what a long-running process does to its host: a goroutine leak that grows for days, a binary cross-compiled for another architecture, a garbage collector made to live under a container's memory limit. Neither side skips the semantics underneath, and the first technical questions are usually shared: what append does to a slice two variables share, and why an interface holding a nil pointer does not compare equal to nil.
Each role roadmap that carries this topic does so for a reason of its own. On the Blockchain Developer path, Go is the language of many node clients and chain frameworks, and the questions turn to determinism: Go randomizes map iteration order on purpose, so state-transition code that ranges over a map can leave two nodes disagreeing. A Server-Side Game Developer loop asks about thousands of long-lived connections, with a goroutine or two behind each, and what allocating inside a tick loop does to tail latency once the collector runs. For DevSecOps, where much of the scanning and signing tooling is itself written in Go, expect TLS configuration, decoding input you do not trust, and how a module's dependencies are checked for known vulnerabilities. Open the one for your role to prepare for the whole loop rather than the language.
Read the primer on the Go hub once, before the first question, for why the tree is cut where it is and which sections lean on others. After that, drill: answer a few questions aloud at a time and test each answer against code you can run, since a ten-line program settles most arguments about what a slice or an interface holds.
Juniors are judged on whether their model of values survives a follow-up, so slices, maps and structs come first: when append reallocates, what a function handed a slice can change in its caller, why a map has to be made before anything is written to it. Middle candidates are separated by whether their goroutines stop. A worker pool that winds down when its caller gives up is a context question as much as a channel one, and it is the code many loops ask you to write. Senior candidates should reach symptoms in production early, such as a goroutine count that only climbs or latency spikes that line up with collection, because scheduler and collector questions usually arrive as a symptom to explain, and that answer comes easier from a profile than from memory.
Go screens usually stay inside the core language, errors and one short concurrency exercise. If yours is days away, spend the days there: narrow level so it stops at the seniority on the job posting, narrow importance to must know, and put the hours saved into writing that exercise by hand and running it under go test -race.