uber-go/guide
Guide
This project is a collection of guidelines and best practices for the Go programming language, providing a comprehensive style guide and set of programming standards. It establishes a framework for writing maintainable and performant source code through standardized naming, structuring, and organizational conventions.
The guide focuses on specific patterns for concurrency, error handling, and performance optimization. It details methods for managing goroutine lifecycles to prevent race conditions, designing structured error wrapping and routing to maintain observability, and implementing memory allocation strategies to reduce garbage collection overhead.
The architectural guidance covers API design through dependency injection, functional options, and implementation encapsulation to ensure extensibility and testability. Quality assurance workflows are addressed through the use of table-driven testing, compile-time interface verification, and the integration of static analysis and linting tools.
Features
- Go Ecosystem Conventions - Establishes standardized naming, structuring, and organizational conventions for consistency across large Go codebases.
- Concurrent Programming Patterns - Defines architectural patterns for concurrent programming to ensure data consistency and safety.
- Coding Style Guides - Provides a comprehensive set of standardized coding conventions and best practices for writing maintainable Go source code.
- Go Idioms & Patterns - Provides idiomatic Go patterns for managing goroutine lifecycles and concurrent primitives.
- Go Performance Optimization - Offers strategies for efficient primitive conversions and container capacity management.
- Type Encapsulation - Details how to hide internal implementation details to maintain flexible and stable public APIs.
- Error Handling - Provides a structured framework for designing, wrapping, and routing errors to maintain stability and observability.
- Error Handling Strategies - Implements a structured approach to error wrapping and reporting to maintain observability.
- Linear - Establishes a standard for shallow logic paths by prioritizing immediate error handling.
- Functional Options - Describes the use of variadic functions to implement the functional options pattern for extensible API configuration.
- Go API Architecture Design - Provides a comprehensive framework for designing testable and extensible Go APIs.
- Dependency Injection - Provides guidelines on using structs and interfaces for dependency injection to improve testability and modularity.
- Language Performance Optimization - Offers detailed recommendations for reducing memory allocations and optimizing primitive conversions to improve execution speed.
- Goroutine Leak Prevention - Outlines signal mechanisms and exit strategies to prevent goroutine leaks.
- Module Encapsulation Patterns - Provides patterns for preventing public implementation leakage by encapsulating internal types within public structs.
- Slab-Based Pre-allocation - Implements memory allocation strategies such as specifying initial capacities to reduce garbage collection overhead.
- Table-Driven Tests - Promotes the use of table-driven tests to increase code reliability and coverage.
- Atomic Memory Operations - Provides guidance on using atomic types to ensure thread-safe memory access without locks.
- Slab-Based Memory Pre-allocation - Recommends memory pre-allocation strategies to reduce garbage collection overhead.
- Compile-Time Interface Verification - Explains how to use zero-value interface variables to catch implementation gaps at compile time.
- Deferred Execution - Explains the use of the defer keyword to ensure timely release of files, locks, and other system resources.
- Primitive Conversion Optimizations - Provides specialized conversion tools to transform primitive values into strings more efficiently than general formatting functions.
- Custom Error Definitions - Details the design of static, dynamic, and custom error types for better contextual failure information.
- Error Contextualization - Explains how to use format verbs to wrap errors with descriptive context while preserving the error chain.
- Error Routing Logic - Provides a strategy for error routing to prevent noise in application logs.
- Error Recovery - Emphasizes returning errors over triggering panics to ensure predictable application recovery.
- Static Analysis - Integrates static analysis and linting tools to detect common coding mistakes and enforce consistent styling.
- Static Code Analysis - Advocates for the use of automated linting and static analysis to ensure consistent coding style.
- Coding Standards - Uber Go coding style guide.
- Language Style Guides - Opinionated style and engineering standards for Go projects.
- Programming Language Standards - Patterns and conventions for idiomatic Go code.
