1 views collected around this technical thread.
This article explores the internal structure and growth mechanism of Go's bytes.Buffer, demonstrates how the GWS library replaces gorilla/websocket, and presents a high‑performance bytes.Buffer pool implementation using sync.Pool with power‑of‑two sizing to reduce allocations and improve concurrency in backend services.
This article explains the principles of object pools, details the internal implementation of Go's sync.Pool, and demonstrates through benchmarks how using an object pool can dramatically reduce memory allocation and latency for high‑traffic menu services in a restaurant ordering application.
This article introduces the Go WorkQueue project, detailing its motivation, overall architecture, layered design of Queue, Simple Queue, Delaying Queue, Priority Queue, and RateLimiting Queue, compares underlying data structures such as DoubleLinkedList versus slice, presents performance benchmarks, and explains memory‑fragmentation mitigation using sync.Pool.
This article explains Go 1.18 generics, covering type parameters, type sets, type inference, and shows how to simplify sorting, strconv.Append, heap, sync.Pool, and sync.Map with concise generic implementations and real code examples.
This article explains Go 1.18 generics—type parameters, type‑set interfaces, and inference—through six practical examples including a universal sorting function, generic Append, heap, sync.Pool and sync.Map wrappers, showing how generics reduce code size, improve readability, and enhance type safety.
The article explains how Go's lock‑free sync.Pool can cut garbage‑collection overhead, shows practical FFmpeg thread‑parameter tuning that balances CPU use and latency for video filtering versus encoding, and compares PaddlePaddle's static and dynamic graph modes, including debugging tips and conversion to static.
The article surveys a range of Go standard‑library performance tricks—from using sync.Pool and zero‑copy string/byte conversions to reducing lock contention, leveraging go:linkname, caching call‑frame data, optimizing cgo calls, employing custom epoll, SIMD, and occasional JIT—while urging profiling‑first, readability‑preserving optimizations.
This article explains what a sync.Pool object pool is, when it should be used, details the Go 1.12 implementation with its internal structures and algorithms, describes the enhancements introduced in Go 1.13, and analyzes the resulting performance improvements for high‑concurrency backend applications.
This article presents a collection of practical Go performance‑tuning techniques—including reuse of objects with sync.Pool, avoiding pointer‑heavy map keys, generating marshal code to bypass reflection, using strings.Builder for efficient concatenation, preferring strconv over fmt, and pre‑allocating slices—to significantly reduce allocation overhead and garbage‑collection time.
This article presents seven practical Go performance optimization techniques—including using sync.Pool, avoiding pointer‑heavy maps, generating marshal code, leveraging strings.Builder, preferring strconv over fmt, pre‑allocating slices, and passing byte slices—to reduce garbage collection overhead, improve allocation efficiency, and achieve up to 97% faster execution.
This article analyzes Uber's open‑source Go logging library zap, explaining its architectural trade‑offs, performance‑boosting techniques such as object pooling, reflection avoidance, and write‑time copying, and offers practical guidance for developers who want to build high‑performance logging components in Go.