Go

Trace Go from its systems-programming roots through Go 1, the compatibility promise, modules, cloud-native adoption, generics, and recent language changes. Connect the language’s history to its emphasis on simplicity, fast builds, concurrency, and dependable tooling.

Work with identifiers, declarations, zero values, constants, built-in types, operators, type inference, conversions, and formatted output. Use Go’s static type system to catch mistakes before a program runs.

Control execution with if, switch, for, range, break, continue, and defer. Build small programs that validate input, repeat work, and handle multiple cases clearly.

Define functions with parameters, multiple return values, named results, variadic arguments, and function values. Practice decomposition, scope, closures, recursion, and straightforward API design.

Handle UTF-8 text correctly using strings, bytes, and runes. Apply the strings, bytes, strconv, and unicode packages to search, convert, normalize, and process text without corrupting characters.

Create fixed-size arrays and flexible slices, then use indexing, slicing, append, copy, and multidimensional layouts. Reason about length, capacity, shared backing arrays, and common aliasing mistakes.

Store and retrieve keyed data with maps, test whether keys exist, delete entries, and count or group values. Account for unordered iteration, nil maps, and reference-like behavior.

Model domain data with structs, field tags, embedding, and composition. Compare values, copy records, control field visibility, and choose representations that keep invalid states out.

Use addresses, dereferencing, pointer parameters, new, and heap allocation without manual memory management. Distinguish value and pointer semantics and recognize when mutation or copying is intended.

Attach behavior to named types with methods and select value or pointer receivers deliberately. Build small domain APIs whose operations and state belong together.

Define and satisfy interfaces implicitly, use type assertions and type switches, and keep interfaces focused on caller needs. Apply standard interfaces such as Stringer, Reader, Writer, and error.

Represent expected failures with error values, wrap causes, inspect error chains, and create typed or sentinel errors when callers need decisions. Reserve panic and recover for appropriate boundary and invariant failures.

Organize code into packages with clear exported APIs, internal packages, documentation comments, initialization rules, and import boundaries. Refactor a single-file program into a maintainable package layout.

Create modules, select dependency versions, work with semantic import versioning, and maintain go.mod and go.sum. Use module proxies, vendoring, replace directives, workspaces, and toolchain selection for dependable multi-module development.

Write reusable functions and data structures with type parameters, constraints, approximation elements, and type inference. Decide when generics improve an API and when interfaces or concrete code remain clearer.

Consume and create iterator functions using modern range-over-function patterns. Design lazy sequences, early termination, adapters, and collection helpers while accounting for Go version compatibility.

Compose streaming operations with io.Reader, io.Writer, buffering, pipes, limits, and copying. Build memory-efficient transformations that work with files, network connections, compressed data, and in-memory buffers.

Read, write, traverse, and modify files and directories with os, io/fs, and filepath. Handle permissions, temporary files, atomic replacement, embedded files, and cross-platform path rules.

Encode and decode JSON, XML, CSV, binary records, and URL values using standard interfaces and struct tags. Validate untrusted input and handle schema changes, missing fields, and streaming data.

Work safely with durations, timestamps, timers, tickers, time zones, and parsing layouts. Avoid common errors involving local time, daylight-saving changes, monotonic clocks, and timer cleanup.

Write unit tests with the testing package, table-driven cases, subtests, helpers, examples, and testable package boundaries. Use fakes and small interfaces instead of tightly coupled dependencies.

Use Go’s built-in fuzzing support to generate unexpected inputs and preserve failures as regression cases. Define useful properties, control the fuzzing corpus, and apply fuzzing to parsers, encoders, and boundary-heavy APIs.

Measure code with benchmarks, allocation reports, execution traces, and CPU, memory, mutex, and blocking profiles. Turn measurements into focused experiments rather than guessing about performance.

Start concurrent work with goroutines and reason about lifetime, scheduling, blocking, and ownership. Convert sequential tasks into bounded concurrent work without losing errors or leaking resources.

Coordinate goroutines with typed channels, directional channels, select, buffering, closing, and fan-in or fan-out patterns. Apply ownership rules that prevent sends on closed channels and stranded workers.

Protect shared state with mutexes, read-write mutexes, once values, condition variables, wait groups, and atomic operations. Use the Go memory model and happens-before relationships to judge whether concurrent code is correct.

Carry deadlines, cancellation, and request-scoped values across API boundaries with context.Context. Build operations that stop promptly and release resources when callers disconnect or time out.

Find data races with the race detector and diagnose deadlocks, starvation, goroutine leaks, and unsafe shutdown sequences. Implement bounded worker pools, backpressure, error groups, and graceful termination.

Connect source code to stack growth, escape analysis, garbage collection, goroutine scheduling, and interface representation. Use compiler diagnostics and runtime metrics to explain allocations, pauses, and scheduling behavior.

Create TCP, UDP, Unix-socket, and DNS-aware programs with the net package. Add deadlines, connection management, framing, and TLS certificate validation to a small network protocol.

Send requests with net/http, construct URLs and headers safely, stream bodies, reuse transports, and enforce timeouts. Handle redirects, cookies, retries, rate limits, and response cleanup in resilient clients.

Build HTTP servers with handlers, routing, middleware, forms, templates, static assets, and structured responses. Apply request limits, graceful shutdown, authentication boundaries, and server timeouts.

Design resource-oriented JSON APIs with stable schemas, status codes, pagination, filtering, idempotency, and versioning. Produce useful error responses and verify behavior with contract and integration tests.

Implement full-duplex communication with WebSockets and server-sent events. Manage connection lifetimes, heartbeats, message limits, backpressure, and concurrent readers and writers.

Access relational databases through database/sql using parameterized queries, prepared statements, transactions, connection pools, and nullable values. Test repository code and handle cancellation, migrations, isolation, and partial failure.

Define typed service contracts with Protocol Buffers and build unary and streaming RPC services with gRPC. Add deadlines, interceptors, status errors, compatibility rules, authentication, and service testing.

Create command-line programs with flags, subcommands, standard streams, exit codes, configuration, and shell-friendly output. Package a practical CLI with clear errors, completion support, and cross-platform behavior.

Interact with environment variables, processes, signals, terminals, and operating-system services. Implement signal-aware shutdown and manage child processes without leaving resources behind.

Use reflection for metadata-driven code while preserving type safety at public boundaries. Compare reflection with source generation, go generate, templates, and compiler-based analysis for repetitive or schema-driven work.

Recognize when unsafe operations or native interoperability are justified and isolate them behind tested APIs. Work with unsafe.Pointer, memory layout, cgo ownership rules, callbacks, and the performance and deployment costs of C dependencies.

Cross-compile Go programs, apply build constraints, inject release metadata, and produce reproducible binaries. Choose static or dynamic linking appropriately and publish archives, checksums, and signed release artifacts.

Produce machine-readable logs with log/slog, propagate trace and request identifiers, and expose useful metrics. Connect logs, metrics, traces, runtime profiles, and health endpoints to diagnose a running service.

Protect Go applications against injection, path traversal, request smuggling, denial of service, weak randomness, insecure TLS, and accidental secret exposure. Apply input limits, secure defaults, dependency review, and security-focused tests.

Audit modules, verify checksums and provenance, generate software bills of materials, and respond to vulnerability reports with Go security tools. Harden CI against compromised dependencies, build scripts, credentials, and artifact tampering.

Design package boundaries, dependency direction, configuration flow, and interfaces for changeable external systems. Apply layered and hexagonal patterns selectively while keeping ordinary Go code direct and readable.

Carry a service from requirements and data modeling through package design, implementation, migrations, tests, API documentation, review, and release. Validate behavior under failure, cancellation, concurrency, and realistic load before delivery.

Package a Go service in a minimal container image using multi-stage builds and non-root execution. Configure health checks, resource limits, shutdown behavior, networking, and local multi-service development.

Run Go services in Kubernetes using declarative workloads, Services, configuration, secrets, probes, resource requests, and autoscaling. Account for pod termination, retries, leader election, controllers, and the operational patterns common in cloud-native Go systems.

Compile Go programs for WebAssembly and interact with browser or host environments through supported APIs. Handle startup size, asynchronous calls, portability limits, and testing across native and WebAssembly targets.

Build Go software for small devices using constrained runtimes such as TinyGo. Work within limits on memory, garbage collection, peripherals, interrupts, timing, and hardware-dependent testing.

Use measured evidence to reduce allocations, improve locality, control concurrency, batch work, and tune network or database paths. Balance latency, throughput, memory, readability, and operational cost without relying on folklore.

Use formatting, vet, static analysis, linters, test coverage, race checks, and CI gates as one feedback system. Review Go code for API clarity, error behavior, cancellation, concurrency safety, compatibility, and maintainability.

Use AI coding assistants for Go scaffolding, tests, refactoring, and documentation while treating generated output as untrusted. Verify API availability, concurrency behavior, security, licenses, and performance with documentation, review, and automated checks.

Map Go skills to backend, platform, cloud infrastructure, networking, security, data, embedded, and developer-tooling roles. Build proof-of-skill projects, contribute to open source, prepare for technical interviews, evaluate optional certifications, and follow release notes, proposals, security advisories, and community resources.