shaneohanlon.dev / learning / go-learning

Go Learning
Plan

A 10-part self-directed plan covering Go fundamentals, idiomatic design, standard library depth, concurrency, CLI development, HTTP services, Kubernetes tooling, cloud SDKs, testing, and production code study.

Go Concurrency CLI HTTP Kubernetes Production
Phase 01
Language & Idioms
Weeks 1–3
0%
Phase 02
Concurrency & Services
Weeks 4–6
0%
Phase 03
Platform & Cloud
Weeks 7–8
0%
Phase 04
Testing & Production
Weeks 9–10
0%
Learning Journey
1
Foundations
Wks 1–3 · Language
2
Build Things
Wks 4–6 · Services
3
Ecosystem
Wks 7–8 · Platform
4
Production
Wks 9–10 · Testing
Phase 01 · Weeks 1–3

Language & Idiomatic Go

Core language, standard library, and style.
Start with the language itself. Learn the syntax, data structures, interfaces, and method sets first, then move into idiomatic style and the standard library packages you will use repeatedly in real code.
Read First
  • Tour of Go ↗ Learn syntax, types, slices, maps, structs, methods, interfaces, and concurrency basics.
  • The Go Programming Language — Donovan & Kernighan
    Focus on interfaces, methods, error handling, and concurrency patterns.
  • Effective Go ↗ Idioms, naming, API design, and formatting conventions.
  • Go Code Review Comments ↗ Production-grade expectations for style and review quality.
Concepts to Nail
  • Understand slices, maps, structs, methods, and interfaces
  • Explain zero values, pointers, and error-first flow clearly
  • Know idiomatic naming and when exported vs unexported matters
  • Be comfortable navigating pkg.go.dev for standard library docs
  • Read and understand table-driven tests in existing Go code
Standard Library Deep Dive

Use the standard library as your default toolkit before reaching for frameworks.

  • Read docs for net/http, context, and encoding/json
  • Read docs for os, io, sync, time, errors, and testing
  • Practice building small examples using only the standard library
Phase 02 · Weeks 4–6

Concurrency, CLI Development & HTTP Services

Hands-on with real programs and service patterns.
Build intuition through practice. Concurrency is where Go becomes distinctive, and the fastest way to internalise it is by writing worker pools, rate limiters, CLIs, and small HTTP services yourself.
Read & Learn
  • Concurrency in Go — Katherine Cox-Buday
    Focus on goroutines, channels, select, cancellation, worker pools, and sync primitives.
  • flag package ↗ Argument parsing basics for small CLIs.
  • Cobra ↗ Structured CLI apps with commands and subcommands.
  • Viper ↗ Configuration management and environment loading.
  • net/http ↗ Handlers, middleware, context usage, and graceful shutdown.
Hands-On Projects
  • Build a worker pool from scratch
  • Implement a simple rate limiter
  • Write an HTTP server with graceful shutdown
  • Build a CLI using Cobra and Viper
  • Add middleware and context propagation to a small service
Practice Targets
go run ./cmd/app go test ./... go test -race ./... go test -bench=. ./... go tool pprof http://localhost:6060/debug/pprof/profile
  • chi ↗ Optional router if you want something lightweight and idiomatic.
  • echo ↗ Optional router if you want a more batteries-included framework.
Phase 03 · Weeks 7–8

Platform & Cloud Development

Kubernetes clients and AWS SDK work.
Move from application code into infrastructure-facing Go. Learn the patterns used for controllers, watchers, cloud SDK interactions, and long-running services that integrate with external APIs.
Read
  • client-go ↗ Resource watching, patching, shared informers, and controller patterns.
  • AWS SDK for Go v2 ↗ Focus on S3, EC2, and IAM interactions to build real cloud tooling.
Focus Areas
  • Read client-go examples for watch and list patterns
  • Patch a Kubernetes resource using typed or dynamic clients
  • Write an AWS SDK script for S3 or EC2
  • Use context and retries correctly when calling external APIs
Where Go Shows Up in Platform Work
Layer 01
Services
HTTP APIs, CLIs, daemons, and internal tools
net/http · Cobra
Layer 02
Kubernetes
Controllers, reconcilers, resource watches, operators
client-go
Layer 03
Cloud
Provisioning, automation, and service integrations
AWS SDK v2
Phase 04 · Weeks 9–10

Testing, Performance & Production Code

Verification, profiling, and code reading.
Finish by learning how production Go code is structured and verified. Table-driven tests, subtests, benchmarks, profiling, and large codebase reading are the habits that distinguish toy knowledge from useful engineering skill.
Read
  • testing package ↗ Table-driven tests, subtests, examples, and benchmarks.
  • pprof ↗ Profiling and performance analysis for CPU and memory behaviour.
Production Checklist
  • Write table-driven tests with subtests for a real package
  • Run a benchmark and compare two implementations
  • Capture and inspect a pprof profile
  • Read production Go code and trace a request path end to end
  • Notice common patterns in error handling, context usage, and interfaces
Read Production Code
RepositoryWhat to Learn
kubernetes/kubernetesAPI machinery, controllers, package boundaries, large-scale Go organisation
moby/mobyInterfaces, error handling, service wiring, and systems programming style
hashicorp/terraformCLI design, SDK integration, and package layout for large tools
prometheus/prometheusConcurrency patterns, interfaces, and performance-sensitive code paths
All Links

Resources

Language
Tour of Go ↗ The fastest path through core syntax and language primitives. Effective Go ↗ Idioms, conventions, and API design principles. Code Review Comments ↗ The closest thing to production review defaults for Go.
Standard Library
pkg.go.dev/std ↗ Reference for the standard library. Spend time here. net/http ↗ Handlers, clients, middleware, and server lifecycle. testing ↗ Tests, benchmarks, examples, and profiling hooks.
Tooling
flag ↗ Minimal built-in CLI argument parsing. Cobra ↗ Structured CLI applications with commands and help generation. Viper ↗ Configuration loading across files, flags, and environment variables.
Platform
client-go ↗ Kubernetes API clients, watches, and controller patterns. AWS SDK for Go v2 ↗ Cloud integrations for S3, EC2, IAM, and more. pprof ↗ Performance and runtime profiling toolkit.
Optional Routers
chi ↗ Lightweight and idiomatic router for HTTP services. echo ↗ More batteries included if you want framework ergonomics.
Production Repos
kubernetes/kubernetes ↗ Controllers, API machinery, and large-scale package organisation. moby/moby ↗ Systems programming style and runtime interfaces. hashicorp/terraform ↗ CLI architecture and provider integration patterns. prometheus/prometheus ↗ Concurrency, storage, and performance-sensitive Go code.