Go Programming Language

Install Go, understand GOPATH vs Go modules, and learn the core CLI commands like go run, go build, go mod init, and go fmt that form your daily workflow.

Learn Go's type system including integers, floats, strings, booleans, and runes, along with variable declarations using var and short assignment, constants, and basic operators.

Master if/else statements, for loops (Go's only loop construct), switch statements with expression and type switches, and defer statements for cleanup logic.

Understand function declarations, multiple return values (Go's signature pattern), named returns, variadic functions, and first-class functions as values.

Understand the difference between fixed-size arrays and dynamically-sized slices, how slices reference underlying arrays, and operations like append, copy, and slice expressions.

Learn how to create, read, update, and delete entries in Go's built-in hash map type, including the comma-ok idiom for checking key existence.

Define custom types with structs, attach methods using receiver functions, and understand the difference between value receivers and pointer receivers.

Understand how pointers work in Go, when to pass by pointer vs by value, the new() built-in, and why Go has no pointer arithmetic.

Learn Go's unique approach to interfaces where types satisfy them implicitly, enabling loose coupling and powerful abstractions without inheritance.

Extract concrete types from interface values using type assertions and type switches, and understand the empty interface (any) and its role.

Write type-parameterized functions and types using Go's generics system, understand type constraints, and learn when generics are the right choice vs interfaces.

Use composition over inheritance through Go's embedding mechanism, promoting methods and fields from embedded types to achieve code reuse.

Organize code into packages, understand exported vs unexported identifiers, manage dependencies with Go modules, and learn semantic import versioning.

Master Go's explicit error handling philosophy using the error interface, error wrapping with fmt.Errorf and %w, errors.Is, errors.As, and sentinel errors.

Understand when panics occur, how to recover from them using deferred functions, and why panics should be reserved for truly unrecoverable situations.

Launch lightweight concurrent functions with the go keyword, understand how goroutines are multiplexed onto OS threads, and learn the basics of concurrent execution.

Communicate between goroutines using channels, understand buffered vs unbuffered channels, directional channel types, and the range/close pattern.

Multiplex across multiple channel operations using select, implement timeouts, non-blocking sends and receives, and build fan-in patterns.

Use sync.Mutex, sync.RWMutex, sync.WaitGroup, sync.Once, and sync.Map for scenarios where shared memory is more appropriate than channels.

Implement common patterns like worker pools, pipelines, fan-out/fan-in, cancellation via context.Context, and errgroup for managing groups of goroutines.

Work with io.Reader and io.Writer interfaces, read and write files using os and bufio packages, and understand how Go's I/O abstractions compose.

Marshal and unmarshal JSON with encoding/json, use struct tags for field mapping, handle dynamic JSON with map[string]any, and work with streaming encoders/decoders.

Understand Go's string internals as byte slices, work with the strings and bytes packages, handle Unicode with the unicode/utf8 package, and use strings.Builder for efficient concatenation.

Write unit tests, table-driven tests, and subtests using Go's built-in testing package, and run them with go test including coverage analysis.

Write benchmark functions, use pprof to profile CPU and memory, and identify performance bottlenecks using Go's built-in profiling tools.

Build HTTP servers using Go's standard library, understand the Handler and HandlerFunc patterns, implement middleware, and work with the enhanced routing in Go 1.22+.

Make HTTP requests with net/http.Client, set timeouts and headers, parse response bodies, and handle retries and error responses gracefully.

Connect to SQL databases, execute queries and prepared statements, scan results into structs, manage connection pools, and handle transactions.

Structure Go projects for maintainability, understand the standard project layout conventions, apply dependency injection, and organize code using the repository and service patterns.

Use context.Context for cancellation propagation, timeouts, and request-scoped values across API boundaries and goroutine trees.

Create minimal Docker images with multi-stage builds, cross-compile for different platforms, use build tags, and configure Go services for production with graceful shutdown.