Developers often struggle with Go's standard library because its high abstraction, performance tricks, compatibility concerns, Go's programming paradigm, reliance on documentation, and individual experience levels combine to make the code less intuitive and harder to grasp.
This article walks through a step‑by‑step Go implementation of Liu Qian’s 2024 Spring Festival Gala magic trick, explaining how to model the card‑handling algorithm with slices, shuffle, cuts, and loops, and provides complete source code and execution logs for readers to try.
This article traces Go’s rise to the TIOBE top‑10 ranking, recounting its 2009 debut, early hype, subsequent decline, and recent resurgence driven by a strict release cycle and the popularity of Docker and Kubernetes, while also explaining the index’s methodology.
This article introduces the RateLimiting Queue module of the Go WorkQueue project, explains why it builds on the Delaying Queue, details its design, interfaces, and usage examples, and provides code snippets for creating and operating a rate‑limited queue in backend systems.
This article explains why unit testing is often seen as burdensome in long‑running Go projects and provides practical techniques—such as using pure functions, extracting dependencies, object‑oriented design, and function variableization—to make business code easy to test and maintain.
This article comprehensively explains the Go program startup sequence, detailing how the runtime locates the entry point, initializes m0, g0, and P structures, processes command‑line arguments, sets up thread‑local storage, creates the first goroutine, and launches the GMP scheduler.
This article explores common caching scenarios, selection criteria, and best‑practice pitfalls, demonstrates a Go demo with configurable cache modes, compares byte‑versus‑struct caches, discusses concurrency, expiration, failover, cache transfer, lock contention, memory management, and provides benchmark results to guide high‑performance backend development.
This article dissects the internal architecture of Kubernetes' kube-scheduler, walking through its initialization with Cobra, the Setup function, the creation of scheduler instances, the priority queue mechanics, scheduling cycles, and binding processes, providing comprehensive code examples to illuminate each step of the scheduling workflow.
This article explains the internal workflow of the Kubernetes informer package in client-go, covering its architecture, key components such as Reflector, DeltaFIFO, and Indexer, and provides a step‑by‑step code example that demonstrates how informers are created, registered, started, and used to handle watch events efficiently.
This article provides an in‑depth analysis of Go’s GMP scheduler, explaining the evolution of the G‑M‑P model, detailing the structures g, m, p, their initialization, scheduling loops, code paths for goroutine creation, execution, and termination, and illustrating key source snippets with explanations.
This article explores how PayPal achieved the processing of billions of daily transactions using only eight virtual machines by adopting an actor‑model architecture built with Go, detailing the underlying challenges, network and resource optimizations, and providing a complete Go code example.
The guide shows that by consciously designing Go data structures and function interfaces—using pure functions, parameter injection, interface abstractions, struct‑based objects, or function‑variable patterns—and avoiding init(), developers can expose and control all dependencies, making business code inherently testable and achieving high unit‑test coverage.
This article walks through the complete design and implementation of full‑stack distributed tracing for Go‑based microservices, explaining correlation IDs, OpenTracing concepts, component roles, client and server code, database and service call tracing, compatibility issues, and best‑practice design guidelines.
This article explains the concept of object pools in Go, outlines their performance benefits, demonstrates how to implement pools using the standard sync.Pool and channel approaches with full code examples, and reviews several third‑party libraries for advanced pooling needs.
This article details how to train a YOLOv8‑pose model for license‑plate detection, convert it to TensorRT engine, implement C++ inference and preprocessing, expose the functionality via CGO to Go, and assemble a lightweight web service for real‑time plate recognition.
This article explains the design, implementation details, and practical usage of the Delaying Queue and Priority Queue modules in the WorkQueue library, covering their inheritance from the core Queue, the role of the Quadruple Heap data structure, and providing Go code examples for integration in backend systems.
Delve, the primary Go debugger, is installed via its official guide, requires disabling inlining with appropriate gcflags, supports flexible location specifications and rich expressions, offers multiple debugging modes (debug, exec, attach, core), configurable settings, runtime commands, breakpoint types, variable and stack inspection, and integrates seamlessly with Goland.
This guide walks through building a Go number‑guessing game, containerizing it with Docker, pushing the image, and deploying the application to a Kubernetes cluster using a Deployment manifest, then verifying and running the game inside the pod.
This article explores the various ways to compare structs, slices, maps, and other Go types, explaining when the == operator is applicable, why it fails for certain types, and how alternatives like reflect.DeepEqual, cmp.Equal, and testify can be used effectively.
This article introduces Baidu Comate, an AI-powered coding assistant built on the Wenxin model, explains how to install it, demonstrates its real-time code completion, comment generation, test creation, and optimization features across multiple languages and IDEs, and highlights its benefits for developers.
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 details the systematic investigation of intermittent availability drops in a high‑throughput Go service, covering hypothesis formulation, extensive profiling with pprof, gctrace, strace, fgprof, go trace, heap analysis, the discovery of a gcache LFU bug, and the final remediation steps.
The article shows how to write high‑performance Go code by spotting bottlenecks, using go‑test benchmarks and pprof profiling, and applying optimizations such as avoiding reflection, preferring strong‑type conversions, selecting appropriate map implementations, zero‑allocation string/slice tricks, efficient loops, generics, stack allocation, data alignment, pre‑allocation, and suitable lock primitives.
This article describes the motivation, design, and usage of Hasaki, a lightweight Go HTTP Restful client that supports custom status‑code handling, multiple data formats such as JSON, XML, YAML and protobuf, builder‑style chaining, and extensible middleware, providing code examples and a plugin architecture.
Distributed leader election ensures a single node performs exclusive tasks in high‑availability systems, with common implementations like Etcd, Kafka, Elasticsearch, and Zookeeper using algorithms such as Paxos, Raft, and ZAB, while Kubernetes provides the Lease resource to manage leader election via a distributed lock.
This article explains how to restrict a third‑party API to five requests per second in Go by combining a rate limiter to pace job starts and a semaphore to cap concurrent executions, complete with a full, runnable code example and detailed implementation notes.
This article explains the fundamental concepts of search engine technology—including forward and inverted indexes, tokenizers, stop words, synonym handling, ranking algorithms, and NLP integration—and provides a concise Go implementation with code examples and performance testing.
This article details Baidu's search display service evolution, outlining its original C and PHP/HHVM implementation, the three major challenges of high development difficulty, limited architecture capability, and low reusability, and presents a comprehensive solution using a graph execution engine, common operators, and a phased migration to Go.
The article explains how Go’s function values introduce an extra indirection and trigger escape analysis, making indirect calls slower than C pointers, and offers optimization tactics such as avoiding function‑pointer calls, using switch‑based dispatch, or applying the unsafe noescape trick when safe.
This article compares Go and Rust across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers decide which language best fits their specific project requirements in 2024.
Grafana Labs engineer Bryan Boreham explained at KubeCon how a series of code changes, label optimizations, and Go runtime tuning reduced Prometheus memory consumption by roughly 50%, detailing the technical challenges, solutions, and measurable impact on modern monitoring deployments.
This article explains how the team transformed a Go‑based microservice recommendation system into a single‑pod monolithic application using tRPC‑Go, detailing performance bottlenecks, code‑level mock‑proxy techniques, deployment adjustments, and the resulting dramatic reduction in CPU consumption.
This article explains the motivation, design, and implementation of JD’s lightweight Go‑based “localhost” tool that creates secure tunnels for remote debugging of locally running services, detailing its usage, core architecture, routing logic, and future enhancements.
This guide explores Go's versatile switch statement, covering basic syntax, initializer and value parts, literal true switches, short assignments, multiple case values, fallthrough behavior, default placement nuances, and type switches, all illustrated with clear code examples.
This article compares Rust and Go across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers choose the most suitable language for their 2024 projects.
This article explains how a large‑scale recommendation system built with tRPC‑Go microservices was refactored into a single‑process monolith to cut network overhead, reduce CPU usage by over 60%, and retain the benefits of microservice development while minimizing code changes.
This comprehensive guide walks you through Go structs—covering their definition, instantiation, methods, receivers, anonymous fields, embedding, and method expressions—while providing clear code examples and practical guidelines for effective use in Go programming.
Bilibili built a middleware‑based chaos engineering platform that injects faults into Golang microservices via AOP, supporting server‑ and client‑side, database, cache, and queue components, with fine‑grained instance, request, target, and user controls, automated dependency collection, experiment orchestration, and CI integration to boost system reliability.
This article walks through building a minimal Go HTTP server, explains how ListenAndServe internally binds, listens, and accepts connections, details the server’s main loop, request handling, routing logic, and shows how to customize connection and state hooks with concrete code examples.
The article explains Go’s stack and heap memory, showing that stack allocations are fast, LIFO‑ordered and compile‑time sized while heap allocations grow upward, require garbage collection, and occur when variables escape a function, urging developers to prefer stack use for better performance.
Looking back over ten years, the author revisits earlier blog posts and shares personal insights and judgments about the Go and Rust programming languages, concluding that choices often outweigh effort in shaping one’s technical path.
This article provides a comprehensive, step‑by‑step analysis of Go’s core concepts—including nil handling, the context package, string and rune internals, unsafe pointers, memory alignment, WaitGroup, semaphores, channels, slices, map implementations, sync.Map, garbage collection, and reflection—illustrated with concrete code examples and detailed reasoning.
Thread profiling uses threshold‑triggered tasks on business threads to capture stack snapshots, which a dedicated profiler thread sends via high‑performance gRPC to a server that queues them in Kafka, enriches and stores them in ClickHouse, correlates with OpenTelemetry traces, and provides metrics that let developers quickly pinpoint latency bottlenecks and improve system stability.
The article shows how to monolithize selected tRPC‑Go microservices by defining protobuf‑generated Go interfaces and swapping RPC proxies for in‑process implementations via a proxy API, cutting CPU usage by 61% while keeping microservice flexibility and offering best‑practice guidelines for Go service design.
This article dissects WeChat's group chat system, covering its functional and non‑functional requirements, high‑level architecture, face‑to‑face group creation, message transmission, storage design, and the real‑time red‑packet allocation algorithm implemented in Go.
This article compares Java classes with Go structs, covering how each language handles state and behavior, inheritance versus composition, and visibility rules, while providing concrete code examples to illustrate the practical differences for developers.
This article introduces the Kubernetes Operator pattern, explains its purpose for automating complex tasks, and provides a step‑by‑step tutorial on creating, configuring, and deploying a custom Operator using the Operator Framework, KubeBuilder, and Go, including code examples and deployment instructions.
This article dissects the design of WeChat's group chat system, covering functional and non‑functional requirements, high‑level component architecture, database schemas, face‑to‑face group creation, real‑time messaging, red‑packet algorithms, and Go code implementation, revealing how massive concurrency, performance, and storage challenges are solved.
The article details Gaode’s journey of building a high‑performance Go ecosystem that scaled from zero to tens of millions of QPS, comparing Go with Java and Erlang, outlining cloud‑native serverless architecture, and sharing real‑world refactoring and optimization case studies such as a million‑QPS rendering gateway and a Go‑based sharding middleware.
The article examines the long‑standing debate between tabs and spaces for code indentation, citing a massive GitHub analysis that shows spaces dominate most languages while Go uniquely enforces tabs, and explains the technical, historical, and practical reasons behind these preferences and how IDEs can enforce consistent styles.
This article explains how to use Prometheus to monitor business‑level metrics in a Kubernetes environment, covering observability fundamentals, metric definitions, metric types, exposing metrics via a /metrics endpoint, and practical Go code examples for defining, recording, and scraping custom metrics.
This article presents a comprehensive guide to software engineering fundamentals, covering code review, documentation, SOLID, dependency inversion, error handling, logging, and many practical design principles that help developers write maintainable, testable, and adaptable code.
The investigation revealed that the Go http.Client was not reusing connections because response bodies were closed before being fully read, causing the underlying connections to be marked dead; fully reading the bodies restored pooling, eliminated DNS‑resolution timeouts and dramatically lowered query‑per‑second spikes.
Profile‑Guided Optimization (PGO) collects runtime profiling data to recompile programs for higher performance, reducing branch mispredictions and improving code layout; Go gained built‑in PGO in 1.21 with typical 5 % gains, while C++ sees 15‑18 % QPS improvements and devirtualization benefits, and future work aims at deeper block ordering and register allocation.
This article compares Rust and Go across performance, language features, concurrency, memory safety, ecosystem, learning curve, and real‑world use cases to help backend developers choose the most suitable language for their projects.
This article introduces Dragonfly, an open‑source in‑memory database compatible with Redis and Memcached APIs, explains its architectural innovations, presents benchmark code comparing it with Redis, and discusses real‑world performance results and future development plans.
The article details how a Go service’s 300‑second Redis call timeout was traced to a gateway’s full‑NAT session‑table loss, and explains how targeted retries, proper timeout settings, and rate‑limiting can prevent similar cascading failures in distributed systems.
The article explains how to handle business scenarios that require splitting large data sets into concurrent I/O requests and sequential aggregation by presenting a Go‑based chunk processing framework with map and reduce functions, configurable concurrency, and example code.
This article provides a comprehensive, beginner‑friendly walkthrough of Go language fundamentals, covering variable and constant declarations, zero values, functions with multiple returns and variadic parameters, struct‑based OOP, non‑intrusive interfaces, slices, maps, goroutines, channels, and the simple error‑handling model with defer, panic, and recover.
Spark is an open‑source Go‑based remote control and monitoring tool that runs in any modern browser, supports Windows, Linux and macOS, and offers features such as web shell, file management, system info, and customizable API access.
Go introduced generics in version 1.18, allowing developers to write reusable, type‑safe code by defining type parameters and constraints in square brackets, instantiating them with concrete type arguments, and using generic functions, types, and collections such as stacks and sets to improve readability, safety, and maintainability.
This article explains how to build a high‑performance Go server capable of processing up to one million requests per minute using efficient goroutine‑pool patterns, detailing the design of two worker structures, their dispatch, start, stop mechanisms, and practical optimizations.
This article provides an in‑depth analysis of the Kubernetes scheduler's queue subsystem, detailing the internal data structures, heap implementation, priority queue logic, and the lifecycle methods that add, activate, update, and remove Pods from active, backoff, and unschedulable queues.
The article details how a sudden surge in goroutine and heap usage was traced to repeatedly creating gRPC clients instead of reusing a singleton, leading to blocked goroutines and TCP connections, and explains using pprof, stack traces, and tools like goleak to detect and prevent such leaks.
The 37Game team built the cloud‑native kjob platform to replace VM‑based schedulers, providing a unified, highly available Kubernetes solution that manages both CronJob‑style scheduled tasks and long‑running Deployments through a backend‑agent architecture, offering CRUD operations, rich configuration, real‑time monitoring, alerting, and seamless migration.
This article details the design and development of a unified permission management service (MPS) that consolidates RBAC, ACL, and DAC models to solve fragmented enterprise permission issues, covering requirement analysis, technical selection, functional modules, deployment, and performance outcomes.
This article explains how a Go hello‑world program starts, tracing the ELF entry point, runtime initialization, GMP scheduler setup, creation of the main goroutine, and the flow into the user's main function.
The author reflects on how studying several programming languages—Java, Go, and Python—mirrors learning foreign tongues, revealing that cross‑language comparison sharpens understanding of data structures, HTTP fundamentals, and framework implementations, ultimately deepening overall software development expertise.
This tutorial walks you through the concepts of Kubernetes Operators, how they work, and provides a hands‑on walkthrough using Kubebuilder to set up the development environment, create a simple Foo operator, define CRDs, implement controller logic, and deploy and test the operator on a local cluster.
This article analyzes several bugs discovered in a Go goroutine pool implementation—incorrect active count, mismatched execution counters, slow scaling during QPS spikes, and inefficient recycling—and presents detailed code fixes and redesigns to achieve accurate metrics and faster, more graceful worker management.
This article explains the origins and purpose of Linux's standard input (0), standard output (1), and standard error (2) file descriptors, shows how they are defined in Rust and Go, and illustrates their behavior in terminal emulators and SSH sessions with detailed diagrams.
This article introduces Go to developers familiar with other object‑oriented languages, covering the language definition, basic syntax such as variable and constant declarations, control structures, functions with multiple returns and variadic parameters, data structures like arrays, slices and maps, struct‑based object‑orientation, interfaces, goroutine‑based concurrency, channels, mutexes, and the simple error‑handling model using error, defer, panic, and recover.
The article explains Go’s runtime finalizer mechanism, shows how a single blocked finalizer can stall all cleanup callbacks, and recounts a real‑world memory‑leak incident where an unrelated goroutine’s blocked finalizer for struct B prevented struct A’s resources from being released.
Unified Permission Management Service (MPS) at Baidu centralizes fragmented permission systems across internal platforms, integrating ACL, DAC, and RBAC models via Baidu's GDP framework, and provides modules for platform and node management, permission CRUD, workflow approvals, and audit/recovery, now serving over 20,000 users and managing more than 100,000 permission nodes.
This guide explains how to obtain a GitLab access token, download a Go-based cloning tool, configure its parameters, and run it to automatically fetch all groups and projects from a GitLab instance, with full source code examples for customization.
Go 1.21.0 introduces toolchain enhancements, new built‑in functions, expanded standard library packages, performance improvements through PGO and garbage‑collector tuning, experimental WASI support, and version‑number changes, all illustrated with concise code examples for developers.
Kscan is a pure‑Go, all‑in‑one network scanner that supports port scanning, protocol detection, fingerprinting, and brute‑force cracking across thousands of protocols, offering detailed usage instructions, command‑line options, and a GitHub download link for security professionals.
This article explains three typical pitfalls of Go slices—ignoring the slice returned by append, unintentionally sharing the underlying array which can cause memory leaks, and the value‑copy behavior of for‑range loops—while also showing how to inspect slice internals using unsafe pointers.
The article describes an eBPF‑based, language‑agnostic traffic recording framework that hooks low‑level socket operations and thread identifiers to capture complete request‑response flows across Java, PHP, and Go services without modifying application code, dramatically lowering implementation and maintenance costs for cloud‑native traffic replay.
Based on analysis of over 14 million developer job postings from January 2022 to May 2023, DevJobsScanner identified JavaScript/TypeScript, Python, Java, C#, PHP, C/C++, Ruby, and Go as the eight programming languages with the highest demand, accounting for roughly 29% of all language‑specific positions.
This article explores Go's channel implementation—from its CSP‑inspired design and internal hchan structure to real‑world memory‑leak debugging, creation nuances, send/receive mechanics, and proper closing—providing developers with a comprehensive understanding of safe concurrent programming in Go.
The article recounts a Go project's evolution of configuration handling—from hard‑coded DB credentials to a unified global struct and finally an init‑based implicit loader—highlighting how each teammate’s approach reflects distinct mindsets, knowledge gaps, and productivity trade‑offs, and invites readers to consider their own collaboration preferences.
This article details Tongcheng Travel's cloud‑native migration journey, describing the challenges of resource quota management, component versioning, and operational automation, and explains how a Kubernetes Operator platform built with Go, kubebuilder, and a watch‑broadcast mechanism addresses these issues while outlining future expansion plans.
Using Go’s pprof, the team traced a gradual CPU spike in a high‑throughput kafka‑go consumer to a saturated commit queue and repeatedly nested context values, which forced costly lookups; eliminating the unnecessary trace‑id context injection (or recreating a fresh context each loop) resolved the issue and reduced CPU usage to under 2 %.
This article presents a Go‑based dynamic QPS load‑testing framework that leverages a custom goroutine pool, explains the rationale behind reusing goroutines, provides core functions for task execution and console command handling, and includes a complete runnable demo illustrating high‑throughput performance testing.
This guide walks through the background, implementation, usage examples, and step‑by‑step open‑source contribution process for adding Redis cache expiration and memory‑limit chaos experiments to the ChaosBlade platform, including code snippets, Git workflow, and testing procedures.
The article explains Go closures, shows how capturing loop variables by reference can cause bugs like repeated values, demonstrates correct patterns such as copying variables inside loops or passing them as parameters, and offers guidelines to avoid common pitfalls with defer and concurrency.
This tutorial explains how Go developers can generate Tars RPC code from IDL, implement server and client logic, configure server and client settings, use various call patterns such as context, one‑way, mod‑hash and consistent‑hash, and quickly scaffold projects with the tarsgo tool.
This article explains how thorough code review, using tools like GoLand, Git plugins, and Postman, improves test case accuracy, data integrity, branch coverage, and overall software quality in Go projects, while offering practical tips on diff usage and highlighting the tangible benefits for testing teams.
The article details Shopee’s seadt‑SAGA framework—a Go‑based distributed transaction solution that implements the SAGA pattern via two modes, orchestration with a central coordinator and collaboration with embedded logic, explains their state‑machine designs, compares rollback ordering using vector clocks versus sequence numbers, and discusses each mode’s trade‑offs.
This guide explains how rtty combines a lightweight C client, a Go server, and a Vue front‑end to provide web‑accessible terminals for remote Linux device maintenance, covering its key features, installation steps, token generation, and browser‑based access.
The article explains how Bilibili’s senior engineer uses Domain‑Driven Design combined with hexagonal architecture to merge separate VOD and live‑stream Danmaku services into a unified platform, detailing sub‑domain decomposition, six‑sided ports, rich models, mapping logic, and the trade‑offs of improved modularity, maintainability, and reduced duplication versus added design and refactoring effort.
This article details Baidu Wenku App's backend migration from a PHP‑based stack to Go, covering the motivation, technical debt, technology selection, step‑by‑step migration strategy, quality assurance practices, performance improvements, and key takeaways for large‑scale service refactoring.
This article shares a detailed account of a Tencent testing engineer interview, covering self‑introduction, Go knowledge, Redis performance, distributed lock implementation, semaphore mechanics, RPC vs HTTP, concurrency usage, Git security practices, Linux commands, and a few brain‑teaser and algorithm questions.
This article explains how to implement a high‑performance Go coroutine pool by adapting key features of Java’s ThreadPoolExecutor, covering core parameters, task queue design, dynamic scaling, worker management, timeout handling, and provides complete code examples and self‑test results.
This guide introduces the Go‑based “diskusage” utility, shows how to install it with a single command, explains its usage with examples such as filtering specific file types, displaying sizes in gigabytes, and enabling colored output, and notes its cross‑platform support for Linux, macOS, and Windows.
The article explains why PHP programmers should learn Go, highlighting its faster execution, superior concurrency support, and built‑in web server capabilities, while providing simple code examples and mentioning a related training course.
Go maps are not safe for concurrent access, so programs can panic when multiple goroutines read and write the same map; to prevent this you can use sync.Once for immutable data, protect maps with sync.RWMutex, employ sharded locks via concurrent‑map, or use the built‑in sync.Map, each offering different performance trade‑offs depending on read/write ratios and concurrency level.
Learning Go offers PHP developers faster execution, superior concurrency, and a built‑in web server, making it easier to build high‑performance applications, and this article demonstrates these advantages with simple code examples while also providing resources for further study.
This article, the final installment of a DDD series, walks through a practical implementation of Domain‑Driven Design in Go using Kitex and Thrift, covering bounded contexts, layered architecture, domain modeling, persistence, factories, domain services, and cross‑cutting concerns in a fictional e‑commerce system.
