React
React Native
Node.js
Python
Rust
PostgreSQL
Solana
Claude
AI Agents
Go

Perguntas frequentes

Seções

Fundamentos e Núcleo Go

Why Go Exists: Simplicity, Readability, and Practical Concurrency Go Philosophy Basics Go's Target Domains: Systems, Cloud-Native, CLIs, and Distributed Services Go vs Rust: Safety, Performance, and Team Velocity Trade-offs Go vs C++, Java, Python, and Node.js Simplicity as a Deliberate Constraint in API Design When Go Is the Wrong Tool Go Philosophy Best Practices

Go's Evolution: From 2007 Origins to Go 1.0 and Beyond Go Releases Basics Major Milestones: Modules, Generics, Workspaces, Fuzzing, and PGO Go 1.26 Highlights: Green Tea GC, go fix Modernizers, and Language Tweaks The Go 1 Compatibility Promise in Practice Go 2 Discussion History and What Actually Shipped Reading Release Notes Like a Tech Lead Planning Go Version Upgrades Across a Monorepo Go History & Releases Best Practices

How Go Programs Are Structured: Packages, main, and the Toolchain Go Fundamentals Basics Variables, Constants & Scope Zero Values and Initialization Numeric Types, Strings, Runes & Byte Slices Arrays, Slices & Maps at a Glance Structs, Embedding & Field Promotion Pointers & the Address-of Operator Go Fundamentals Best Practices

Go's Memory Model: Stack, Heap, and Value Semantics Data Types Basics Slice Internals: Pointer, Len, Cap & Append Map Internals & Hash Table Behavior Struct Alignment, Padding & unsafe.Sizeof Interface Internals: Static Type, Dynamic Type & itables Channel Internals: Buffered vs Unbuffered unsafe Pointers & the unsafe Package Data Types & Memory Model Best Practices

Go Control Flow: Expression-Oriented Design Control Flow Basics for Loop Variants & range Semantics if with Initialization & switch Patterns defer, panic & recover break, continue & Labeled Control Flow range Variable Reuse Pitfalls Control Flow in HTTP Middleware Control Flow Best Practices

Functions and Interfaces: Go's Composition Model Functions & Methods Basics Multiple Returns, Named Returns & Naked Returns Variadic Functions & Function Types Methods: Value vs Pointer Receivers Function Literals & Closures Defining and Implementing Interfaces Nil Interface vs Nil Pointer Functions, Methods & Interfaces Best Practices

Errors as Values: Go's Error Philosophy Error Handling Basics Sentinel Errors & errors.Is Error Wrapping with %w & errors.As Custom Error Types & Error Interfaces Stack Traces with runtime/debug Error Handling in Concurrent Code API Error Design for HTTP and gRPC Services Error Handling Best Practices

Packages and Modules: Go's Unit of Distribution Packages & Modules Basics Package Naming & internal/ Directories go.mod, go.sum & Minimal Version Selection Pseudo-Versions, replace & retract Directives Import Cycles, Blank Imports & Dot Imports go work: Workspace Mode for Multi-Module Repos Standard Project Layout for Services and Libraries Packages, Modules & Project Layout Best Practices

Ferramentas, Qualidade e Craft

The go Command: Build, Test, and Module Lifecycle Go Toolchain Basics go build, run, install & clean go test, list & generate go mod tidy, vendor, download & graph go fix Modernizers & go vet Analyzers Build Tags & Conditional Compilation Cross-Compilation & Private Module Proxies Go Toolchain Best Practices

Go Developer Tooling: LSP, Debugger, and Analyzers Go Tooling Setup Basics gopls: Navigation, Refactoring & Diagnostics Debugging with Delve govulncheck for Dependency Vulnerabilities staticcheck & golangci-lint in CI gosec & nilaway for Security and Nil Safety Writing Custom go/analysis Analyzers gopls & Analysis Tooling Best Practices

Go Testing Culture: Simple, Fast, Table-Driven Go Testing Basics Table-Driven Tests & Subtests testify, httptest & Test Doubles Examples as Executable Documentation Benchmarks with testing.B & B.Loop Fuzz Testing with testing.F Coverage, Race Detector & Golden Files Testing Best Practices

Go Code Quality: Opinionated by Design Code Quality Basics gofmt & goimports Enforcement go vet & Common Analyzer Diagnostics golangci-lint Configuration Pre-commit Hooks & Review Checklists CI Quality Gates: Lint, Test, Race, Vuln Code Review Standards for Go Teams Linting & Code Quality Best Practices

Effective Go as a Living Standard Go Rules Quickstart Effective Go Rules Checklist API Design Rules for Go Libraries Concurrency Rules Checklist Module & Dependency Rules Security Rules for Go Services Performance Rules: When to Optimize Go Rules & Best Practices Summary

Arquitetura, Padrões e Depuração

Architecture in Go: Small Interfaces, Explicit Dependencies Go Architecture Basics Monolith vs Microservices in Go Clean & Hexagonal Architecture in Go Handler-Service-Repository Layering Dependency Injection: wire, dig & Manual Wiring Architecture Decision Records for Go Teams Refactoring & Architecture Audit Checklist Architecture & Design Best Practices

Go Idioms: Composition Over Inheritance Go Patterns Basics Functional Options Pattern Constructor Functions & Package APIs Repository & Service Layer Patterns Middleware & Decorator Patterns sync.Once & Singleton Patterns Common Anti-Patterns in Go Codebases Go Patterns & Idioms Best Practices

Debugging Go: Observable Failures and Sharp Edges Go Debugging Basics Nil Interface vs Nil Pointer Defect Walkthrough Slice Header Copy & Append Surprise Range Variable & Goroutine Closure Bugs Time Zone & time.Parse Gotchas Goroutine Leaks & Missing Context Cancellation Data Race Scenarios & race Detector Fixes Debugging & Defect Scenarios Best Practices

Concorrência, Generics e Runtime

Concurrency in Go: Goroutines and Channels First Concurrency Basics Goroutines: Creation Cost & Scheduling Overview Channels: Buffered, Unbuffered & Closing Rules select Statement & Default Cases sync.Mutex, RWMutex & WaitGroup sync.Once, Cond, Pool & sync.Map Race Detector: Running and Interpreting Output Concurrency Fundamentals Best Practices

Production Concurrency: Patterns Beyond Hello Goroutine Advanced Concurrency Basics Worker Pools & Task Queues Fan-In, Fan-Out & Pipeline Stages Rate Limiting & Backpressure errgroup & golang.org/x/sync Extensions sync/atomic Operations Avoiding Goroutine Leaks & Channel Deadlocks Advanced Concurrency Best Practices

context.Context: Cancellation as a First-Class API context Basics Cancellation Propagation in HTTP Handlers Deadlines & Timeouts Across Service Boundaries context Values: When and When Not context in database/sql & gRPC Testing Code That Accepts context.Context Context Misuse Anti-Patterns context Package Best Practices

Generics in Go: Constraints Without Templates Generics Basics Type Parameters & Constraint Interfaces Type Sets & the comparable Constraint Generic Data Structures: Sets, Queues, Maps Generic Algorithms: slices, maps & cmp Packages Performance Implications of Generics When to Avoid Generics in Go APIs Generics Best Practices

Reflection vs Code Generation in Go Reflection Basics Struct Tags & Custom Tag Parsing Deep Equality & Kind Switches ORM & Serializer Reflection Costs go generate & stringer Building Custom Code Generators go:fix inline & API Migration Directives Reflection & Code Generation Best Practices

Beyond the Spec: Embed, Build Modes, and Assembly Advanced Language Features Basics //go:embed for Files and Templates Build Constraints & Platform-Specific Files Assembly in Go (*.s files)Linker Flags & buildmode Options Plugin Packages & Dynamic Loading Compiler Directives: //go:noinline, linkname & go:fix inline Advanced Language Features Best Practices

CGO: Crossing the Go-C Boundary CGO Basics Calling C from Go & Exporting Go to C CGO Performance & Scheduler Interactions syscall & Pure-Go Alternatives to CGO FFI Safety: Pointers, C.CString & Free WebAssembly Overview (see WebAssembly & TinyGo section)Interop Decision Guide: CGO vs RPC vs Rewrite CGO & Interoperability Best Practices

The Go Runtime: Scheduler, GC, and Memory Runtime Basics Garbage Collector: Tri-Color Mark-Sweep & Pacing Green Tea GC & GOEXPERIMENT Flags (Go 1.26)Escape Analysis & Stack vs Heap Allocation GOGC, GOMEMLIMIT & Finalizers Goroutine Stacks & Stack Growth Memory Leaks in Go: Common Causes Runtime & GC Best Practices

Web, Dados e Serviços em Produção

net/http: Go's Batteries-Included HTTP Stack net/http Basics HTTP Servers, Handlers & ServeMux Patterns HTTP Clients, Transport & Connection Pooling Middleware Chains & Request Context HTTP/2, Timeouts & ReverseProxy httptest for Handler Integration Tests Production net/http Configuration Checklist net/http Best Practices

Go HTTP Frameworks: Routers vs Full Frameworks Web Frameworks Basics chi: Lightweight Routing & Middleware gorilla/mux: Regex Routes & Host Matching Gin: Fast JSON APIs & Binding Echo: Middleware Ecosystem & Context Wrapper Framework Selection Decision Guide Migrating Between Routers Without Rewriting Handlers Web Frameworks Best Practices

gRPC in Go: Contracts, Streaming, and Performance gRPC Basics Protocol Buffers Schema Design Unary, Streaming & Bidirectional RPCs gRPC Middleware, Interceptors & Metadata gRPC Error Codes & Status Mapping REST vs gRPC Trade-off Guide gRPC Gateway & JSON Transcoding gRPC Best Practices

Data Access in Go: database/sql as the Foundation Databases Basics database/sql Connection Pooling & Timeouts Transactions, Prepared Statements & sql.Tx GORM vs sqlx vs Raw database/sql Migrations with golang-migrate & goose Redis Caching & NATS/Kafka Messaging embed for SQL Migrations & Seed Data Databases & Data Access Best Practices

Serialization in Go: JSON First, Formats on Demand Serialization Basics encoding/json Custom Marshaling encoding/xml, gob & Binary Formats Struct Tags for JSON, DB & Validation Schema Evolution & Unknown Field Handling High-Performance JSON: jsoniter & sonic Alternatives Validation with go-playground/validator Serialization Best Practices

CLI Design in Go: Single Binary, Fast Startup CLI Tools Basics flag Package & POSIX-Style Flags cobra & urfave/cli Command Trees kingpin & Advanced CLI UX Configuration: Viper, Env & Config Files bubbletea Terminal UI & Progress Bars Color Output & User-Friendly Errors CLI Tools Best Practices

Production Go: Logs, Metrics, Traces, and Signals Observability Basics Structured Logging with slog Prometheus Metrics & RED/USE Dashboards OpenTelemetry Tracing in Go Services Health, Readiness & Liveness Probes Graceful Shutdown & Signal Handling Configuration Management: Env, Flags & Viper Observability Best Practices

Security for Go Services: Defaults and Gaps Go Security Basics crypto/tls Configuration & Certificate Management Input Validation & Safe HTML/JSON Handling Authentication & Authorization Patterns Rate Limiting, CORS & Security Headers Secure Cookies & CSRF for Web Apps Dependency Scanning with govulncheck & SBOM Security Best Practices Summary

Performance, Stdlib e Ecossistema

Performance in Go: Measure, Profile, Then Optimize Performance Basics CPU & Heap Profiling with pprof trace & Execution Tracer Escape Analysis & Compiler Optimizations Slice Preallocation, strings.Builder & map Pre-sizing Profile-Guided Optimization (PGO)GC Tuning for Latency-Sensitive Services Performance Best Practices

The Go Standard Library: Batteries Included Standard Library Basics os, io, bufio & path/filepath time, timezones & context Integration crypto/*, compress & math/rand/v2 log, regexp & text/template runtime, debug & pprof Packages database/sql & net Package Family Overview Standard Library Best Practices

The Go Ecosystem: Small, Focused Libraries Essential Libraries Basics Logging: zap vs zerolog vs slog Configuration with viper & envconfig Testing with testify & mockery Dependency Injection with google/wire Validation, migrate & sqlc Prometheus & OpenTelemetry Client Libraries Essential Go Libraries Best Practices

Deploying Go: Single Binary as a Superpower Deployment Basics Multi-Stage Docker Builds for Go Kubernetes Deployments, Services & Ingress Probes, HPA & Pod Disruption Budgets CI/CD Pipelines for Go Services Chaos Engineering Hooks for Go Microservices Single-Binary Edge & Air-Gapped Deployments Deployment Best Practices

Why Go Dominates the Kubernetes Operator Ecosystem Kubernetes Operators Basics controller-runtime Manager, Client & Scheme Writing a Reconciler: ctrl.Request & Reconcile Loop CRD Design & kubebuilder Scaffolding Watches, Predicates, Owner References & Finalizers Admission Webhooks: Validating & Mutating in Go Operator Testing with envtest & fake client Leader Election, Metrics & Operator Observability OLM Bundles, Upgrades & Multi-Tenant RBAC Kubernetes Operators Best Practices

Go on WebAssembly: Browser, WASI, and Embedded Paths WebAssembly & TinyGo Basics Compiling with GOOS=wasip1 GOARCH=wasm syscall/js: Go in the Browser WASI Host Runtimes: wasmtime, wazero & Spin TinyGo for Microcontrollers & Constrained WASM WASM Size Optimization: TinyGo vs gc WASM Go 1.26 WASM Runtime & Memory Improvements Native Go vs TinyGo vs Rust WASM Decision Guide WebAssembly & TinyGo Best Practices

Go in the Cloud: Lambda, Cloud Run, and Beyond Cloud Deploy Basics AWS Lambda Custom Runtime & provided.al2023 GCP Cloud Run & AWS Fargate Patterns Azure Functions & Container Apps for Go Secrets, IAM & Workload Identity S3/GCS SDK Patterns with aws-sdk-go-v2 Serverless Go Architecture Decision Guide Cloud & Serverless Best Practices

Agent Skills for Go Teams Agent Skills Basics Go Concurrency Review Skill Go Module & Security Audit Skill Go Performance Profiling Skill Go API Design Review Skill Go Testing & Benchmark Skill Go Kubernetes Operator Review Skill WASM & TinyGo Build Review Skill Agent Skills Best Practices

Git for Go Teams Git Basics for Go Projects Branching Strategies & Trunk-Based Flow Rebasing, Cherry-Pick & Worktrees GitHub Actions for Go Repos Code Review with GitHub PRs Signed Tags & Go Module Releases Monorepo Git Patterns with go work Git & GitHub Best Practices

Linux CLI Skills for Go Engineers Linux CLI Basics Go Toolchain on Linux: Install & Version Switching Build, Test & Profile from the Shell Search, ripgrep & jq for Debugging systemd & Service Unit Files for Go Binaries Containers from the CLI: docker & kubectl Shell Productivity: tmux, fzf & direnv Linux CLI Best Practices

Onboarding Go Specialists Team Onboarding Basics Go SME Onboarding Checklist (30/60/90)Effective Go Reading Path Pairing & Mob Sessions for Go Teams Code Review Culture for Go Leveling Guide: Junior to Staff in Go Documentation & godoc Conventions Team & Onboarding Best Practices

Craft de Tech Lead: Entrega, Liderança e Longevidade

Incident Response for Go Services Production Troubleshooting Basics Live CPU & Heap Profiling Under Incident Load Goroutine Dump & Leak Profile Analysis OOM, GC Storm & Latency Spike Playbooks Database Connection Pool Exhaustion Post-Mortem Template for Go Incidents On-Call Handoff Checklist for Go Platforms Production Troubleshooting Best Practices

Shipping Go Services Safely at Enterprise Scale Enterprise Delivery Basics Release Strategy: Blue-Green & Canary for Go Feature Flags in Go Services Rollback Runbooks for Go Deployments DORA Metrics for Go Teams Progressive Delivery & Automated Verification Change Management & Compliance Gates Enterprise Delivery Best Practices

Technical Leadership in Go Teams Tech Leadership Basics Writing ADRs for Go Architecture Decisions Design Reviews for Go Services Mentoring Go Developers Across Experience Levels Handling Technical Disagreements on Go Teams Tech Debt Backlogs for Go Codebases Staff Engineer Path in Go Organizations Technical Leadership Best Practices

Tech Leads Bridge Engineering and the Business Stakeholder Collaboration Basics From Requirements to Go Service Specs Estimating Go Work: Modules, Risk & Unknowns Prioritizing Features vs Platform Work in Go Communicating Go Trade-offs to Non-Go Stakeholders Risk Registers for Go Migration Projects Release Notes for Internal Go Platform Changes Stakeholder Collaboration Best Practices

Learning from Production Go Systems Case Studies Basics Reference Build: Cloud-Native REST Microservice Reference Build: High-Throughput gRPC Data Plane Reference Build: Production CLI with cobra Reference Build: Kubernetes Operator End-to-End Reference Build: WASI Edge Module with wazero Host Before/After: Refactoring a God Package Benchmark Case Study: JSON API Latency Case Studies Best Practices

Go Community & Long-Term Craft Community & Governance Basics Official Resources: go.dev, pkg.go.dev & Go Blog GopherCon, Meetups & Proposal Tracking Contributing to Go Toolchain & Stdlib Coding Standards & Doc Conventions for Teams Dependency Governance & License Compliance Future-Proofing: Proposals, Experiments & Roadmap Standards, Governance & Community Best Practices

/

/

© 2026 @csjcode|SystemsArchitect.io: Cloud Systems Tools|Termos

Recurso educacional independente e não oficial. Sem afiliação, endosso ou patrocínio dos proprietários ou responsáveis pelas marcas.

Buscar na documentação

Busque em todas as páginas da documentação

#Go445 pages

Pages tagged Go across 49 sections.

Concorrência Avançada

Advanced Concurrency Basics Advanced Concurrency Best Practices Avoiding Goroutine Leaks & Channel Deadlocks errgroup & golang.org/x/sync Extensions Fan-In, Fan-Out & Pipeline Stages Production Concurrency: Patterns Beyond Hello Goroutine Rate Limiting & Backpressure sync/atomic Operations Worker Pools & Task Queues

Recursos Avançados

//go:embed for Files and Templates Advanced Language Features Basics Advanced Language Features Best Practices Assembly in Go (*.s files)Beyond the Spec: Embed, Build Modes, and Assembly Build Constraints & Platform-Specific Files Compiler Directives: //go:noinline, linkname & go:fix inline Linker Flags & buildmode Options Plugin Packages & Dynamic Loading

Habilidades de Agente

Agent Skills Basics Agent Skills Best Practices Agent Skills for Go Teams Go API Design Review Skill Go Concurrency Review Skill Go Kubernetes Operator Review Skill Go Module & Security Audit Skill Go Performance Profiling Skill Go Testing & Benchmark Skill WASM & TinyGo Build Review Skill

Architecture & Design Best Practices Architecture Decision Records for Go Teams Architecture in Go: Small Interfaces, Explicit Dependencies Clean & Hexagonal Architecture in Go Dependency Injection: wire, dig & Manual Wiring Go Architecture Basics Handler-Service-Repository Layering Monolith vs Microservices in Go Refactoring & Architecture Audit Checklist

Estudos de Caso

Before/After: Refactoring a God Package Benchmark Case Study: JSON API Latency Case Studies Basics Case Studies Best Practices Learning from Production Go Systems Reference Build: Cloud-Native REST Microservice Reference Build: High-Throughput gRPC Data Plane Reference Build: Kubernetes Operator End-to-End Reference Build: Production CLI with cobra Reference Build: WASI Edge Module with wazero Host

Calling C from Go & Exporting Go to C CGO & Interoperability Best Practices CGO Basics CGO Performance & Scheduler Interactions CGO: Crossing the Go-C Boundary FFI Safety: Pointers, C.CString & Free Interop Decision Guide: CGO vs RPC vs Rewrite syscall & Pure-Go Alternatives to CGO WebAssembly Overview (see WebAssembly & TinyGo section)

Ferramentas CLI

bubbletea Terminal UI & Progress Bars CLI Design in Go: Single Binary, Fast Startup CLI Tools Basics CLI Tools Best Practices cobra & urfave/cli Command Trees Color Output & User-Friendly Errors Configuration: Viper, Env & Config Files flag Package & POSIX-Style Flags kingpin & Advanced CLI UX

Cloud e Serverless

AWS Lambda Custom Runtime & provided.al2023 Azure Functions & Container Apps for Go Cloud & Serverless Best Practices Cloud Deploy Basics GCP Cloud Run & AWS Fargate Patterns Go in the Cloud: Lambda, Cloud Run, and Beyond S3/GCS SDK Patterns with aws-sdk-go-v2 Secrets, IAM & Workload Identity Serverless Go Architecture Decision Guide

Channels: Buffered, Unbuffered & Closing Rules Concurrency Basics Concurrency Fundamentals Best Practices Concurrency in Go: Goroutines and Channels First Goroutines: Creation Cost & Scheduling Overview Race Detector: Running and Interpreting Output select Statement & Default Cases sync.Mutex, RWMutex & WaitGroup sync.Once, Cond, Pool & sync.Map

Cancellation Propagation in HTTP Handlers context Basics context in database/sql & gRPC Context Misuse Anti-Patterns context Package Best Practices context Values: When and When Not context.Context: Cancellation as a First-Class API Deadlines & Timeouts Across Service Boundaries Testing Code That Accepts context.Context

Fluxo de Controle

break, continue & Labeled Control Flow Control Flow Basics Control Flow Best Practices Control Flow in HTTP Middleware defer, panic & recover for Loop Variants & range Semantics Go Control Flow: Expression-Oriented Design if with Initialization & switch Patterns range Variable Reuse Pitfalls

Tipos e Memória

Channel Internals: Buffered vs Unbuffered Data Types & Memory Model Best Practices Data Types Basics Go's Memory Model: Stack, Heap, and Value Semantics Interface Internals: Static Type, Dynamic Type & itables Map Internals & Hash Table Behavior Slice Internals: Pointer, Len, Cap & Append Struct Alignment, Padding & unsafe.Sizeof unsafe Pointers & the unsafe Package

Bancos de Dados

Data Access in Go: database/sql as the Foundation database/sql Connection Pooling & Timeouts Databases & Data Access Best Practices Databases Basics embed for SQL Migrations & Seed Data GORM vs sqlx vs Raw database/sql Migrations with golang-migrate & goose Redis Caching & NATS/Kafka Messaging Transactions, Prepared Statements & sql.Tx

Cenários de Defeitos

Data Race Scenarios & race Detector Fixes Debugging & Defect Scenarios Best Practices Debugging Go: Observable Failures and Sharp Edges Go Debugging Basics Goroutine Leaks & Missing Context Cancellation Nil Interface vs Nil Pointer Defect Walkthrough Range Variable & Goroutine Closure Bugs Slice Header Copy & Append Surprise Time Zone & time.Parse Gotchas

Chaos Engineering Hooks for Go Microservices CI/CD Pipelines for Go Services Deploying Go: Single Binary as a Superpower Deployment Basics Deployment Best Practices Kubernetes Deployments, Services & Ingress Multi-Stage Docker Builds for Go Probes, HPA & Pod Disruption Budgets Single-Binary Edge & Air-Gapped Deployments

Entrega Empresarial

Change Management & Compliance Gates DORA Metrics for Go Teams Enterprise Delivery Basics Enterprise Delivery Best Practices Feature Flags in Go Services Progressive Delivery & Automated Verification Release Strategy: Blue-Green & Canary for Go Rollback Runbooks for Go Deployments Shipping Go Services Safely at Enterprise Scale

Tratamento de Erros

API Error Design for HTTP and gRPC Services Custom Error Types & Error Interfaces Error Handling Basics Error Handling Best Practices Error Handling in Concurrent Code Error Wrapping with %w & errors.As Errors as Values: Go's Error Philosophy Sentinel Errors & errors.Is Stack Traces with runtime/debug

Bibliotecas Essenciais

Configuration with viper & envconfig Dependency Injection with google/wire Essential Go Libraries Best Practices Essential Libraries Basics Logging: zap vs zerolog vs slog Prometheus & OpenTelemetry Client Libraries Testing with testify & mockery The Go Ecosystem: Small, Focused Libraries Validation, migrate & sqlc

Funções e Interfaces

Defining and Implementing Interfaces Function Literals & Closures Functions & Methods Basics Functions and Interfaces: Go's Composition Model Functions, Methods & Interfaces Best Practices Methods: Value vs Pointer Receivers Multiple Returns, Named Returns & Naked Returns Nil Interface vs Nil Pointer Variadic Functions & Function Types

Generic Algorithms: slices, maps & cmp Packages Generic Data Structures: Sets, Queues, Maps Generics Basics Generics Best Practices Generics in Go: Constraints Without Templates Performance Implications of Generics Type Parameters & Constraint Interfaces Type Sets & the comparable Constraint When to Avoid Generics in Go APIs

Branching Strategies & Trunk-Based Flow Code Review with GitHub PRs Git & GitHub Best Practices Git Basics for Go Projects Git for Go Teams GitHub Actions for Go Repos Monorepo Git Patterns with go work Rebasing, Cherry-Pick & Worktrees Signed Tags & Go Module Releases

Arrays, Slices & Maps at a Glance Go Fundamentals Basics Go Fundamentals Best Practices How Go Programs Are Structured: Packages, main, and the Toolchain Numeric Types, Strings, Runes & Byte Slices Pointers & the Address-of Operator Structs, Embedding & Field Promotion Variables, Constants & Scope Zero Values and Initialization

Histórico e Releases

Go 1.26 Highlights: Green Tea GC, go fix Modernizers, and Language Tweaks Go 2 Discussion History and What Actually Shipped Go History & Releases Best Practices Go Releases Basics Go's Evolution: From 2007 Origins to Go 1.0 and Beyond Major Milestones: Modules, Generics, Workspaces, Fuzzing, and PGO Planning Go Version Upgrades Across a Monorepo Reading Release Notes Like a Tech Lead The Go 1 Compatibility Promise in Practice

Padrões e Idiomas

Common Anti-Patterns in Go Codebases Constructor Functions & Package APIs Functional Options Pattern Go Idioms: Composition Over Inheritance Go Patterns & Idioms Best Practices Go Patterns Basics Middleware & Decorator Patterns Repository & Service Layer Patterns sync.Once & Singleton Patterns

Go Philosophy Basics Go Philosophy Best Practices Go vs C++, Java, Python, and Node.js Go vs Rust: Safety, Performance, and Team Velocity Trade-offs Go's Target Domains: Systems, Cloud-Native, CLIs, and Distributed Services Simplicity as a Deliberate Constraint in API Design When Go Is the Wrong Tool Why Go Exists: Simplicity, Readability, and Practical Concurrency

API Design Rules for Go Libraries Concurrency Rules Checklist Effective Go as a Living Standard Effective Go Rules Checklist Go Rules & Best Practices Summary Go Rules Quickstart Module & Dependency Rules Performance Rules: When to Optimize Security Rules for Go Services

Build Tags & Conditional Compilation Cross-Compilation & Private Module Proxies go build, run, install & clean go fix Modernizers & go vet Analyzers go mod tidy, vendor, download & graph go test, list & generate Go Toolchain Basics Go Toolchain Best Practices The go Command: Build, Test, and Module Lifecycle

gopls e Depuração

Debugging with Delve Go Developer Tooling: LSP, Debugger, and Analyzers Go Tooling Setup Basics gopls & Analysis Tooling Best Practices gopls: Navigation, Refactoring & Diagnostics gosec & nilaway for Security and Nil Safety govulncheck for Dependency Vulnerabilities staticcheck & golangci-lint in CI Writing Custom go/analysis Analyzers

gRPC e Protobuf

gRPC Basics gRPC Best Practices gRPC Error Codes & Status Mapping gRPC Gateway & JSON Transcoding gRPC in Go: Contracts, Streaming, and Performance gRPC Middleware, Interceptors & Metadata Protocol Buffers Schema Design REST vs gRPC Trade-off Guide Unary, Streaming & Bidirectional RPCs

Admission Webhooks: Validating & Mutating in Go controller-runtime Manager, Client & Scheme CRD Design & kubebuilder Scaffolding Kubernetes Operators Basics Kubernetes Operators Best Practices Leader Election, Metrics & Operator Observability OLM Bundles, Upgrades & Multi-Tenant RBAC Operator Testing with envtest & fake client Watches, Predicates, Owner References & Finalizers Why Go Dominates the Kubernetes Operator Ecosystem Writing a Reconciler: ctrl.Request & Reconcile Loop

Linting e Qualidade

CI Quality Gates: Lint, Test, Race, Vuln Code Quality Basics Code Review Standards for Go Teams Go Code Quality: Opinionated by Design go vet & Common Analyzer Diagnostics gofmt & goimports Enforcement golangci-lint Configuration Linting & Code Quality Best Practices Pre-commit Hooks & Review Checklists

Build, Test & Profile from the Shell Containers from the CLI: docker & kubectl Go Toolchain on Linux: Install & Version Switching Linux CLI Basics Linux CLI Best Practices Linux CLI Skills for Go Engineers Search, ripgrep & jq for Debugging Shell Productivity: tmux, fzf & direnv systemd & Service Unit Files for Go Binaries

HTTP Clients, Transport & Connection Pooling HTTP Servers, Handlers & ServeMux Patterns HTTP/2, Timeouts & ReverseProxy httptest for Handler Integration Tests Middleware Chains & Request Context net/http Basics net/http Best Practices net/http: Go's Batteries-Included HTTP Stack Production net/http Configuration Checklist

Observabilidade

Configuration Management: Env, Flags & Viper Graceful Shutdown & Signal Handling Health, Readiness & Liveness Probes Observability Basics Observability Best Practices OpenTelemetry Tracing in Go Services Production Go: Logs, Metrics, Traces, and Signals Prometheus Metrics & RED/USE Dashboards Structured Logging with slog

Pacotes e Módulos

go work: Workspace Mode for Multi-Module Repos go.mod, go.sum & Minimal Version Selection Import Cycles, Blank Imports & Dot Imports Package Naming & internal/ Directories Packages & Modules Basics Packages and Modules: Go's Unit of Distribution Packages, Modules & Project Layout Best Practices Pseudo-Versions, replace & retract Directives Standard Project Layout for Services and Libraries

CPU & Heap Profiling with pprof Escape Analysis & Compiler Optimizations GC Tuning for Latency-Sensitive Services Performance Basics Performance Best Practices Performance in Go: Measure, Profile, Then Optimize Profile-Guided Optimization (PGO)Slice Preallocation, strings.Builder & map Pre-sizing trace & Execution Tracer

Produto e Stakeholders

Communicating Go Trade-offs to Non-Go Stakeholders Estimating Go Work: Modules, Risk & Unknowns From Requirements to Go Service Specs Prioritizing Features vs Platform Work in Go Release Notes for Internal Go Platform Changes Risk Registers for Go Migration Projects Stakeholder Collaboration Basics Stakeholder Collaboration Best Practices Tech Leads Bridge Engineering and the Business

Resposta a Incidentes

Database Connection Pool Exhaustion Goroutine Dump & Leak Profile Analysis Incident Response for Go Services Live CPU & Heap Profiling Under Incident Load On-Call Handoff Checklist for Go Platforms OOM, GC Storm & Latency Spike Playbooks Post-Mortem Template for Go Incidents Production Troubleshooting Basics Production Troubleshooting Best Practices

Reflexão e Codegen

Building Custom Code Generators Deep Equality & Kind Switches go generate & stringer go:fix inline & API Migration Directives ORM & Serializer Reflection Costs Reflection & Code Generation Best Practices Reflection Basics Reflection vs Code Generation in Go Struct Tags & Custom Tag Parsing

Escape Analysis & Stack vs Heap Allocation Garbage Collector: Tri-Color Mark-Sweep & Pacing GOGC, GOMEMLIMIT & Finalizers Goroutine Stacks & Stack Growth Green Tea GC & GOEXPERIMENT Flags (Go 1.26)Memory Leaks in Go: Common Causes Runtime & GC Best Practices Runtime Basics The Go Runtime: Scheduler, GC, and Memory

Authentication & Authorization Patterns crypto/tls Configuration & Certificate Management Dependency Scanning with govulncheck & SBOM Go Security Basics Input Validation & Safe HTML/JSON Handling Rate Limiting, CORS & Security Headers Secure Cookies & CSRF for Web Apps Security Best Practices Summary Security for Go Services: Defaults and Gaps

encoding/json Custom Marshaling encoding/xml, gob & Binary Formats High-Performance JSON: jsoniter & sonic Alternatives Schema Evolution & Unknown Field Handling Serialization Basics Serialization Best Practices Serialization in Go: JSON First, Formats on Demand Struct Tags for JSON, DB & Validation Validation with go-playground/validator

Biblioteca Padrão

crypto/*, compress & math/rand/v2 database/sql & net Package Family Overview log, regexp & text/template os, io, bufio & path/filepath runtime, debug & pprof Packages Standard Library Basics Standard Library Best Practices The Go Standard Library: Batteries Included time, timezones & context Integration

Padrões e Comunidade

Coding Standards & Doc Conventions for Teams Community & Governance Basics Contributing to Go Toolchain & Stdlib Dependency Governance & License Compliance Future-Proofing: Proposals, Experiments & Roadmap Go Community & Long-Term Craft GopherCon, Meetups & Proposal Tracking Official Resources: go.dev, pkg.go.dev & Go Blog Standards, Governance & Community Best Practices

Equipe e Onboarding

Code Review Culture for Go Documentation & godoc Conventions Effective Go Reading Path Go SME Onboarding Checklist (30/60/90)Leveling Guide: Junior to Staff in Go Onboarding Go Specialists Pairing & Mob Sessions for Go Teams Team & Onboarding Best Practices Team Onboarding Basics

Liderança Técnica

Design Reviews for Go Services Handling Technical Disagreements on Go Teams Mentoring Go Developers Across Experience Levels Staff Engineer Path in Go Organizations Tech Debt Backlogs for Go Codebases Tech Leadership Basics Technical Leadership Best Practices Technical Leadership in Go Teams Writing ADRs for Go Architecture Decisions

Testes e Fuzzing

Benchmarks with testing.B & B.Loop Coverage, Race Detector & Golden Files Examples as Executable Documentation Fuzz Testing with testing.F Go Testing Basics Go Testing Culture: Simple, Fast, Table-Driven Table-Driven Tests & Subtests testify, httptest & Test Doubles Testing Best Practices

chi: Lightweight Routing & Middleware Echo: Middleware Ecosystem & Context Wrapper Framework Selection Decision Guide Gin: Fast JSON APIs & Binding Go HTTP Frameworks: Routers vs Full Frameworks gorilla/mux: Regex Routes & Host Matching Migrating Between Routers Without Rewriting Handlers Web Frameworks Basics Web Frameworks Best Practices

Compiling with GOOS=wasip1 GOARCH=wasm Go 1.26 WASM Runtime & Memory Improvements Go on WebAssembly: Browser, WASI, and Embedded Paths Native Go vs TinyGo vs Rust WASM Decision Guide syscall/js: Go in the Browser TinyGo for Microcontrollers & Constrained WASM WASI Host Runtimes: wasmtime, wazero & Spin WASM Size Optimization: TinyGo vs gc WASM WebAssembly & TinyGo Basics WebAssembly & TinyGo Best Practices

Related tags

Advanced List Explainer Basics Best Practices Examples Cheatsheet Security