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.
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.
An investigation of a 100k‑QPS Go monolith revealed that intermittent availability drops were caused by a memory‑leak in the third‑party gcache LFU implementation, which inflated GC work and produced long mark phases; upgrading gcache eliminated the leak and restored 0.999+ availability, highlighting the need for thorough observability and dependency monitoring.
This article explains why unit testing is essential for Go development, compares the legacy 2.0 approach with the new 3.0 plugin, details the plugin architecture, execution flow, code snippets, and shows real-world adoption results with clear HTML reports.
The article explains how Go's short variable declaration (:=) can cause variable shadowing across scopes, demonstrates the effect with a sample program, and recommends using the golangci-lint static analysis tool to automatically detect such hidden bugs.
