The full route
From first principles to production.
Nothing is locked. Follow the sequence or jump to the idea you need today.
Foundations refresh
Syntax becomes muscle memory; the project turns it into a useful CLI.
Setup and toolchain
Install Go and learn the commands that turn source into a dependable program.
Variables, types, constants
Use Go’s type system, zero values, conversions and constants with confidence.
Control flow
Shape programs with Go’s compact if, for and switch statements.
Functions and closures
Compose behavior with multiple returns, variadic functions, closures and defer.
Arrays and slices
Understand slice headers, shared backing arrays, capacity and append.
Maps, strings, runes
Work safely with maps and Unicode text instead of assuming every character is one byte.
Word-frequency CLI
Build a tested command-line tool from the foundations in Week 1.
Types, methods, interfaces, errors
Model a domain and make failure behavior explicit.
Structs
Model data with literals, embedding, comparison and clear invariants.
Methods
Choose value or pointer receivers and understand method sets.
Pointers and memory
Use pointers, nil, new and make without importing C’s mental model.
Interfaces
Design small behavior contracts and avoid the nil-interface trap.
Standard interfaces
Connect your types to fmt, errors, io and sort.
Errors and panics
Create, wrap, inspect and recover from failures deliberately.
Library management CLI
Combine structs, interfaces and typed errors in a local project.
Catch-up & review I
Revisit the weakest topics from Weeks 1–2 or recover a missed day.
Packages, testing, generics, I/O
Move from snippets to maintainable, tested modules.
Packages and modules
Organize real programs across packages, modules and internal boundaries.
Testing basics
Write table-driven tests, subtests and useful helpers.
Benchmarks, fuzzing, coverage
Measure code, explore unexpected inputs and use coverage as evidence.
Generics I
Write reusable functions and types with precise constraints.
Generics II and iterators
Use slices, maps and iterator APIs in modern Go.
Files and I/O
Stream, scan, copy and walk files while handling cleanup.
Log analyzer
Build and test a multi-package log analysis tool.
Concurrency
Coordinate work safely with goroutines, channels and context.
Goroutines
Launch concurrent work and wait for it without leaking tasks.
Channels
Coordinate values and ownership with buffered and unbuffered channels.
Select and time
Combine channels with timeouts, tickers and cancellation.
Sync primitives
Protect shared state and use the race detector to prove it.
Concurrency patterns
Build worker pools, pipelines and bounded parallel work.
Context
Propagate cancellation and deadlines across call boundaries.
Concurrent URL checker
Ship a race-clean worker-pool application.
Catch-up & review II
Consolidate testing and concurrency before building services.
Building real programs
Build an HTTP service with persistence and operations basics.
JSON
Encode APIs with tags, custom formats and careful decoding.
HTTP server
Build and test handlers with the standard library ServeMux.
HTTP client and middleware
Set timeouts, decode responses and compose handler behavior.
REST API
Design CRUD routes, status codes, validation and an in-memory store.
Databases
Use database/sql, transactions and a repository boundary.
CLIs, config, logging
Configure a service, emit structured logs and shut down cleanly.
Todo REST API
Combine HTTP, SQLite, validation and logging in a tested service.
Idiomatic, fast, shippable Go
Polish judgment, performance and delivery through a capstone.
Idiomatic Go
Refine names, package APIs and zero values for clear Go code.
Performance and profiling
Find hot spots with evidence and reduce avoidable allocations.
Runtime internals
Build a useful mental model of scheduling, GC and happens-before.
Reflection, embed, build tags
Use metaprogramming tools narrowly and deliberately.
Tooling and shipping
Vet, lint, cross-compile, containerize and automate checks.
Capstone build: design and core
Design Spendwise and build its service and storage layers.
Capstone build: test and ship
Finish Spendwise, test it, ship it and take the final review.
Catch-up & final polish
Redo weak tasks or add the final capstone polish.