Quick Navigation

Rust 71 Python 158 Go 144 TypeScript 1 JavaScript 152

Golang — Topic Index

Topic index generated on 2026-08-03 — grouped article list

Golang — Topic Index

Below is an index of articles grouped by topic. Click a heading to jump to the section.

Go

Programming

Uncategorized

If you find missing articles or inaccurate groupings, run ./scripts/update_index.py with appropriate flags.

Benchmarking Go Code

Master benchmarking in Go. Learn to measure performance, identify bottlenecks, and optimize code effectively.

Go Modules: Dependency Management

Master Go modules for managing dependencies, versioning, and maintaining reproducible builds. Learn go.mod, go.sum, and best practices for dependency management.

Go Naming Conventions and Code Style

Master Go naming conventions and code style guidelines. Learn idiomatic Go naming for packages, functions, variables, and best practices for consistent code.

IDE Setup: VS Code for Go

Complete guide to setting up Visual Studio Code for Go development. Learn extensions, configurations, debugging, and productivity tips for VS Code.

Packaging and Distributing Go CLI Tools

Package and distribute Go CLI tools — cross-platform builds with ldflags version injection, goreleaser automation, checksums, Homebrew formulas, go install, Docker multi-stage …

Setting Up Your Go Workspace

Complete guide to setting up a productive Go development workspace, including directory structure, project organization, and best practices for Go projects.

Advanced Channel Patterns in Go

Master advanced Go channel patterns — multiplexing, tee, done channels, or-done, bridge channels, queuing, and how to combine them with context for production-ready concurrent …

Analytics and Reporting in Go

Build analytics and reporting systems in Go — in-memory metric aggregation, percentile calculations, time-bucketing, group-by analysis, multiple report formatters, and integrating …

API Design Best Practices for Go

Master Go API design — URL naming conventions, versioning strategies, consistent error responses, pagination patterns, rate limiting with golang.org/x/time/rate, OpenAPI …

API Gateways and Reverse Proxies in Go

Build API gateways and reverse proxies in Go using httputil.ReverseProxy — custom directors, load balancing, middleware chains, circuit breaking, and production-ready patterns for …

AST Manipulation and Analysis in Go

Master Abstract Syntax Tree manipulation in Go. Learn to parse, analyze, and transform Go code programmatically using the go/ast, go/parser, and go/analysis packages to build …

Behavioral Design Patterns in Go

Master behavioral design patterns in Go — Observer, Strategy, Command, State, Chain of Responsibility, and Iterator. Learn idiomatic Go implementations using interfaces and …

Buffered vs Unbuffered Channels

Master buffered and unbuffered channels in Go. Learn when to use each, deadlock prevention, and channel patterns for concurrent programming.

Building CLI Tools with Cobra in Go

Master the Cobra framework for Go CLI tools — command structure, persistent and local flags, RunE error handling, argument validators, Viper configuration integration, shell …

Building Interactive CLI Applications in Go

Build interactive CLI applications in Go — reading user input with bufio, secure password input with golang.org/x/term, multi-select menus, input validation, progress indicators, …

Building REST APIs with Go

Build production-ready REST APIs in Go — API design principles, request handling, input validation, pagination, versioning, authentication middleware, error responses, and testing …

Building System Utilities in Go

Build production-quality Go system utilities — disk usage analyzers, log parsers, process monitors, file watchers with fsnotify, structured output formatting, and distributing …

Bytes, Runes, and Unicode in Go

Master Go's string model — how UTF-8 encoding works, when to use bytes vs runes, correct iteration, unicode/utf8 package functions, and the performance tradeoffs of []byte vs …

Code Coverage and Quality Metrics in Go

Master Go code coverage — go test -cover, coverage profiles, HTML reports, per-function analysis, enforcing coverage thresholds in CI, golangci-lint configuration, and interpreting …

Code Generation in Go

Master Go code generation — go:generate directives, stringer for enums, mockgen for test doubles, sqlc for type-safe SQL, writing custom generators with text/template and go/ast, …

Command-Line Parsing and Flags in Go

Master Go's flag package — defining flags, custom flag types, subcommands, environment variable fallback, validation patterns, and when to reach for Cobra instead.

Compiler Optimizations and Inlining

Master Go compiler optimizations including function inlining, dead code elimination, and compiler directives. Learn how to write code that compiles efficiently.

Concurrency Performance Tuning in Go

Optimize concurrent Go programs — goroutine pool sizing, channel buffer tuning, atomic operations, lock contention reduction, batch processing, and profiling with pprof.

Configuration Management in Go

A complete guide to Go configuration management — environment variables, Viper, config file formats, secrets management, feature flags, hot reload, and production validation …

Constants and Enumerations in Go

Master Go constants and enumerations — const declarations, untyped vs typed constants, iota patterns for enums and bit flags, String() methods, and why typed enums prevent bugs …

Creational Design Patterns in Go

Master creational design patterns in Go — Singleton with sync.Once, Factory functions, Builder with functional options, Abstract Factory, and Object Pool with sync.Pool. Practical …

Cryptography in Go

Master Go cryptography — AES-GCM authenticated encryption, SHA-256/SHA-3 hashing, HMAC for message authentication, RSA and ECDSA signatures, bcrypt for passwords, and using …

Custom Errors and Error Wrapping in Go

Master custom error types and error wrapping in Go — implementing the error interface, adding structured context, Unwrap chains, multi-error with errors.Join, and patterns for …

Data Validation and Transformation in Go

Master data validation in Go — struct validation with go-playground/validator, custom rules, collecting all errors vs failing fast, input sanitization, and transformation pipelines …

Database Fundamentals with Go's database/sql

Master Go's database/sql package — connection pooling configuration, prepared statements, scanning into structs, transactions with proper rollback, handling sql.ErrNoRows, and …

Database Operations and Optimization in Go

Optimize Go database operations — connection pool sizing with DBStats, batch inserts with prepared statements, EXPLAIN ANALYZE query tuning, read replicas, query caching patterns, …

Deadlock Detection and Prevention in Go

Master deadlock detection and prevention in Go. Learn to identify deadlock conditions, use tools like go-deadlock, implement prevention strategies, and debug concurrent systems.

Debugging Go Programs

Master debugging Go programs using Delve debugger, print debugging, and profiling tools. Learn effective debugging techniques and best practices.

Debugging System-Level Issues in Go

Master Go debugging — Delve debugger commands, structured debug logging, detecting goroutine and memory leaks, diagnosing deadlocks with pprof, using race detector, and tracing …

Dependency Injection in Go

Master dependency injection in Go — constructor injection patterns, the wire-up function, avoiding global state, testing with fakes, and using google/wire for large codebases.

Deploying Go Applications to Kubernetes

A complete guide to running Go apps on Kubernetes — Dockerfiles, deployments, services, ConfigMaps, health probes, autoscaling, client-go, and production patterns for Go …

Distributed Tracing in Go

Master distributed tracing in Go with Jaeger, Zipkin, and OpenTelemetry. Learn how to instrument microservices, track requests across systems, and debug complex distributed …

Empty Interface and Reflection in Go

Master Go's any/interface{}, reflection with reflect.TypeOf and reflect.ValueOf, struct field inspection, modifying values via reflection, and when to prefer generics over …

Encoding and Decoding Data in Go

Master data encoding in Go — JSON marshaling with custom types, base64, hex, binary encoding, CSV, gzip compression, and choosing the right format for each use case.

Fiber: High-Performance Web Framework for Go

Master the Fiber web framework — zero-allocation routing, middleware, request parsing, route groups, custom error handlers, and when Fiber's fasthttp backend gives you a real …

File System Operations at Scale in Go

Handle large-scale file system operations in Go — parallel directory walks with bounded concurrency, streaming large files with custom buffer sizes, atomic directory operations, …

File System Operations in Go

Master file I/O in Go — reading and writing files with os and bufio, walking directory trees with filepath.WalkDir, atomic writes, temp files, file watching, and path safety for …

Go Reflection: Advanced Type Inspection

Master Go reflection for runtime type inspection — reflect.TypeOf/ValueOf, struct field and tag inspection, modifying values safely, calling methods dynamically, building generic …

Go Toolchain: build, run, test, fmt

Master the Go toolchain commands: build, run, test, fmt, and more. Learn how to compile, execute, test, and format Go programs efficiently.

Go Type System: Basics and Type Inference

Master Go's type system — basic numeric and string types, type inference with :=, explicit type declarations for domain modeling, type aliases vs new types, zero values, and …

GORM: ORM in Go

Master GORM for Go — model definition with struct tags, CRUD operations, associations with Preload, scopes, hooks, transactions, and avoiding the N+1 query problem.

GraphQL APIs with Go and gqlgen

Build GraphQL APIs in Go with gqlgen — schema-first development, code generation, resolver implementation, DataLoader for N+1 prevention, subscriptions, and middleware for …

Implicit Interfaces and Duck Typing in Go

Master Go's implicit interfaces and duck typing. Learn how Go's interface system enables flexible, decoupled code without explicit implementation declarations.

Interface Composition and Embedding in Go

Master Go interface composition — embedding interfaces to build larger contracts, struct embedding for method promotion, the middleware wrapper pattern, and when composition beats …

Logging in Go

Master logging in Go — the standard log package, Go 1.21 slog structured logging, log levels, context-aware logging, third-party libraries (zap, zerolog), and production best …

Memory Management and Allocation in Go

Master Go memory management — stack vs heap allocation, escape analysis, reducing GC pressure with sync.Pool and pre-allocation, reading MemStats, tuning GOGC/GOMEMLIMIT, and …

Memory Management and Escape Analysis

Master Go's memory management and escape analysis. Learn how the compiler decides whether variables are allocated on the stack or heap, and how to optimize memory usage.

Methods and Receivers in Go

Master Go methods and receivers — when to use value vs pointer receivers, method sets and interface satisfaction, method chaining, embedding method promotion, and the consistency …

Microservices Architecture with Go

Comprehensive guide to building microservices architecture using Go. Learn service design, communication patterns, and best practices for scalable distributed systems.

Operating System Interfaces in Go

Master Go's OS interfaces — environment variables, process information, signal handling for graceful shutdown, cross-platform paths, file permissions, and system resource discovery …

Performance Optimization Techniques

Master performance optimization in Go. Learn algorithmic improvements, memory optimization, concurrency tuning, and practical techniques to make your applications faster and more …

Performance Tuning Go Systems

Tune Go application performance — reading pprof CPU and heap profiles, reducing allocations with escape analysis, cache-friendly data layout, GOMAXPROCS tuning, avoiding lock …

Profiling Go Programs: CPU and Memory

Master CPU and memory profiling in Go using pprof. Learn to identify performance bottlenecks, analyze heap allocations, and optimize your applications with practical profiling …

Protocol Buffers and Serialization in Go

Master Protocol Buffers in Go — proto3 schema design, code generation with protoc, marshal/unmarshal, field numbering rules, oneof for sum types, Well Known Types for timestamps, …

Race Conditions and Data Races

Master race conditions and data races in Go. Learn to detect, prevent, and fix concurrency bugs using the race detector and synchronization primitives.

Readers, Writers, and Buffers in Go

Master Go's io package — the Reader and Writer interfaces, io.Copy, io.TeeReader, io.LimitedReader, bufio for line-by-line reading, bytes.Buffer, io.Pipe for goroutine …

Regular Expressions in Go

Master regular expressions in Go using the regexp package. Learn pattern matching, capturing groups, and practical regex patterns.

REST vs gRPC in Go: When to Use Each

Compare REST and gRPC for Go microservices — transport differences, serialization benchmarks, streaming capabilities, browser compatibility, debugging tradeoffs, and a practical …

Secure Coding Practices in Go

Master secure coding practices in Go — input sanitization, safe error messages, path traversal prevention, secure file permissions, dependency auditing, environment secrets, …

Security Testing in Go

Master security testing in Go — testing input validation, SQL injection prevention, authentication flows, authorization boundaries, fuzzing with go test -fuzz, and integrating …

Semaphores and Rate Limiting in Go

Master semaphores and rate limiting in Go. Learn to control concurrent access, limit throughput, and implement token bucket, leaky bucket, and sliding window algorithms for …

Shell Integration and Scripting in Go

Learn how to run shell commands, execute scripts, manage processes, and build cross-platform CLI tools in Go. Covers os/exec, command piping, environment management, and shell …

SOLID Principles in Go

Apply SOLID principles to Go code — Single Responsibility with package design, Open/Closed with interfaces, Liskov Substitution, Interface Segregation with small interfaces, and …

SQL Query Building in Go

Master SQL query building in Go — raw queries with database/sql, avoiding N+1 with JOINs, the Squirrel query builder for dynamic conditions, sqlx for struct scanning, and when to …

Static Files and HTML Templates in Go

Master serving static files and rendering HTML templates in Go — http.FileServer, http.ServeFile, html/template security, template caching, custom functions, template composition …

Stream Processing in Go

Build stream processing systems in Go — tumbling and sliding windows, stateful aggregations, event-time vs processing-time, session windows, backpressure, and integrating with …

Struct Tags and Metadata

Master struct tags in Go for encoding metadata. Learn to use tags for JSON marshaling, database mapping, validation, and custom metadata handling.

Structural Design Patterns in Go

Master structural design patterns in Go — Adapter for interface compatibility, Decorator for layered behavior, Facade for subsystem simplification, Proxy for controlled access, and …

System Calls and Low-Level Programming in Go

Master Go system calls — golang.org/x/sys vs syscall, file descriptors, memory mapping with mmap, signal handling, process management with os/exec, and using the unsafe package …

Testing CLI Applications in Go

Master testing Go CLI applications — testing command handlers with Cobra, capturing stdout/stderr, injecting dependencies, golden file tests, integration tests with exec.Command, …

Text Processing and String Algorithms in Go

Master text processing in Go — the strings package, strings.Builder, regex, Unicode-aware operations, Levenshtein distance, word frequency, and performance tradeoffs for …

Time and Date Handling in Go

Master time and date operations in Go. Learn about the time package, parsing, formatting, timezones, and practical time manipulation techniques.

Time Series Data Handling in Go

Handle time series data in Go — in-memory storage with concurrent access, time-range queries, downsampling, aggregation functions, working with InfluxDB and Prometheus remote …

Unicode and String Encoding in Go

Master Unicode in Go — UTF-8 encoding mechanics, NFC/NFD normalization for correct string comparison, grapheme clusters with golang.org/x/text, collation for sorting, and handling …

Web Application Security in Go

Secure Go web applications against OWASP Top 10 — SQL injection prevention, XSS with html/template, CSRF tokens, security headers, input validation, rate limiting, and secure …

Worker Pools and Concurrency Patterns in Go

Master Go worker pool patterns — fixed-size pools, fan-out/fan-in, pipelines, and backpressure. Includes production patterns with context cancellation and error propagation.

Working with Large Datasets in Go

Process large datasets efficiently in Go — streaming with bufio.Scanner, chunked parallel processing with goroutines, sync.Pool buffer reuse, memory profiling, and database cursor …

Anonymous Functions and Closures in Go

Master Go anonymous functions and closures — function literals, how closures capture variables, practical patterns for callbacks and state, the loop variable trap, and using …

Conditional Statements in Go

Master Go conditional statements — if/else with initialization clause, switch without expression, type switches, guard clauses over deep nesting, and the idiomatic Go patterns for …

Defer, Panic, and Recover in Go

Master Go's defer, panic, and recover — how defer executes (LIFO, argument capture, named returns), when panic is appropriate, how recover works at service boundaries, and …

Error Handling in Go

Master error handling in Go — the error interface, custom error types, wrapping with %w, errors.Is and errors.As, sentinel errors, and production patterns for clear, recoverable …

Go Arrays: Fixed-Size Collections

Master Go arrays — fixed-size declaration, the ellipsis syntax, value semantics (arrays are copied), slicing to create slice views, multidimensional arrays, and when arrays are the …

Go Interfaces: Definition and Implementation

Master Go interfaces — defining single and composed interfaces, implicit satisfaction, the Stringer and error contracts, common standard library interfaces, and how interface …

Go Loops: for, range, and Loop Patterns

Master Go's single loop construct — the three-clause for, while-style, infinite loop, range over slices/maps/strings/channels, labeled break/continue for nested loops, and common …

Go Maps: Key-Value Pairs and Patterns

Master Go maps — creation, the comma-ok idiom, iteration order, concurrent access with sync.Map, common patterns like frequency counting and grouping, and avoiding nil map panics.

Go Pointers and Memory Management

Master Go pointers — address-of and dereference operators, pointer vs value receivers, nil pointer safety, escape analysis, new vs make, and how the GC manages heap memory …

Go Slices: Dynamic Arrays and Operations

Master Go slices — the three-component header, append growth behavior, the sharing trap with sub-slices, copy for independent copies, three-index slices for capacity control, and …

Go Structs: Composition and Embedding

Master Go structs — field declaration, initialization, methods, anonymous embedding for code reuse, struct tags for JSON/database mapping, and why Go chooses composition over …

Go Variables and Data Types Fundamentals

Master Go variables — var declarations, short := syntax, when each form is appropriate, multiple assignment, blank identifier, scope rules, and the constants/iota patterns used …

Goroutines: Lightweight Concurrency in Go

Master goroutines in Go — how they work under the hood, how to start and stop them safely, synchronization with WaitGroup, and patterns to avoid goroutine leaks.

HTTP Client and Server in Go

Master Go's net/http package — building production servers with timeouts, routing with ServeMux, middleware, a correctly configured HTTP client, connection pooling, and context …

Multiple Return Values in Go

Master Go's multiple return values — the error pattern, named returns with defer-based wrapping, returning optional values with bool, the comma-ok idiom, and when to use structs …

Type Assertions and Type Switches in Go

Master Go type assertions and type switches — the two-value assertion idiom, avoiding panics, type switches with interfaces, errors.As for error type extraction, and when to use …

Working with JSON in Go

Master JSON in Go — struct tags, marshaling edge cases, streaming with Encoder/Decoder, custom marshalers, json.RawMessage, and performance tips for high-throughput JSON workloads.

Common Go Pitfalls and How to Avoid Them

The most common Go pitfalls — loop variable capture, nil interface traps, goroutine leaks, slice gotchas, and defer in loops — with clear examples and fixes.

Go Slices and append: A Complete Guide

A complete guide to Go slices and the append function — how slices work internally, capacity growth, common patterns, and performance tips.