golang

Concurrent Go code uses goroutines (lightweight threads) launched with the `go` keyword and channels for safe communication between them. Channels synchronize goroutines, prevent race conditions, and enable idiomatic patterns like worker pools and fan-out/fan-in. This is Go's core concurrency model for building efficient, scalable applications.

Go's idiomatic error handling returns errors as values, checked explicitly with `if err != nil`. This explicit approach differs from exceptions; it makes error paths visible and forces deliberate handling. Wrap errors with context for debugging, and design functions to fail fast and communicate failure clearly.

Organize Go projects with clear package structure, table-driven tests (test cases as data slices), and comprehensive test coverage. Use `*testing.T` and subtests for maintainable test suites. Document exported types and functions with comment blocks starting with the name, following Go conventions for discoverability and API clarity.

Go modules use `go.mod` and `go.sum` files to declare and lock dependencies. Run `go mod init` to create a module, `go get` to add packages, and `go mod tidy` to clean unused ones. Modules ensure reproducible builds and explicit versioning, eliminating dependency conflicts across Go projects.

Go HTTP servers and clients use `context.Context` to manage request deadlines, cancellation, and values across goroutines. Pass context through request handlers, database calls, and external API calls to enforce timeouts and enable graceful shutdown. Proper context propagation prevents resource leaks and hanging requests.

Go interfaces are implicit and based on method sets, not explicit inheritance. Small, focused interfaces promote composition and loose coupling. Design interfaces around behavior (what a type does), not type hierarchy, enabling flexible, testable code and reducing package dependencies.