Sources
Canonical source catalog for the site. Generated from data/sources.toml. Do not edit manually.
Community
- Basics tutorial - Official gRPC tutorial for Go covering service definitions, handlers, clients, and streaming RPCs.
- Being confused about nil vs. empty slice (#22) - Official 100go entry on API and encoding differences between
niland empty slices. - Error comparison pitfalls (#50-51) - Official 100go coverage of mistakes #50-51; the anchor points at #50 and the adjacent section covers both typed and value-based error comparison pitfalls.
- Forgetting about sync.Cond (#72) - Official 100go entry on cases where condition variables are cleaner than channels or polling.
- How to parse a JSON request body in Go - Practical request-body decoding guidance that complements
encoding/jsondocs with operational checks. - Ignoring when to wrap an error (#49) - Official 100go entry on adding context without destroying the ability to inspect the original failure.
- Misusing init functions (#3) - Official 100go entry on keeping
initrare, predictable, and free of hidden application logic. - Misusing sync.WaitGroup (#71) - Official 100go entry on correct add/done/wait ownership and lifecycle for
sync.WaitGroup. - Named result parameters (#43-44) - Official 100go coverage of mistakes #43-44; the anchor points at #43 and the adjacent section covers defer-driven side effects with named results.
- Neglecting integer overflows (#18) - Official 100go entry on treating integer overflow as a real correctness concern in counters, sizes, and arithmetic.
- Not using errgroup (#73) - Official 100go entry on preferring error-aware goroutine orchestration over ad hoc WaitGroup plus channel plumbing.
- Not using fuzzing (community mistake) - Official 100go entry on using fuzzing to uncover edge cases that table tests did not anticipate.
- Not using linters (#16) - Official 100go entry on using automated analysis to catch common correctness and maintainability issues early.
- Not using test execution modes (#84) - Official 100go entry on using parallelism and shuffle deliberately to expose hidden coupling in tests.
- Not using the functional options pattern (#11) - Official 100go entry on when functional options improve API ergonomics over sprawling constructors.
- Providing a wrong time duration (#75) - Official 100go entry on duration unit mistakes that silently turn milliseconds into nanoseconds.
- Quick start - Official gRPC quickstart for Go covering generated code, server startup, and client calls.
- Range loop pitfalls (#30-32) - Official 100go coverage of mistakes #30-32; the anchor points at #30 but the page section also covers range evaluation and pointer-related loop pitfalls.
- time.After and memory leaks (#76) - Official 100go entry on timer allocation and cancellation pitfalls when
time.Afteris used repeatedly. - Unintended variable shadowing (#1) - Official 100go entry highlighting how shadowed identifiers quietly change control flow and error handling.
Primary
- A Guide to the Go Garbage Collector - Practical guide to GC cost model, pacing, memory limits, and tuning decisions in Go.
- Advanced Go Concurrency Patterns - Higher-level concurrency patterns and debugging techniques beyond basic goroutine/channel usage.
- An Introduction To Generics - Introduces type parameters, constraints, and the core problem space generics are meant to solve.
- cgo - Practical cgo usage notes, caveats, and examples that complement the formal package docs.
- cmd/cgo - Canonical docs for cgo directives, generated bindings, and interoperability constraints.
- cmd/vet - Official docs for
go vetanalyzers that catch suspicious constructs before they ship. - Code coverage for Go integration tests - Official guide for collecting and interpreting Go coverage across packages and integration-style runs.
- Compiler Optimizations - Official Go wiki page describing compiler optimizations including escape analysis and inlining.
- Concurrency is not parallelism - Conceptual framing for Go concurrency: structuring work, not merely running things simultaneously.
- Data Race Detector - Official guide to race detector behavior, usage, reports, and practical limitations.
- database/sql package - Canonical docs for SQL DB handles, queries, transactions, pooling, and context-aware operations.
- Defer, Panic, and Recover - Canonical explanation of
defer,panic,recover, and where each belongs in Go code. - Diagnostics - Official overview of Go profiling, tracing, benchmarking, and runtime diagnostic tooling.
- Effective Go - Idiomatic guidance on Go style, control flow, interfaces, methods, and core library usage.
- embed package - Canonical docs for the //go:embed directive and the embed.FS file system.
- encoding/json package - Canonical docs for JSON marshaling, decoding, token streams, tags, and decoder behavior.
- Errors are values - Frames Go error handling as explicit value-oriented control flow rather than exceptions.
- errors package - Canonical docs for sentinels, wrapping, joining, and error inspection via
errors.Isanderrors.As. - Finding and fixing known vulnerabilities in Go - Official guide for vulnerability detection, interpretation, and remediation in Go code and dependencies.
- Fuzzing - Official guide to Go fuzzing, corpus management, and when fuzz targets add value beyond table tests.
- Getting to Go: The Journey of Go’s Garbage Collector - Historical and architectural background on how Go’s GC evolved toward lower latency.
- Go Code Review Comments - Short, practical Go review guidance covering naming, interfaces, errors, comments, and API design.
- go command - Authoritative documentation for the go command, including generate, workspace maintenance, package visibility rules, testing conventions, and vendoring commands.
- Go Concurrency Patterns: Context - Defines idiomatic
context.Contextpropagation, cancellation, deadlines, and request scoping. - Go Concurrency Patterns: Pipelines and cancellation - Practical patterns for pipeline stages, goroutine shutdown, fan-out/fan-in, and cancellation.
- Go Data Structures: Interfaces - Deep explanation of interface representation, dynamic type/value pairs, and nil behavior.
- Go Doc Comments - Canonical rules for package, type, function, and field documentation comments in Go.
- Go Modules Reference - Canonical reference for module files, version selection, workspaces, replacements, vendoring, and module download behavior.
- Go Modules: v2 and Beyond - Explains semantic import versioning and how Go modules handle major version changes.
- go test flags - Official documentation for
go testexecution flags including-run,-shuffle,-short, and parallelism controls. - go/build/constraint package - Canonical docs for parsing and reasoning about Go build constraints.
- Godoc: documenting Go code - Explains how package structure and prose affect generated Go documentation quality.
- golang.org/x/sync/errgroup package - Official package docs for bounded goroutine groups that propagate cancellation and the first error.
- govulncheck command - Reference docs for the official govulncheck command and its analysis modes.
- Introducing the Go Race Detector - Background and practical examples for using the Go race detector in development workflows.
- io package - Canonical docs for Reader, Writer, Copy, pipe, and stream-oriented interfaces in Go.
- Keeping Your Modules Compatible - Guidance on evolving public Go APIs without unnecessary breaking module releases.
- log/slog package - Canonical docs for structured logging with handlers, attributes, groups, and logger composition.
- net/http package - Canonical package docs for HTTP servers, handlers, transports, clients, and request lifecycles.
- Organizing Go code - Guidance on package boundaries, repositories, commands, and library/application layout in Go.
- Package names - Explains the design pressure behind short, clear, non-stuttering Go package names.
- Profile-guided optimization - Official guide for when and how to use Go profile-guided optimization.
- Profiling Go Programs - Teaches disciplined CPU and memory profiling before guessing about performance problems.
- reflect package - Canonical docs for reflection, struct tags, dynamic types, and runtime type inspection.
- Structured Logging with slog - Explains the design goals and usage patterns behind Go’s structured logging package.
- sync package - Canonical docs for mutexes, condition variables, pools, once, maps, and synchronization primitives.
- sync/atomic package - Package docs for low-level atomic operations and typed atomic values in Go.
- TableDrivenTests - Short practical reference for idiomatic table-driven test structure in Go.
- testing package - Canonical package docs for tests, benchmarks, fuzzing, subtests, and helper APIs.
- testing/synctest package - Package docs for deterministic testing of concurrent code using bubbles and fake time.
- The Go Memory Model - Defines happens-before, synchronization, and what concurrent Go programs may safely assume.
- The Go Programming Language Specification - Language specification for syntax, types, declarations, statements, packages, and core semantics.
- The Green Tea Garbage Collector - Explains recent garbage collector design changes and what they improve in real workloads.
- time package - Canonical docs for durations, timers, tickers, deadlines, and monotonic time behavior.
- unsafe package - Defines the unsafe operations Go permits and the narrow rules around pointer conversion.
- Using Go Modules - Introductory guide to module basics, dependency management, and repository setup.
- vgo: Import Compatibility Rule - Defines the import compatibility rule underlying Go module versioning and API evolution.
- When To Use Generics - Decision guide for when generics help versus when interfaces or plain code are better.
- Why is my nil error value not equal to nil? - Concise FAQ entry explaining typed nil values stored in interfaces, especially
error. - Working with Errors in Go 1.13 - Explains the intended use of
%w,errors.Is,errors.As, and wrapper error conventions.