During holidays, millions of users scramble for train tickets, overwhelming the 12306 system; this article dissects its high‑concurrency architecture, explains load‑balancing layers, demonstrates Nginx weighted round‑robin configuration, and provides a Go‑based spike simulation with Redis stock management and performance results.
This article explores Go's panic/recover mechanism, identifies which runtime errors can be recovered, explains unrecoverable scenarios like thread exhaustion and map race, demonstrates best‑practice error handling with Go 1.13 features and popular error libraries, and offers concrete logging strategies for robust server development.
This article analyzes Go's duck typing and interface mechanisms, explaining how interfaces are defined, implemented, and converted at runtime, including details of underlying structures like iface and eface, method sets, pointer vs value receivers, and type assertions, supplemented with code examples and assembly insights.
This article provides a comprehensive overview of Go, covering its naming history, reasons to choose it for server development, key milestones, garbage collection, error handling, module system, concurrency primitives, context management, engineering practices, and the upcoming Go2 evolution, while highlighting its relevance to cloud-native backend engineering.
This article provides a detailed walkthrough of the Kubernetes Job controller source code, explaining the flow from kube‑controller‑manager initialization through key functions such as NewJobController, Run, worker, syncJob, and manageJob, and illustrates how informers, workqueues, and expectations coordinate job lifecycle management.
This article explains how to use Makefiles to create custom build commands, define variables, handle recursive targets, incorporate shell output, add conditional checks, and generate help messages, providing practical examples for Go projects and general build automation.
This article explains what Go channels are, how they are implemented in the runtime, their data structures, creation, sending, receiving, closing semantics, common pitfalls, and includes detailed code examples to illustrate channel behavior in concurrent programs.
This article explains how a travel e‑commerce platform rebuilt its instant‑messaging service with Go, separating business logic, introducing a dual‑layer distributed architecture, and optimizing performance and reliability to handle massive concurrent connections and improve overall GMV.
This article walks through building a basic round‑robin load balancer in Go, covering the underlying principles, data structures, reverse‑proxy integration, atomic indexing, concurrency handling, health‑check mechanisms, and how to extend the implementation for production use.
This article explains the internal representation of Go slices, how they are created and initialized, the mechanics of append and capacity growth, slicing behavior, deep‑copy using the copy function, and whether slices are passed by value or reference, all illustrated with source code and assembly excerpts.
This article explains how to architect a high‑concurrency ticket‑seckill system that can handle one million simultaneous users buying ten thousand tickets, covering load‑balancing strategies, Nginx weighted round‑robin configuration, Go service implementation, Redis‑based inventory management, and performance testing results.
This article explains the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing, Nginx weighted round‑robin, local and remote stock deduction, Go implementation, Redis atomic scripts, and performance testing with ApacheBench.
This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, Go‑based local stock deduction, Redis‑backed unified inventory control, and performance testing with ApacheBench to achieve stable, scalable ticket sales during peak demand.
This guide explains how Spring Cloud Alibaba Sidecar enables zero‑intrusion integration of Go services into a Spring Cloud ecosystem, covering module setup, Maven dependency, YAML configuration, sample Go code, and testing with a Nacos‑based consumer.
This article explains the subtle difference between concurrency and parallelism using a ground‑hog and cart analogy, shows how task decomposition creates concurrent pipelines, and maps the model to scalable web‑service architecture, referencing Rob Pike’s talk “Concurrency is not Parallelism”.
This article walks through creating a lightweight TCP port scanner in Go, covering basic TCP handshake theory, single‑port testing, looping over ports, adding concurrency with WaitGroup, implementing timeouts, using the flag package for command‑line options, and handling race conditions with a mutex.
This article analyzes the 12306 ticket‑spike scenario, presents a distributed high‑concurrency architecture with layered load balancing, compares order‑creation strategies, demonstrates local and remote stock deduction using Go and Redis, and validates performance with ApacheBench testing.
This article traces the history of dubbo-go from its 2016 inception, describes its reconstruction by Ctrip in 2018, outlines its modular Apache‑licensed components, showcases cross‑language usage with Java Dubbo, and details its current features, roadmap, and cloud‑native ambitions.
This article explains how to design a high‑concurrency ticket‑sniping service that can handle millions of users by using multi‑layer load balancing, Nginx weighted round‑robin, local stock deduction, Redis for unified inventory, and a Go implementation with performance testing.
This article explores the design of a high‑concurrency ticket‑spike system, covering multi‑layer load balancing, weighted Nginx routing, pre‑deduction inventory strategies using Redis, Go implementation details, and performance testing that demonstrates handling millions of requests while preventing oversell and ensuring high availability.
This article dissects the extreme concurrency challenges of China's 12306 ticket‑spike scenario, presents a layered load‑balancing architecture, compares order‑processing strategies, and provides a complete Go‑based prototype with Nginx weighted routing and Redis atomic stock deduction, complete with performance testing and key takeaways.
This article analyzes the current state of multiple domestic and overseas CMS back‑ends, compares their codebases and performance, and proposes a unified Go‑based architecture with optimization steps to reduce maintenance cost and improve scalability.
This article explains how to build a high‑concurrency ticket‑seckill system using Go, Nginx weighted load balancing, and Redis, covering architecture design, local and remote stock deduction, Lua scripting for atomic operations, and performance testing with ApacheBench to achieve thousands of requests per second without overselling.
This article explains how to build a high‑concurrency train‑ticket flash‑sale system that can handle millions of requests by combining layered load‑balancing, Nginx weighted round‑robin, in‑memory stock deduction, Redis atomic Lua scripts, and a Go HTTP service with channel‑based concurrency control, and it provides performance test results and source code.
This article analyzes the architecture, load‑balancing strategies, stock‑deduction techniques, and Go/Redis implementation needed to support a million concurrent users purchasing ten thousand train tickets without overselling or underselling.
This article explores the architecture and implementation of a high‑concurrency train‑ticket flash‑sale system, covering load‑balancing strategies, weighted round‑robin Nginx configuration, local and remote stock deduction using Go and Redis, performance testing, and key lessons for building reliable, scalable services.
qrpc is a lightweight, high‑performance RPC framework that adopts gRPC's streaming and bidirectional concepts without HTTP/2, offering a smaller binary, lower memory usage, up to three‑fold throughput gains, and flexible modes such as blocking, non‑blocking, streaming, push, and bidirectional calls, all demonstrated with Go code examples and real‑world use cases.
This article explains Go's built‑in error interface, the traditional ways of creating and checking errors before Go 1.13, and the new errors.Unwrap, errors.Is, errors.As functions plus the %w verb in fmt.Errorf introduced in Go 1.13 for error wrapping and inspection.
This article walks you through deploying a WebSocket chat service and a gRPC ping service on Knative, covering repository cloning, Docker image preparation, Knative Service YAML configuration, kubectl deployment commands, and browser‑based verification to ensure the services run correctly in a serverless environment.
This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing architectures, OSPF/LVS/Nginx strategies, pre‑deduction inventory techniques, Go‑based HTTP services, Redis Lua scripts, and performance testing with AB, demonstrating how to achieve stable, scalable ticket‑purchasing under massive traffic.
This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering load‑balancing strategies, weighted Nginx configuration, in‑memory pre‑deduction, Redis Lua scripts, and Go implementation, and demonstrates its performance with real‑world stress testing.
This article provides a detailed source‑code walkthrough of Kubernetes' kube‑proxy IPVS load‑balancing mode, explaining the command‑line setup with cobra, the internal ProxyServer and Proxier structures, the BoundedFrequencyRunner, ServiceConfig handling, and the core syncProxyRules function that generates IPVS, iptables and ipset rules.
The series teaches mobile developers how to use Chrome’s Network panel and Wireshark, explains connection keep-alive, demonstrates HTTP 1.x head-of-line blocking with Go and OkHttp, and clarifies fixed-length versus chunked body transfer, providing practical code and traffic analysis for deeper protocol understanding.
This guide walks you through the challenges of manual API documentation, introduces Swagger as a powerful solution, and provides a step‑by‑step tutorial for integrating Swagger with Go projects using the Swag tool, Gin framework, and custom UI enhancements.
This article explains the controller pattern and declarative API in Kubernetes, dives deep into Kubebuilder's architecture—including GVK/GVR, Scheme, Manager, Cache, and Controller components—and provides step‑by‑step guidance with code examples for creating, configuring, and deploying custom resources and their controllers.
This article details how a high‑traffic trading app migrated from Node.js to Go, outlining Go's advantages, drawbacks, and the team's engineering practices—including environment management, dependency handling, efficiency tools, standardized libraries, testing, monitoring, and distributed tracing—to achieve robust, high‑performance backend services.
The article details the step‑by‑step architectural evolution of Mafengwo's instant‑messaging platform—from an initial PHP‑based monolith, through polling optimizations with OpenResty, to a Go‑implemented, micro‑service‑oriented design that improves scalability, reliability, and multi‑device synchronization.
This article walks through the fundamentals of Golang Context, explains how Knative Serving SDK leverages Context for informer and client initialization, and provides step‑by‑step code examples for building serverless applications, including logging, reconciler implementation, and practical deployment tips.
Over three years, Meitu’s long‑connection service “bifrost,” built in Go with MQTT, cut memory use from 22.3 GB to 5.1 GB for 210 k connections—and about 10 GB for a million—by tuning buffers, reducing allocations, employing memory pools, and replacing a goroutine‑per‑connection model with an epoll‑driven event architecture.
This article presents a comprehensive overview of Huajiao's gRPC development practice, covering background decisions, gRPC features, gateway integration, Dart and Go client libraries, component architecture, protobuf conventions, code generation, SDK integration, documentation tooling, debugging strategies, and future roadmap.
This article walks through building a simple RPC framework in Go using about 300 lines of code, covering RPC fundamentals, TLV network data format, serialization, transport layer, server and client implementations, and a complete example to help readers understand RPC concepts.
This article provides a comprehensive analysis of Go’s non‑generational concurrent mark‑and‑sweep garbage collector, tracing its evolution from early stop‑the‑world implementations to the mixed write‑barrier design in Go 1.8, and explains how to interpret GC traces, tune GC parameters, and reduce latency caused by mark‑assist and STW pauses.
This article explains the drawbacks of using a vendor directory in Go projects, outlines how Go module proxy solves those issues, and provides step‑by‑step guidance on configuring GOPROXY, choosing public or self‑hosted proxies, and recent Go 1.13 enhancements.
Go‑Spring is a Go‑language application framework that brings Spring‑style conventions such as dependency injection, auto‑configuration, starter modules, interface‑based design, and integrated testing to developers, enabling organized code, easy component swapping, configuration binding, and full‑stack unit tests while supporting databases, messaging, and microservice features.
This article examines Go's memory allocation mechanisms in version 1.12.6, detailing the roles of spans, mcache, mcentral, and mheap, explaining tiny, small, and large object handling, and describing GC and heap reclamation improvements for efficient runtime performance.
This article revisits the author’s earlier talk on software architecture, reorganizes and expands it with detailed explanations of Clean Architecture’s layered design, dependency rules, and related concepts such as DDD, while reflecting on how these ideas can reduce code modification difficulty and guide personal growth as an architect.
The article demonstrates how Go’s built‑in pprof tools can be used for live performance profiling, walking through two real‑world cases—one where a malformed JSON request caused massive object allocation and CPU spikes, and another where per‑call self‑referencing structs leaked memory—while offering practical tips on input validation, allocation reduction, and GC monitoring.
This article explores the challenges of building layered, flexible database queries in Go, compares GORM, sqlx, and squirrel, and proposes a custom, option‑based query‑builder pattern that stays idiomatic and extensible for complex search scenarios.
This article enumerates ten frequent Go programming errors—from unknown enum handling and benchmark mis‑optimizations to pointer misuse, slice initialization, context pitfalls, and error‑handling practices—explaining why they occur, showing reproducible code examples, and offering concrete fixes to write more reliable Go code.
This guide walks through building a Go REST‑API, containerizing it, deploying multiple Knative Service revisions, configuring traffic percentages for gray releases, validating revisions before traffic shift, and rolling back, while comparing Knative’s traffic‑driven model to traditional pod‑based deployments.
This article chronicles the evolution of MaFengWo's instant‑messaging platform, detailing the transition from a simple PHP implementation to OpenResty optimizations, the introduction of multi‑mode routing in IM 2.0, and a complete service‑oriented redesign in Go for IM 3.0, while addressing scalability, multi‑device synchronization, and message reliability.
This article provides a comprehensive walkthrough of using Go's crypto library for hashing, symmetric and asymmetric encryption, certificate generation, and TLS/HTTPS server and client implementation, illustrating how these techniques are applied in kubeadm to simplify Kubernetes cluster security.
This article describes how a PHP‑based backend service integrates Adobe After Effects' command‑line renderer and FFmpeg to generate, split, concatenate, and compress user‑uploaded video templates for a mini‑program, covering architecture, workflow, code snippets, and performance optimizations.
Gaea is an open‑source MySQL middleware created by Xiaomi that replaces MyCAT, offering read‑write splitting, sharding, namespace‑based multi‑tenant configuration, Go‑driven architecture, hot‑reload via etcd, comprehensive monitoring, and a visual management console, with its source hosted on GitHub.
This article describes how a PHP‑based backend service integrates After Effects' aerender command‑line tool and FFmpeg to automatically generate, split, compress, and deliver video templates for a mini‑program, covering requirement analysis, architecture, rendering workflow, code snippets, and performance optimizations.
This article explains how the Go community drives the future "Go 2" language updates through a standardized proposal selection and evaluation workflow, shows how to locate proposals on GitHub using specific labels, and points to official releases and blog resources for early access and detailed information.
This tutorial explains how to implement a simple LL(1) parser in Go for SQL queries, covering lexical analysis, syntax analysis, finite‑state‑machine strategy, and testing, providing complete code snippets and practical guidance for developers interested in parser construction.
This tutorial explains Linux inotify's event model and demonstrates how to employ the Go package golang.org/x/sys/unix to initialize inotify, add watches, and process file system events in order to achieve automatic configuration file hot‑reloading in Go applications.
This tutorial explains how to implement hot‑reloading of Go configuration files by manually sending Unix signals, covering the creation of a signal‑listening goroutine, use of the signal.Notify API, selective handling with select, and a complete example that loads JSON config on SIGUSR1.
This interview with Ctrip's He Xinming details the motivation, architecture, features, performance benchmarks, and future roadmap of dubbo-go, the Go language implementation of Apache Dubbo, highlighting its role in bridging Java and Go microservice ecosystems and its cloud‑native aspirations.
By applying Mike Cohn’s testing pyramid to a Go scheduling service, the author demonstrates a structured approach that combines straightforward unit tests, organized integration suites with setup/teardown hooks and coverage scripts, expressive GoConvey assertions, and end‑to‑end trace‑ID verification, while noting remaining gaps.
gobox is a self‑developed lightweight Go framework comprising various utility boxes such as color, crypto, exception, gohttp, golog, and gomisc, with detailed explanations of its origin, naming, supported modules, and extensive code examples demonstrating usage for logging, error handling, slice deduplication, file checks, JSON handling, and time utilities.
The article presents a comprehensive overview of the challenges, evolution, design principles, and concrete implementation techniques behind building a large‑scale microservice framework at Didi, illustrating how systematic abstraction, reliable I/O handling, and strict interface stability can dramatically improve development efficiency and system robustness.
The article walks through Go’s 1.9.2 scheduler on Linux, explaining how the three abstractions—G (goroutine), M (OS thread), and P (processor)—are created, bound, and used in the scheduling loop to run, yield, and balance goroutines via local, global, and stolen queues.
In his Go China talk, senior Didi engineer Du Huan outlined the design and implementation of a large‑scale microservice framework that abstracts I/O, injects tracing via protocol hijacking, optimizes timers, and enforces fail‑fast circuit breaking, delivering faster development, higher stability, seamless upgrades, and a unified operating‑system‑like layer for thousands of services.
Go’s reflection, accessed via the reflect package’s TypeOf and ValueOf functions, lets programs inspect and modify runtime types and values—including fields, tags, and slices—while obeying settable rules, enabling generic utilities such as JSON serialization, deep equality checks, and dynamic ORM-like behavior.
This article shares practical guidelines and a detailed directory layout for organizing Go projects, illustrated with the gobox-demo template, covering configuration, source code organization, controller/action separation, service layer structuring, and best‑practice recommendations for clean, maintainable backend development.
The article thoroughly examines Go’s interface system, explaining static duck typing, the differences between value and pointer receivers, the internal iface/eface structures, how interfaces are constructed and converted, compiler implementation checks, type assertions, runtime polymorphism, and contrasts these mechanisms with C++ abstract‑class interfaces.
SQLFlow, an open‑source project from Ant Financial, bridges SQL engines and AI frameworks so that users can train and predict machine‑learning models with simple SQL statements, dramatically lowering the technical barrier for analysts and engineers across diverse data platforms.
SQLFlow is an open‑source project that connects diverse SQL engines (MySQL, Hive, SparkSQL, etc.) with AI frameworks (TensorFlow, PyTorch, XGBoost, etc.) through extended SQL syntax, enabling analysts to train and predict models using only a few SQL statements while aiming for high scalability and performance.
The Shanghai Go technology salon brought together senior architects from QuTouTiao, Qiniu, and Bilibili to share real‑world implementations of Service Mesh, full‑link tracing, and microservice governance using Go, highlighting practical challenges, solutions, and future directions.
The article explains Go slices as three‑field descriptors pointing to an underlying array, details creation methods, shows the low‑level runtime representation and assembly for make, describes how append triggers growslice with capacity‑doubling or ~25 % growth and alignment, and clarifies sharing, nil slices, and passing semantics.
Go’s syscall mechanism uses assembly‑implemented entry functions like Syscall and Syscall6 to invoke the kernel, while the runtime’s entersyscall and exitsyscall hooks notify the scheduler, allowing P resources to be released during blocking calls and handling privileged low‑level syscalls separately.
The Shanghai Go Language Tech Salon, co‑hosted by Qutoutiao and Jikebang, gathered senior architects from Qutoutiao, Qiniu, and Bilibili to share real‑world implementations of Go, covering a self‑built Service Mesh, full‑link tracing, and microservice governance, followed by an interactive Lean Coffee discussion on Go’s future.
This article reviews HTTP/2's core features such as binary framing, multiplexing, header compression, and server push, evaluates their performance benefits and real‑world limitations, discusses implementation challenges in Go and proxy servers, and provides references for further study.
This article explains the original design goals of Go, outlines its key features and advantages such as fast compilation, simple syntax, powerful concurrency, and easy deployment, and compares it with languages like Java, C#, C/C++, JavaScript, Python, Scala, and Erlang.
This article demonstrates how to add on‑demand and periodic HTTP/2 server‑push functionality in Go, explaining the required handlers, showing complete Go code examples, and detailing the HTTP/2 frame exchange observed with an h2c client.
This article explains the internal architecture of Spark Operator, covering Kubernetes operator fundamentals, CRD definitions, code layout, job submission flow, state machine handling, monitoring integration, and troubleshooting techniques for reliable Spark workloads on Kubernetes.
This article details ByteDance's migration to Go for its backend, covering the reasons for choosing Go, the design of a five‑tuple microservice architecture, concurrency models, timeout handling, performance tuning, monitoring, and engineering practices that enabled a production system handling over 300 billion daily requests.
This article demonstrates how to build a minimal HTTP/2 server in Go that responds only with header frames, covering certificate generation, server code, frame structures, the http2Framer API, and how to test the implementation using curl, providing both conceptual explanations and full source listings.
This article explains HTTP/2's header compression using the HPACK format—including static and dynamic tables, Huffman coding, and literal encoding—and the Server Push mechanism with PUSH_PROMISE frames, illustrating how these features reduce bandwidth and improve request latency.
In this interview, Didi R Lab senior engineer Du Huan discusses his decade‑long Go experience, the language’s low‑cost entry, system‑level performance and cloud‑native strengths, upcoming enhancements like generics, his large‑scale microservice framework design for Gopher China 2019, and practical advice for developers and enterprises adopting Go.
This article provides a comprehensive overview of HTTP/2, explaining its binary framing, multiplexing, and the various frame types such as DATA, HEADERS, PRIORITY, RST_STREAM, SETTINGS, PUSH_PROMISE, PING, GOAWAY, WINDOW_UPDATE, and CONTINUATION, with specific focus on how Go's HTTP server implements these features.
To implement a graceful hot restart for a Go HTTP service, the program listens for SIGHUP, forks a child process that inherits the listening socket via an extra file descriptor, the parent stops accepting new connections and shuts down while the child begins serving, ensuring uninterrupted client requests.
This article explains how Alibaba's open‑source PouchContainer adds both unit‑test and integration‑test coverage reporting using Go's cover tool, TravisCI, Codecov, and custom test harnesses, providing step‑by‑step commands, code snippets, and PR details to raise overall coverage from 18% to 60%.
This article presents SlimTrie, a trie‑based indexing structure that dramatically reduces memory consumption while maintaining fast query speeds, detailing its design, compression techniques, implementation steps, memory analysis, and performance comparisons with map and B‑Tree structures for large‑scale storage systems.
This article explains the inner workings of the Kubernetes scheduler, covering its architecture, pod queue handling, filtering, prioritization, binding, preemption, and code-level details, while also discussing current limitations and future enhancements such as the V2 framework and gang scheduling extensions.
The article details the step‑by‑step evolution of the WeChat‑like instant messaging platform at 58 Group, describing how the system transitioned from a simple PHP short‑connection architecture to a layered micro‑service architecture using Java‑based RPC, Go‑based short‑connection services, distributed storage, message queues, and clear separation of storage, logic, and interface layers.
This article recounts the migration of the Core Course (CC) service from a custom Ruby RPC framework to a Go‑based gRPC solution, detailing technical choices, performance bottlenecks, testing strategies, monitoring setup, and the substantial improvements achieved after launch.
This article introduces Go’s basic program structure, how to run and build Go applications, the role of comments, why semicolons are omitted, and best practices for organizing imports, providing a concise foundation for writing clean Go code.
This article provides a step‑by‑step guide on installing the Protobuf compiler, setting up the Go plugin, writing .proto definitions, generating Go code, and demonstrating serialization and deserialization of Protobuf messages in a Go application, complete with troubleshooting tips and reference links.
This article presents a comprehensive overview of Ant Financial's ServiceMesh implementation, detailing the background, architecture, key features of SOFAMesh and MOSN, technical case studies, performance benchmarks, security capabilities, and future outlook for cloud‑native network proxies.
Zhihu’s backend team migrated high‑traffic services from Python to Go, detailing the motivations, step‑by‑step migration process, performance gains, project structure, testing practices, static analysis, and operational lessons such as graceful traffic shifting and service deprecation.
This article introduces core Go concepts—including slice internals, common pitfalls when using slices and maps, type conversion techniques, function parameter behavior, and a stack‑overflow‑safe directory‑listing example—providing practical code snippets and guidance for reliable Go development.
This article explains how etcd stores and retrieves multiple revisions of a key using a B‑tree index, details the read and write paths, describes index restoration on startup, and shows how the watch subsystem delivers change events to clients, all illustrated with Go code snippets.
This article translates David Cheney's 2014 Gocon talk, detailing five Go language features—efficient value handling, inlining, escape analysis, goroutine scheduling, and dynamic stack management—that together explain Go's performance advantages, memory usage, and concurrency model.
Naftis is an open‑source web dashboard for Istio that lets users define custom task templates, manage services, view topology and metrics, and provides step‑by‑step Kubernetes deployment instructions, Docker images, and a complete developer guide for building and running the platform.
The article investigates a Go 1.8.3 issue where goroutines block on ForkLock during fork‑exec, analyzes the kernel and Go runtime behavior, presents a hypothesis about memory‑heavy processes, validates it with experiments, and shows that upgrading to Go 1.9 or later eliminates the problem.
This article explains the fundamental differences between Go arrays and slices, describes their memory layout and value semantics, illustrates various slice declaration forms, and details the rules governing slice capacity growth with example code and visual diagrams.
The article describes how to build a Go‑based backend for a WeChat lottery mini‑program using the Echo framework, Tencent Cloud load balancer, Nginx, Redis and MySQL, detailing the system architecture, API design, database and Redis integration, WeChat login flow, activity state machine, and lessons learned.
