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.
This article details the preparation of the development environment, choice of Go and gopacket, MongoDB integration, the multi‑threaded architecture for real‑time packet capture, and a series of performance optimizations addressing slow logs, packet loss, and CPU usage.
Xiaomi is open‑sourcing its Go‑based SQL Optimizer and Rewriter (SOAR) at OSCAR Days, a tool that automatically checks SQL quality, suggests index improvements, rewrites queries, provides EXPLAIN analysis, and integrates with editor plugins and a web self‑audit platform to boost database reliability and developer productivity.
This article explains what a non‑reentrant function is, why it matters in concurrent Go programs, and demonstrates two practical implementations—using a sync.Mutex and an atomic flag—to ensure a function runs only once at any given time.
This article shares practical Golang notes, covering compilation, package structure, basic syntax, common pitfalls like GOPATH issues, and step‑by‑step screenshots of setting up a Hello World program in Eclipse.
This article demonstrates how to build an HTTP/2 server and client in Go, covering TLS certificate generation, server and client implementations, switching between HTTP/1.1 and HTTP/2, server‑push handling, and full‑duplex echo communication with complete code examples.
This article describes the shortcomings of a legacy log‑collection architecture, proposes a streamlined real‑time design that centralises configuration in Etcd, uses a single Go‑based logagent to tail files, applies per‑service rate limiting, and forwards logs to Kafka for downstream processing.
This article explains how Kubelet obtains pod configurations, processes updates through its syncLoop, coordinates pod workers, and ultimately invokes the container runtime's SyncPod method to keep node pods aligned with the desired state.
This article explains how Go organizes source files into packages, the difference between import paths and package names, how the compiler chooses between source code and compiled .a files, the role of import aliases, and why a directory can contain only one package.
The article describes how a DBA team at Ele.me transformed manual database management into a fully automated, platform‑driven operation covering monitoring, alarm handling, MHA automation, resource pooling, large‑scale migration, SQL review, and multi‑active DDL release using Go‑based tools and custom workflows.
The article details Alibaba’s Sigma scheduling and cluster management platform—its three‑layer architecture, data and state consistency strategies, real‑world case studies, Go‑based redesign, integration with Kubernetes APIs, and lessons on concurrency, high availability, and pod dispersion for massive Double 11 traffic.
The article examines Uber’s high‑throughput Go logging library zap, detailing its structured‑logging design, separation of concerns, copy‑on‑write filtering, extensive sync.Pool object reuse, reflection‑free type‑specific encoding, dynamic HTTP level control, and supplemental features such as a sugar API and log‑rotation, which together deliver superior performance over traditional libraries.
This article analyzes Uber's open‑source Go logging library zap, explaining its architectural trade‑offs, performance‑boosting techniques such as object pooling, reflection avoidance, and write‑time copying, and offers practical guidance for developers who want to build high‑performance logging components in Go.
This guide walks you through every step of learning Hyperledger Fabric—from setting up the environment and deploying single‑ and multi‑node networks to developing, installing, and testing chaincode with Java SDK—providing a hands‑on roadmap for blockchain developers.
This article explains frequent pitfalls in Go programming—including file‑naming conventions, defer execution order, panic value handling, for‑range copying, struct composition, init function behavior, pointer operations, command‑line arguments, slice capacity bugs, map usage, and channel communication—while providing clear examples and recommended fixes.
This article explains Go's concurrency foundations, detailing the difference between concurrency and parallelism, the CSP model using goroutines and channels, and the internal M‑P‑G scheduler architecture that balances work across processors and system threads.
This article explains the fundamentals of database transactions, introduces Vitess's architecture, and details how Vitess implements a two‑phase commit protocol for distributed transactions, including transaction IDs, metadata management, preparation, commit, rollback, error handling, and performance considerations, with illustrative Go code snippets.
This article explains Vitess’s two‑phase commit mechanism for distributed transactions, covering the ACID properties, shard architecture, transaction manager roles, detailed code flow, metadata handling, preparation, commit, rollback, and various failure scenarios, along with practical examples and performance considerations.
This article walks through upgrading Consul to 1.2, configuring service‑mesh support, building two Go micro‑services, registering them with Consul, reloading the configuration, testing the mesh with curl, and provides a detailed analysis of Consul’s service‑mesh architecture, advantages, and limitations.
Meituan Finance reduced user churn by replacing Node‑based diff generation with a Go‑powered incremental‑update service that uses lightweight goroutines, a three‑layer CDN/API/compute architecture, and pre‑warmed patches, achieving 99.97 % success, 64.9 % incremental updates and roughly 164 KB daily bandwidth savings per user.
This article explains Go's channel feature, covering its design philosophy, channel types (bidirectional and directional), core operations such as send, receive, close, capacity queries, detailed execution rules for different channel states, and includes several illustrative code examples.
This article explains Go's channel primitive in depth, covering its conceptual model, types, operations, internal queues, rule scenarios, practical code examples, and best‑practice tips for building clear and efficient concurrent programs.
This article explains the history and architecture of PostgreSQL's Foreign Data Wrapper (FDW), details the required database objects and callback functions, and provides a step‑by‑step guide for implementing an FDW in Go using cgo, including code examples, build instructions, and performance considerations.
PhoenixGo, an open‑source Go AI built on AlphaGo Zero's reinforcement‑learning algorithm, leveraged Tencent's idle cloud servers to achieve professional‑level play, won the 2018 World AI Go Championship, and was released with a strong model for researchers and hobbyists alike.
This article describes the motivation, requirements, solution research, and detailed design of a lightweight distributed VPN built with Go, employing KCP as the transport protocol, and includes prototype source code for both hub and peer components.
This article explains how to create HTTP middleware in Go, covering request reading, trailing‑slash redirection, request‑ID injection, server header manipulation, custom ResponseWriter implementation, and handling of additional interfaces such as Push and Flush, with complete code examples.
When running an Ethereum full node, Geth can panic with a runtime error "index out of range" caused by LevelDB's shortenb function exceeding its unit array, especially once the database size reaches terabytes, and a simple code tweak can prevent the crash.
This tutorial explains the fundamentals of Proof‑of‑Stake, compares it with Proof‑of‑Work, and provides a step‑by‑step Go implementation of a PoS blockchain with TCP networking, validator selection, and code snippets for building and running the system.
At GopherChina 2018, Didi engineer Shi Songran explained how Go powers the company’s high‑availability order, dispatch, and storage systems, detailing service‑governance practices, two production‑level bugs, and Didi’s open‑source contributions of the gendry database helper and the high‑performance json‑iterator codec.
When the low‑quality app "XX段子" was forced to close, Douyin faced a massive comment surge and responded within minutes by disabling the comment service through circuit‑breaking, illustrating the crucial role of microservice governance, monitoring, and rapid fault isolation in large‑scale backend systems.
This article introduces Tendermint’s modular blockchain framework, explains its Core and ABCI components, provides step‑by‑step installation and execution of the built‑in key‑value store example, demonstrates transaction creation and querying, and walks through the Go source code for CheckTx, DeliverTx, and Commit functions.
The article examines the advantages and drawbacks of microservices versus monolithic architectures, outlines key factors that influence the decision to split, and walks through a real‑world shared‑points project, detailing a four‑step process for decomposing a monolith into independent services.
This article dissects the Go implementation of Ethereum’s eth.syncing API, explaining the Syncing method, the SyncProgress struct, how block synchronization statistics are gathered, and how different sync modes affect the returned values, all illustrated with real source code excerpts.
In Ethereum v1.7.3 the console command miner.start() always returns null, regardless of whether mining actually starts, because the underlying Go implementation returns nil and the real status is logged or inferred from other API calls, not from the return value.
This article examines the three Ethereum Geth synchronization modes—fast, full, and light—by dissecting the underlying Go source code, explaining the SyncMode type, its constants, string and marshaling implementations, default configuration, and the runtime logic that switches modes based on blockchain state.
When an Ethereum transaction runs out of ether to cover the gas limit multiplied by the gas price plus the transfer value, the client throws an “insufficient funds for gas * price + value” error, and this article explains the underlying code logic and troubleshooting steps.
The article explains how Ethereum nodes that expose an unrestricted unlock duration of 300 seconds allow attackers to steal ether by exploiting the default account unlock window, and it provides code analysis and practical mitigation steps to secure the node.
This article explains the architecture and key technologies of 360’s SSP advertising engine—including flexible micro‑service layers, DAG‑based topology, rule and template management, and high‑performance Go‑based HTTP frameworks—that enable billion‑scale ad delivery with low latency and high concurrency.
MesaLock Linux is an open‑source Linux distribution that rewrites user‑space applications in memory‑safe languages like Rust and Go, applying three security principles to reduce attack surface, offering container‑ready images, BSD licensing, and community‑driven development.
The two‑day Tongcheng Technology Conference in Suzhou featured six technical sessions covering serverless architecture, microservices with Go, Facebook‑style development tools, NewSQL database practices, hybrid cloud management at Sina Weibo, and high‑performance ticket search systems, offering practical insights for backend engineers.
This article delves into Go's channel mechanism, explaining its three core signal properties—delivery guarantee, state, and data presence—while providing clear code examples for unbuffered, buffered, and context‑based channels to help developers write reliable concurrent programs.
This article explains how to replace repetitive manual Go commands like "go build" and "go test" with a well‑structured Makefile, covering variable definitions, common targets, cross‑compilation, Docker builds, and usage examples to streamline and automate Go project workflows.
This article recounts Xiaomi's rapid development of a high‑concurrency flash‑sale platform for the 2014 "Mi Fan Festival", detailing the design choices, trade‑offs, and performance optimizations that enabled millions of users to purchase phones simultaneously.
This article critically examines Go’s advertised sub‑10 ms garbage‑collection pauses, compares its concurrent mark‑sweep collector with Java’s GC algorithms, and explores the fundamental trade‑offs of throughput, pause time, memory overhead, and scalability that shape modern garbage‑collector design.
This article explains how Go’s compiled single‑binary output, static type system, superior performance, built‑in libraries, and strong IDE support helped a micro‑service platform replace a Python/Django stack, cutting code by 64% and boosting backend speed by up to 30%.
This article explains why HTTPS is essential, compares third‑party and self‑managed TLS options, and provides a complete Go implementation using Let’s Encrypt’s autocert library, including code for certificate handling, HTTP‑to‑HTTPS redirection, DNS requirements, and caching strategies.
The July 2017 TIOBE index shows Go leaping from rank 55 to the top ten, while Java remains first despite a 6% drop, and other languages like Kotlin, Elixir, and Hack fall, highlighting shifting popularity among the top programming languages.
This article details Huajiao's transition from an Erlang‑based chat system to a Go‑driven QChat architecture, covering language selection, component redesign, deployment strategies, flow‑control mechanisms, and four‑layer proxy testing that together enabled massive scaling for live streaming comment and gift traffic.
This article examines how different server‑side languages model I/O, compares blocking and non‑blocking approaches in PHP, Java, Node.js, and Go, and presents benchmark results to help you choose the most suitable technology for high‑load web applications.
This article examines how different server‑side languages model I/O, compares blocking and non‑blocking approaches, discusses scheduling overhead, presents sample code for PHP, Java, Node.js, and Go, and offers benchmark insights to help developers choose the right technology for high‑load web applications.
This article chronicles the multi‑year architectural evolution of Tongcheng Travel's push notification platform, detailing early batch‑job designs, successive redesigns using Redis, MongoDB, Kafka, Go, and .NET, and the performance, scalability, and operational improvements achieved through each major version.
The author rewrote a Laravel‑based Boxzilla application in Go, detailing migration steps, code‑size reduction, benchmark results, and testing advantages, showing how Go delivers faster response times, lower latency, and a more maintainable backend.
The article examines why Go is well‑suited for high‑concurrency, complex communication distributed systems like the 360 message‑push platform, detailing its performance, architecture, challenges, optimization techniques, and operational monitoring compared with traditional C implementations.
This article details the design and implementation of a Go‑based backend for a ride‑hailing app, covering real‑time vehicle tracking, route planning with OSRM, bandwidth‑saving UDP + ProtoBuf communication, in‑memory storage, R‑tree indexing, and the full API workflow.
