Learning-Go

A 60-day roadmap from zero to advanced Go. Aim for 1–2 hours per day: read, code along, then do the exercise. Each day gets its own folder (day-1, day-2, ...).

Phase 1: Foundations (Days 1–10)

• Day 1 – Install Go, set up the editor, go run, go build, Hello World, how a Go program is structured (package main, func main)
• Day 2 – Variables, constants, basic types, zero values, type conversion, fmt printing
• Day 3 – Operators, if/else, switch, user input with fmt.Scan/bufio
• Day 4 – Loops: for (all forms), break, continue, labels, range
• Day 5 – Functions: parameters, multiple returns, named returns, variadic functions
• Day 6 – Functions deep-dive: first-class functions, closures, anonymous functions, defer
• Day 7 – Arrays and slices: length, capacity, append, copy, slicing
• Day 8 – Maps: create, read, delete, check existence, iterate; slices of maps
• Day 9 – Strings, runes, bytes, strings, strconv, unicode packages
• Day 10 – Mini project: CLI calculator or number-guessing game. Review of Phase 1

Phase 2: Core Language (Days 11–20)

• Day 11 – Pointers: &, *, pass by value vs reference, new
• Day 12 – Structs: fields, methods, embedding, struct tags
• Day 13 – Methods: value vs pointer receivers, method sets
• Day 14 – Interfaces: implicit implementation, empty interface, any
• Day 15 – Interfaces deep-dive: type assertions, type switches, Stringer, common stdlib interfaces
• Day 16 – Error handling: error interface, custom errors, errors.New, fmt.Errorf with %w
• Day 17 – Error handling deep-dive: errors.Is, errors.As, panic, recover
• Day 18 – Packages and modules: go mod init, imports, exported vs unexported, go get, go mod tidy
• Day 19 – Project layout: multi-package projects, internal/, cmd/, init functions
• Day 20 – Mini project: to-do list CLI app with structs, slices, and JSON file storage

Phase 3: Intermediate Go (Days 21–32)

• Day 21 – Generics: type parameters, constraints, generic functions
• Day 22 – Generics deep-dive: generic types, comparable, cmp, slices and maps packages
• Day 23 – Standard library tour: os, io, bufio, reading and writing files
• Day 24 – encoding/json: marshal, unmarshal, struct tags, custom marshalers
• Day 25 – time package: durations, formatting, timers, tickers
• Day 26 – flag, environment variables, log and log/slog (structured logging)
• Day 27 – Testing basics: go test, table-driven tests, t.Run, t.Helper
• Day 28 – Testing deep-dive: coverage, benchmarks, examples, fuzzing, testify (optional)
• Day 29 – Mocking and testing with interfaces, httptest, test fixtures
• Day 30 – Tooling: go fmt, go vet, golangci-lint, go doc, go generate
• Day 31 – Regular expressions, text/template, html/template
• Day 32 – Mini project: CLI tool (e.g., file organizer or log parser) with tests

Phase 4: Concurrency (Days 33–42)

• Day 33 – Goroutines: concepts, go keyword, the scheduler (GMP model)
• Day 34 – sync.WaitGroup, race conditions, the race detector (go run -race)
• Day 35 – Channels: unbuffered vs buffered, send/receive, closing, range over channels
• Day 36 – select: multiplexing, timeouts, default case, non-blocking operations
• Day 37 – sync.Mutex, RWMutex, sync.Once, sync/atomic
• Day 38 – context: cancellation, deadlines, timeouts, passing values
• Day 39 – Concurrency patterns: worker pool, fan-out/fan-in, pipeline
• Day 40 – More patterns: rate limiting, semaphores, errgroup, sync.Pool, sync.Map
• Day 41 – Common concurrency bugs: deadlocks, goroutine leaks, data races, and how to debug them
• Day 42 – Mini project: concurrent web crawler or parallel file processor

Phase 5: Web and Databases (Days 43–52)

• Day 43 – net/http: HTTP client and server, handlers, ServeMux (Go 1.22+ routing)
• Day 44 – Building a REST API: routing, JSON request/response, status codes
• Day 45 – Middleware: logging, recovery, auth, CORS; request context
• Day 46 – Routers and frameworks: chi or gin; validation; project structure
• Day 47 – SQL with database/sql: connections, queries, prepared statements, transactions
• Day 48 – PostgreSQL with pgx, migrations (golang-migrate), sqlc or GORM
• Day 49 – Authentication: password hashing (bcrypt), JWT, sessions
• Day 50 – Configuration, graceful shutdown, Docker, and Dockerfile for Go
• Day 51 – Caching with Redis, background jobs, and queues
• Day 52 – Mini project: full REST API (users, auth, CRUD) with Postgres and tests

Phase 6: Advanced Go (Days 53–60)

• Day 53 – gRPC and Protocol Buffers
• Day 54 – Reflection (reflect), unsafe, and when not to use them
• Day 55 – Memory model: stack vs heap, escape analysis, garbage collector internals
• Day 56 – Profiling and optimization: pprof, go tool trace, benchmarks, benchstat
• Day 57 – Design patterns in Go, clean/hexagonal architecture, dependency injection
• Day 58 – Observability: metrics (Prometheus), tracing (OpenTelemetry), structured logs
• Day 59 – Cross-compilation, build tags, CI/CD with GitHub Actions, releasing binaries
• Day 60 – Capstone project: production-grade service (API + DB + concurrency + tests + Docker + CI)

After Day 60

• Read the Go source code of popular libraries (net/http, chi, cobra)
• Contribute to an open-source Go project
• Build: a key-value store, a load balancer, a CLI with cobra, a message queue
• Read: The Go Programming Language (Donovan & Kernighan), Concurrency in Go (Katherine Cox-Buday), 100 Go Mistakes (Teiva Harsanyi)

Resources

• A Tour of Go
• Go by Example
• Effective Go
• Go Standard Library Docs
• Go Blog