This article walks through a step‑by‑step Go implementation of the popular Spring Festival Gala magic trick, explaining the underlying Josephus‑style algorithm, showing each transformation of a slice of cards with complete code snippets, and demonstrating how the final single card matches the hidden one.
The article investigates why Go applications unexpectedly send AAAA DNS queries to a secondary nameserver, tracing the issue to the built‑in resolver’s handling of non‑recursive responses from a NetScaler proxy, and recommends using the cgo resolver, enabling recursion, or forcing IPv4 to eliminate the added latency.
The February 2024 TIOBE index shows Go reaching a record‑high #8, while legacy languages Fortran and COBOL surge into the top‑20, and IBM unveils a generative‑AI tool to translate COBOL code to Java, highlighting the enduring relevance of older languages.
This article explains how to obtain a file's owner information in Go by using the os package together with system calls, detailing the required steps, providing a complete code example, and highlighting platform considerations and typical use cases.
This article explores how to replicate Python's context manager behavior in Go by examining defer's delayed execution, demonstrating its limitations in loops, and presenting three solutions—anonymous functions, a WithClose helper, and a withLock-inspired pattern—to ensure timely resource release.
This article systematically compares the most popular Go web frameworks—Beego, Buffalo, Echo, Gin, Iris, and Revel—by evaluating their popularity, learning curve, routing capabilities, middleware ecosystems, server features, session handling, template engines, testing support, and other core functionalities, complete with concrete code examples.
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 presents a concise 70‑line Go implementation of a coroutine pool, explaining its design, how it manages task queues and worker goroutines, handles timeouts, and provides the full source code for easy integration.
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.
This article walks through creating a functional Redis service called EasyRedis, focusing on implementing a distributed cluster with a consistent‑hash algorithm in Go, including detailed code examples, node mapping, command routing, and relay mechanisms.
This article walks through the design and Go implementation of a reusable Redis connection pool, covering the pool data structure, object acquisition and release logic, handling of active limits and waiting queues, and an extended per‑IP socket pool for distributed Redis clusters.
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 details the end‑to‑end process of replacing low‑resolution SRTM data with 30‑meter ASTER elevation data, redesigning storage and access using JuiceFS, Go, and sync.Pool, and achieving sub‑millisecond latency for 1500 QPS in a Kubernetes environment.
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 walks through building a functional Redis server in Go, focusing on transaction support (MULTI, EXEC, WATCH, UNWATCH, DISCARD), using locks for atomicity, version tracking for watch, and an undo‑log mechanism for rollback, with code examples and demo screenshots.
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.
This article walks through implementing a Redis‑compatible sorted‑set in Go, covering requirement analysis, data‑structure design with a map and skiplist, detailed insertion and search algorithms, complete code examples, and edge‑case handling, all illustrated with diagrams and sample output.
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.
This article walks through building an EasyRedis service in Go, explaining Redis's lazy and timed expiration strategies, showing concrete code for on‑read expiration checks, and detailing a time‑wheel implementation that efficiently schedules key deletions.
This article walks through the third part of an eleven‑article series that implements a functional Redis‑compatible in‑memory database in Go, detailing how the PING, AUTH, SELECT, SET and GET commands are parsed, routed and executed with concrete code examples.
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 walks through implementing a deep‑copy function in Go with the reflect package, explaining key concepts such as reflect.ValueOf, reflect.New, pointer handling, and recursive copying, and provides a complete code example and visual diagrams.
This tutorial walks through creating a lightweight Go ORM—covering a custom logger, converting structs to table metadata, implementing basic CRUD operations, handling transactions, and adding hook callbacks—while exposing the core Session data structure and providing a GitHub reference.
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.
This article walks through implementing EasyCache, a Go‑based in‑memory cache with sharding, lock‑free concurrency, LRU eviction, and configurable expiration, explaining the underlying data structures, goroutine cleanup logic, and key handling with concrete code examples.
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.
This article walks through implementing three load‑balancing algorithms (random, round‑robin, weighted round‑robin) in Go, explains the weighted selection math with step‑by‑step examples, and presents two service‑liveness solutions—heartbeat via Docker/Kafka and HTTP health checks—complete with code snippets and deployment commands.
This article walks through building a simple yet enterprise‑grade key‑value storage engine in Go, covering WAL implementation, LSM‑Tree structure, SkipList‑based in‑memory storage, transaction handling for Put/Get/Delete, and the on‑disk log format, with a complete 1,000‑line codebase hosted on GitHub.
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 article explains what distributed locks are, outlines their key properties, classifies implementation approaches, and provides detailed walkthroughs of MySQL, Redis, Etcd, and ZooKeeper based locks—including code examples, trade‑offs, and best‑practice recommendations.
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.
This article walks Go beginners through designing and implementing a lightweight RPC framework called easyrpc, covering protocol design, message serialization, network communication, graceful server shutdown, client stub generation with reflect.MakeFunc, and concurrent request handling, with full source code on GitHub.
The article explains how to obtain the rightmost node values at each depth of a binary tree by performing a level‑order (BFS) traversal, and provides a complete Go implementation that records the last node of every level as the right‑side view.
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 explains the classic coin change problem, models it as a minimum‑coin DP task, derives the recurrence relation, shows how to initialize the DP array with a large sentinel value, and provides a complete Go implementation that returns the optimal count or -1 when impossible.
This article explains how to merge overlapping intervals in Go by first sorting them by their start points and then iteratively combining adjacent intervals, with a complete code example and step‑by‑step reasoning.
This article explains the key steps for comparing dot‑separated version strings—ignoring leading zeros, handling different lengths, and performing left‑to‑right numeric comparison—accompanied by a complete Go implementation.
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 explains how to implement an O(1) LRU cache in Go by combining a hash table with a doubly linked list, detailing the put and get operations, eviction policy, and providing complete, ready‑to‑run source code along with illustrative diagrams.
This article explains how to decode nested strings formatted as k[encoded_string] by using a stack to record repetition counts and substrings, detailing the push/pop logic with examples like 2[a3[b]] and 3[a]2[bc] and providing a complete Go implementation.
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.
This article explains the LeetCode 39 "Combination Sum" problem, illustrates recursion with an apple‑picking analogy, details the backtracking algorithm pattern, and provides a complete, well‑commented Go implementation that handles unlimited reuse of candidates and pruning based on the target sum.
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.
This article explains how to solve LeetCode problem 162 (Find Peak Element) in O(log n) time using a binary‑search approach, detailing the three possible cases, providing pseudocode, and presenting a complete Go implementation that handles boundary conditions as negative infinity.
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.
The article explains how to detect a cycle in a singly‑linked list using fast and slow pointers, then locate the cycle’s entry node by resetting the slow pointer to the head and moving both pointers one step at a time, with full Go implementation provided.
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 explains how to solve the classic “longest substring without repeating characters” problem using a sliding‑window technique, detailing pointer management, duplicate detection, and a complete Go implementation.
The article explains a dynamic‑programming approach to the classic “Maximum Subarray Sum” problem, defining dp[i] as the best sum ending at index i, deriving the recurrence dp[i]=max(dp[i‑1]+nums[i], nums[i]), initializing base cases, and providing complete Go code.
This article explains a recursive solution in Go for LeetCode problem 92, detailing how to reverse a sublist of a singly linked list between given positions by first locating the start node, using a helper to reverse the first n nodes, and correctly reconnecting the remaining parts.
The article explains how to determine whether a given push sequence and pop sequence form a valid stack operation by using a temporary Go slice as a stack, iterating through the push list, and repeatedly popping while the top matches the next pop element, finally returning a boolean result.
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.
