Skip to main content

Learning path

Go learning path: everything to study, topic by topic

Comprehensive Go (Golang) assessment covering language fundamentals, data structures, interfaces, concurrency, standard library, advanced patterns, and runtime internals.

Short answer

To learn Go, work through 6 modules and 35 topics in the order they build on each other. It starts with Language Fundamentals, then moves on to Data Structures & Interfaces and Concurrency. Use the map as a checklist, or measure your level and study only what is missing.

6
modules
35
topics
45
min to assess

What you will study

Topics are grouped by module. Open one to see its objectives and key concepts.

1 · Language Fundamentals6 topics
  • Types & Variables

    Basic types (int, float64, string, bool), variable declaration (var, :=), zero values, constants, iota, type conversions

    Objectives

    • Declare and initialize variables
    • Understand zero values and type system

    Key concepts

    • var declaration
    • short variable declaration :=
    • zero values
    • constants
    • iota
    • type conversion
    • basic types
    • rune
  • Functions & Methods

    Function signatures, multiple return values, named returns, variadic functions, methods on types, value vs pointer receivers

    Objectives

    • Write functions with multiple returns
    • Choose between value and pointer receivers

    Key concepts

    • multiple return values
    • named returns
    • variadic functions
    • defer
    • value receiver
    • pointer receiver
    • first-class functions
    • closures
  • Control Flow

    if/else, for loops (three forms), switch statements, type switch, goto, labels, break/continue with labels

    Objectives

    • Write idiomatic Go control flow
    • Use for-range and type switch correctly

    Key concepts

    • if with init statement
    • for loop (C-style, range, infinite)
    • switch
    • type switch
    • fallthrough
    • break/continue with labels
  • Packages & Imports

    Package declaration, import paths, exported vs unexported names, init functions, go modules, go.mod, go.sum

    Objectives

    • Organize code into packages
    • Understand Go module system

    Key concepts

    • package declaration
    • exported names (uppercase)
    • import paths
    • blank import _
    • dot import
    • init()
    • go.mod
    • go.sum
  • Pointers

    Pointer declaration, dereferencing, pointer receivers, nil pointers, pointer to struct, escape analysis, stack vs heap allocation, pointer arithmetic limitations

    Objectives

    • Declare and use pointers correctly
    • Understand stack vs heap allocation decisions

    Key concepts

    • pointer declaration
    • dereferencing
    • pointer receivers
    • nil pointers
    • pointer to struct
    • escape analysis
    • stack vs heap allocation
    • pointer arithmetic limitations
  • Modules & Packages

    go mod init, go.mod file, go.sum file, go mod tidy, module versioning, replace directives, vendoring, private modules

    Objectives

    • Set up and manage Go modules
    • Understand dependency versioning and vendoring

    Key concepts

    • go mod init
    • go.mod file
    • go.sum file
    • go mod tidy
    • module versioning
    • replace directives
    • vendoring
    • private modules
2 · Data Structures & Interfaces4 topics
  • Slices & Maps

    Arrays vs slices, slice internals (length, capacity, backing array), make, append, copy, map operations, nil slices vs empty slices

    Objectives

    • Understand slice internals
    • Avoid common slice and map pitfalls

    Key concepts

    • array vs slice
    • slice header (ptr, len, cap)
    • make()
    • append()
    • copy()
    • map operations
    • nil slice vs empty slice
    • delete()
  • Structs

    Struct definition, embedding (composition over inheritance), struct tags, anonymous structs, struct comparison, pointer to struct

    Objectives

    • Design types with struct embedding
    • Use struct tags for serialization

    Key concepts

    • struct definition
    • embedding
    • struct tags
    • anonymous structs
    • promoted fields
    • struct comparison
    • pointer to struct
    • constructor pattern
  • Interfaces

    Implicit interface satisfaction, interface composition, empty interface (any), type assertions, type switch, common interfaces (io.Reader, io.Writer, fmt.Stringer)

    Objectives

    • Design small, composable interfaces
    • Apply the io.Reader/Writer pattern

    Key concepts

    • implicit satisfaction
    • interface composition
    • empty interface (any)
    • type assertion
    • type switch
    • io.Reader/Writer
    • fmt.Stringer
    • interface embedding
  • Error Handling

    error interface, errors.New, fmt.Errorf with %w, errors.Is, errors.As, custom error types, sentinel errors, panic/recover

    Objectives

    • Implement idiomatic error handling
    • Wrap and unwrap errors correctly

    Key concepts

    • error interface
    • errors.New
    • fmt.Errorf %w
    • errors.Is
    • errors.As
    • custom error types
    • sentinel errors
    • panic/recover
3 · Concurrency4 topics
  • Goroutines

    Goroutine creation, goroutine lifecycle, goroutine leaks, closures in goroutines, runtime.GOMAXPROCS, goroutine scheduling basics

    Objectives

    • Launch and manage goroutines safely
    • Identify goroutine leaks

    Key concepts

    • go keyword
    • goroutine lifecycle
    • goroutine leaks
    • closure capture in goroutines
    • runtime.GOMAXPROCS
    • main goroutine exit
    • goroutine stack growth
  • Channels

    Unbuffered vs buffered channels, channel direction, range over channel, closing channels, deadlocks, channel patterns (fan-out, fan-in, pipeline)

    Objectives

    • Build concurrent pipelines with channels
    • Avoid deadlocks

    Key concepts

    • unbuffered channel
    • buffered channel
    • channel direction
    • range over channel
    • close()
    • deadlock
    • fan-out/fan-in
    • pipeline pattern
  • Select Statement

    select for multiplexing channels, default case, timeout patterns with time.After, context.Context for cancellation, done channel pattern

    Objectives

    • Multiplex channels with select
    • Implement cancellation with context

    Key concepts

    • select
    • default case
    • time.After
    • time.Tick
    • context.Context
    • context.WithCancel
    • context.WithTimeout
    • done channel
  • Sync Primitives

    sync.Mutex, sync.RWMutex, sync.WaitGroup, sync.Once, sync.Pool, sync.Map, atomic operations

    Objectives

    • Protect shared state correctly
    • Choose between channels and mutexes

    Key concepts

    • sync.Mutex
    • sync.RWMutex
    • sync.WaitGroup
    • sync.Once
    • sync.Pool
    • sync.Map
    • atomic operations
    • race detector
4 · Standard Library & Tooling10 topics
  • net/http

    HTTP server and client, Handler interface, ServeMux, middleware pattern, http.Client timeouts, request context, ResponseWriter

    Objectives

    • Build HTTP servers with proper middleware
    • Configure clients with timeouts

    Key concepts

    • http.Handler
    • http.HandlerFunc
    • ServeMux
    • middleware
    • http.Client
    • timeouts
    • ResponseWriter
    • request context
  • encoding/json

    Marshal/Unmarshal, struct tags, json.Decoder/Encoder streaming, custom MarshalJSON, handling null, omitempty, embedded structs in JSON

    Objectives

    • Serialize and deserialize JSON correctly
    • Handle edge cases in JSON processing

    Key concepts

    • json.Marshal
    • json.Unmarshal
    • struct tags
    • json.Decoder/Encoder
    • MarshalJSON
    • UnmarshalJSON
    • omitempty
    • json.RawMessage
  • Testing Package

    testing.T, table-driven tests, subtests, benchmarks (testing.B), test helpers, testdata, test coverage, httptest

    Objectives

    • Write idiomatic table-driven tests
    • Benchmark and profile code

    Key concepts

    • testing.T
    • table-driven tests
    • t.Run subtests
    • testing.B benchmarks
    • t.Helper()
    • httptest.NewServer
    • test coverage
    • t.Parallel()
  • Go Tools

    go build, go run, go vet, go fmt, go mod (init, tidy, vendor), go generate, go install, golangci-lint, pprof

    Objectives

    • Use the Go toolchain effectively
    • Configure CI pipelines for Go projects

    Key concepts

    • go build
    • go vet
    • go fmt
    • go mod tidy
    • go generate
    • golangci-lint
    • pprof
    • build tags
  • Standard Library

    os package, time package, regexp package, bufio package, flag package, strings package, fmt formatting, io.Reader/Writer patterns

    Objectives

    • Navigate and use key standard library packages
    • Apply io.Reader/Writer patterns across the standard library

    Key concepts

    • os package
    • time package
    • regexp package
    • bufio package
    • flag package
    • strings package
    • fmt formatting
    • io.Reader/Writer
  • Web Frameworks

    Gin framework, Echo framework, Fiber framework, Chi router, middleware patterns, request binding, response rendering, framework comparison

    Objectives

    • Compare Go web frameworks and choose appropriately
    • Implement middleware and request handling patterns

    Key concepts

    • Gin framework
    • Echo framework
    • Fiber framework
    • Chi router
    • middleware patterns
    • request binding
    • response rendering
    • framework comparison
  • Database Access

    database/sql package, GORM ORM, sqlx package, pgx driver, connection pooling, prepared statements, transactions in Go, migration tools

    Objectives

    • Use database/sql and ORMs for data persistence
    • Manage connections and transactions correctly

    Key concepts

    • database/sql package
    • GORM ORM
    • sqlx package
    • pgx driver
    • connection pooling
    • prepared statements
    • transactions in Go
    • migration tools
  • CLI Development

    Cobra library, urfave/cli, flag package, argument parsing, subcommands, interactive prompts, CLI testing, cross-platform builds

    Objectives

    • Build command-line tools with Cobra or urfave/cli
    • Implement subcommands and argument parsing patterns

    Key concepts

    • Cobra library
    • urfave/cli
    • flag package
    • argument parsing
    • subcommands
    • interactive prompts
    • CLI testing
    • cross-platform builds
  • Build & Toolchain

    go build flags, cross-compilation, build tags, ldflags, CGO_ENABLED, go install, go generate, build caching

    Objectives

    • Configure cross-compilation and build flags
    • Embed version info and control CGo with build settings

    Key concepts

    • go build flags
    • cross-compilation
    • build tags
    • ldflags
    • CGO_ENABLED
    • go install
    • go generate
    • build caching
  • Code Quality

    golangci-lint, staticcheck, go vet, govulncheck, gofmt vs goimports, race detector, go test -cover, benchmarking

    Objectives

    • Set up comprehensive Go linting and quality pipelines
    • Use vulnerability scanning and coverage tools effectively

    Key concepts

    • golangci-lint
    • staticcheck
    • go vet
    • govulncheck
    • gofmt vs goimports
    • race detector
    • go test -cover
    • benchmarking
5 · Advanced Patterns4 topics
  • Generics

    Type parameters, constraints, type sets, comparable, any, generic functions, generic types, type inference, constraints package

    Objectives

    • Write generic functions and types
    • Design effective type constraints

    Key concepts

    • type parameters
    • constraints
    • type sets
    • comparable
    • any constraint
    • type inference
    • generic data structures
    • ~T (underlying type)
  • Reflection

    reflect.Type, reflect.Value, Kind, struct tag parsing, dynamic method calls, reflect.DeepEqual, performance implications

    Objectives

    • Use reflection for struct introspection
    • Understand when to avoid reflection

    Key concepts

    • reflect.TypeOf
    • reflect.ValueOf
    • Kind
    • struct tag parsing
    • dynamic method invocation
    • reflect.DeepEqual
    • settability
    • performance cost
  • Unsafe Package

    unsafe.Pointer, unsafe.Sizeof, unsafe.Offsetof, uintptr arithmetic, type punning, memory layout, alignment, when unsafe is justified

    Objectives

    • Understand memory layout and alignment
    • Know risks and valid uses of unsafe

    Key concepts

    • unsafe.Pointer
    • unsafe.Sizeof
    • unsafe.Offsetof
    • uintptr
    • type punning
    • memory alignment
    • struct padding
    • unsafe.Slice
  • Code Generation

    go generate, code generators (stringer, mockgen, protoc-gen-go), AST manipulation with go/ast, text/template for codegen, build tags for generated code

    Objectives

    • Set up code generation pipelines
    • Parse Go AST for custom tooling

    Key concepts

    • go generate
    • //go:generate directive
    • stringer
    • mockgen
    • protoc-gen-go
    • go/ast
    • text/template
    • build constraints
6 · Expert Go7 topics
  • Runtime Internals

    Go scheduler (GMP model), garbage collector (tri-color mark-and-sweep), stack management, escape analysis, memory allocator, GOGC tuning

    Objectives

    • Explain the Go scheduler's GMP model
    • Tune GC for production workloads

    Key concepts

    • GMP model (goroutine, M, P)
    • work stealing
    • tri-color GC
    • write barriers
    • stack growth/shrinking
    • escape analysis
    • GOGC / GOMEMLIMIT
    • memory allocator (mcache, mcentral, mheap)
  • Performance Optimization

    pprof (CPU, memory, goroutine), trace tool, benchmarking methodology, allocation reduction, sync.Pool, string interning, CGo overhead, distributed system patterns

    Objectives

    • Profile and optimize Go services
    • Design high-performance distributed systems in Go

    Key concepts

    • pprof
    • trace tool
    • benchmark methodology
    • allocation reduction
    • sync.Pool
    • string builder
    • CGo overhead
    • connection pooling
  • Advanced Concurrency Patterns

    Advanced Go concurrency: errgroup, semaphore, context cancellation trees, and concurrency anti-patterns

    Objectives

    • Use errgroup to fan out goroutines and collect the first error
    • Detect and fix data races using the -race flag

    Key concepts

    • errgroup
    • semaphore
    • context cancellation
    • select patterns
    • channel directions
    • sync.Once
    • data race detection
    • -race flag
  • CGo & C Interop

    Calling C code from Go using CGo, managing memory across the boundary, and understanding CGo's performance costs

    Objectives

    • Call a C function from Go and manage cross-boundary memory correctly
    • Explain why CGo disables the goroutine scheduler and its performance implications

    Key concepts

    • import C
    • CGo calling conventions
    • C.malloc/C.free
    • GoString/CString
    • CGo performance overhead
    • thread locking
  • Go Performance Tuning at Scale

    Using pprof, trace, and benchmarks to identify and fix CPU, memory, and goroutine bottlenecks in Go services

    Objectives

    • Profile a Go service with pprof to locate the hot CPU path
    • Use go tool trace to diagnose goroutine scheduling latency

    Key concepts

    • pprof
    • go tool trace
    • benchmark functions
    • allocs/op
    • CPU profiling
    • goroutine leaks
    • sync.Pool
  • Go Security Patterns

    Secure coding in Go: input validation, SQL injection prevention, cryptographic APIs, and dependency auditing

    Objectives

    • Configure crypto/tls with secure cipher suites and minimum version
    • Use gosec in CI to detect common Go security antipatterns

    Key concepts

    • crypto/tls
    • html/template escaping
    • parameterized queries
    • gosec
    • supply chain (go.sum)
    • constant time comparison
    • secure defaults
  • Go Plugin Architecture

    Implementing extensible Go applications using the plugin package, hashicorp/go-plugin, or interface-based extension points

    Objectives

    • Compare Go native plugin package with hashicorp/go-plugin for production use
    • Design an interface-based plugin contract that allows hot-reloading

    Key concepts

    • plugin.Open
    • hashicorp/go-plugin
    • gRPC-based plugins
    • interface contracts
    • ABI stability
    • hot reload patterns

Levels: Junior, Mid, Senior, and Expert

Explain it in your own words

Graded by AI · no account · 1 question

No options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.

0 / 600

Already studying Go?

The assessment measures topic by topic, and your plan skips what you already know.

Measure my level

Open to read. An account is only needed to be measured.

Frequently asked questions

Where should I start studying Go?

Start with Language Fundamentals: Types & Variables, Functions & Methods, and Control Flow. The map orders topics by what they depend on, so each one prepares the next.

How long does a full Go assessment take?

A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.

Do I need an account to use this page?

No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.