This article explains how Go's runtime initializes, allocates, expands, and shrinks goroutine stack memory, detailing the underlying heap structures, global pools, platform‑specific constants, and the code paths that handle stack growth and reclamation.
This tutorial walks through a complete Golang implementation of a food‑recommendation API using Domain‑Driven Design (DDD), covering the four DDD layers, entity and repository definitions, persistence setup with Gorm, application services, HTTP interfaces, middleware, and how to run the service.
This article walks through a complete Go implementation of a food recommendation API using Domain-Driven Design, covering project setup, layer separation, entity and repository definitions, infrastructure configuration, application services, HTTP interfaces, authentication, and how to run the application.
This tutorial introduces Go's core concepts—including package structure, built‑in types, variable and constant declarations, and function definitions—explaining syntax nuances, import styles, type creation, and initialization patterns to help beginners quickly become productive in Go.
This article examines seven modern programming languages—Rust, Go, Kotlin, TypeScript, Swift, Dart, and Julia—detailing their key features, typical use cases, popularity trends, and why developers should consider learning them to stay competitive in today's software landscape.
The article examines recent TIOBE rankings and explores how emerging languages such as Go, Rust, Swift, Dart, and Kotlin compare to established giants like C, C++, Java, and JavaScript, analyzing their design goals, adoption, and prospects for replacing legacy code.
This article explains practical techniques for drastically reducing Docker image sizes—including Go binary static linking, Alpine vs. slim base images, multi‑stage builds for Java, Rust, and interpreted languages, and detailed size comparisons—so developers can choose the optimal base image and build strategy for any language.
This guide explains how the qrcp command‑line tool creates a temporary web server, encodes its address in a QR code, and enables fast, cross‑device file transfers, covering installation via Go or binary, usage commands, network‑interface selection, and practical examples.
This guide explains how qrcp creates a QR‑coded URL to bind a temporary web server for seamless file transfers between computers and mobile devices, covering its inner workings, installation via Go or binary releases, and detailed command‑line usage for sending and receiving files.
This article explains how to design, implement, and deploy a high‑performance Go service that uses an upgraded sego tokenizer to load custom sensitive‑word dictionaries, provide JSON‑RPC detection, support hot‑reloading, and scale across multiple data centers for live‑stream platforms.
This guide walks through enabling the Windows Subsystem for Linux, installing Ubuntu (or other Linux distributions) from the Microsoft Store, creating a user, updating packages, and installing Go tools, with step‑by‑step screenshots and command examples for developers on Windows 10.
This article explains how Go's sync.Cond works, demonstrates its usage with practical code examples, analyzes its internal implementation, and shows a real‑world application in Kubernetes FIFO queues, helping developers control goroutine synchronization effectively.
This article details a production incident where a Go backend service returned "connection reset by peer" due to exhausted process file descriptors caused by a saturated database connection pool, and describes the step‑by‑step troubleshooting, socket internals, and the eventual fix.
This article demonstrates how to quickly generate large volumes of test data for a MySQL table using the open‑source mysql_random_load_data tool, describing the setup, performance, and advantages over traditional stored procedures or custom scripts.
This article explains how Go handles exceptions and errors using defer, panic, and recover, compares it with try‑catch in other languages, demonstrates the built‑in error interface, custom error types, and provides multiple code examples and analyses of their output.
This article describes how a Go‑based message‑push service migrated to a Kubernetes‑Docker container platform exhibited unexpectedly high CPU usage, the step‑by‑step profiling with go‑tool pprof and flame graphs, analysis of the Go GMP scheduler, and the resolution by configuring GOMAXPROCS to match the container‑allocated cores.
This article, the fourth in a series on building a Raft consensus module in Go, explains how to add persistent state, improve command delivery semantics, optimize AppendEntries handling, and handle crash tolerance, while providing concrete Go code examples and practical testing tips.
This article explains how to extend a Go implementation of the Raft consensus algorithm to handle client commands, replicate logs across the cluster, manage commit pipelines, and ensure election safety, while providing detailed code examples and discussion of underlying concepts.
This article explores how to design a high‑concurrency ticket‑booking service capable of handling millions of simultaneous requests by combining distributed load‑balancing, Nginx weighted round‑robin, Go micro‑services, and Redis atomic inventory management, complete with code samples and performance benchmarks.
This article, the second in a series on Raft, explains the election mechanism, server states, timers, RPC handling, and partition scenarios while providing complete Go code examples for the consensus module and its interactions.
The article details how a Go middleware QA team generates unit‑test coverage with go test and gocov, runs static analysis via golangci‑lint, integrates results into SonarQube, captures integration‑test coverage in Kubernetes, and applies diff‑cover for incremental coverage checks, all visualized through Jenkins.
This tutorial explains how to download and install the Go language, configure the environment, and introduces popular Go web frameworks such as Beego, Iris, and Buffalo, followed by step‑by‑step instructions for installing Beego and creating a Hello World application.
This article walks through creating a Go‑based multi‑cloud management platform by leveraging each cloud provider's open APIs, demonstrating how to use curl and Go HTTP requests to query Tencent Cloud's DescribeRegions endpoint, generate the required signature, and integrate the results into a unified dashboard, reducing operational overhead across diverse cloud environments.
This article provides a thorough introduction to the Raft consensus algorithm, explaining its purpose, core components such as state machine replication, log and consensus module, leader‑follower model, client interaction, fault‑tolerance considerations, the CAP trade‑off, and why Go is a suitable implementation language.
This article explains what a sync.Pool object pool is, when it should be used, details the Go 1.12 implementation with its internal structures and algorithms, describes the enhancements introduced in Go 1.13, and analyzes the resulting performance improvements for high‑concurrency backend applications.
This article explains Go's method sets, the relationship between receivers and method sets, how interfaces work, and the nuances of embedding both value and pointer types, providing clear code examples and practical insights for Go developers.
This article provides a comprehensive beginner-friendly guide to gRPC, covering its definition, the protobuf syntax for defining messages and services, field constraints, supported data types, usage of the protoc tool, and complete Go examples for both server and client implementations.
This article explains how a large e‑commerce platform replaced a MySQL‑centric intermediate table with a binlog‑driven pipeline that streams changes through Kafka into Elasticsearch, ensuring ordered, complete, and low‑latency data synchronization while addressing schema evolution and operational monitoring.
This article examines classic smooth upgrade strategies for HTTP services, highlights their limitations, and provides a detailed analysis of Facebook’s graceful restart library for Go, including code examples, signal handling, process inheritance, and the mechanisms for zero‑downtime deployments.
This article explains how to achieve graceful, zero‑downtime restarts for long‑living TCP services by passing open file descriptors through a Unix domain socket, allowing new processes to inherit existing connections without interrupting clients, and provides a complete Go demo implementation.
This article walks through building a simple Go web service, containerizing it, pushing the image to a registry, and then exploring how Kubernetes API Server authenticates clients with mutual TLS and how the scheduler’s pre‑filter and scoring phases decide the optimal node for a pod, complete with code snippets and log analysis.
This article explains the principle of jump consistent hashing, compares it with traditional ring‑based methods, shows a step‑by‑step implementation with Go code, and discusses its performance advantages and potential optimizations for distributed key‑value storage systems.
The article surveys 2020 DevOps trends, covering cloud‑native adoption, container registries, Go's role, heightened security, serverless growth, multi‑cloud strategies, and real‑world case studies, while highlighting key performance metrics and market forecasts for the next few years.
This article explores the challenges of massive ticket‑buying spikes during holidays, explains the multi‑layer load‑balancing architecture, presents Go and Nginx configurations for weighted routing, demonstrates Redis‑based pre‑deduction of stock with Lua scripts, and shares stress‑test results showing thousands of requests per second on a single node.
This article introduces Huajiao's open‑source backend services—gokeeper, pepperbus, peppercron, and dashboard—detailing their features, architecture, and step‑by‑step Docker‑based deployment, configuration, and usage with Go code examples for service discovery and distributed cron management.
This article presents Bilibili's exploration of microservice governance, detailing the challenges of service splitting and large‑scale management, the design and evolution of its Go‑based Discovery service discovery framework, advanced load‑balancing algorithms, adaptive rate‑limiting, circuit‑breaking strategies, and future directions for resilient backend systems.
This article details a practical experiment that reproduces the load of 100 billion WeChat red‑packet (shake‑and‑grab) requests by simulating 1 million concurrent users on a single machine, achieving peak QPS of 60 k and demonstrating the architectural choices, hardware setup, and monitoring techniques required for such high‑throughput backend systems.
This guide explains how to use Xiaomi's open‑source Gaea middleware to achieve automatic MySQL read/write separation, covering Go environment setup, Gaea compilation, configuration files, Docker deployment, testing procedures, and integration with SpringBoot.
This guide introduces Huajiao Live’s newly open‑sourced backend components—Gokeeper for centralized configuration and service discovery, Pepperbus for message bus, Peppercron for distributed cron management, and the Dashboard UI—providing repository links, Docker images, installation steps, configuration formats, code examples, and operational details for quick deployment.
This article presents seven practical Go performance optimization techniques—including using sync.Pool, avoiding pointer‑heavy maps, generating marshal code, leveraging strings.Builder, preferring strconv over fmt, pre‑allocating slices, and passing byte slices—to reduce garbage collection overhead, improve allocation efficiency, and achieve up to 97% faster execution.
This guide explores Go's engineering-friendly features—including gofmt, built‑in profiling, unit testing, coverage, and documentation practices—while also covering performance tuning, garbage‑collector evolution, language versioning, and the upcoming Go2 transition to help developers build robust server applications.
The article demonstrates that Kotlin coroutines on the JVM are merely a convenient API layered on traditional Java threads rather than true lightweight coroutines, contrasting them with Go’s M:N goroutine scheduling, and discusses experimental Kotlin‑Native and OpenJDK Loom projects that aim to provide genuine coroutine support.
The study traced severe Redis latency spikes in an 8‑core container to the Go runtime mistakenly reading the host’s CPU count, which created hundreds of threads and scheduler contention; limiting GOMAXPROCS to the container’s quota eliminated the jitter, while further gains were suggested by reducing HMGET calls, tuning GC, and upgrading Go.
This article explains how Go avoids traditional class inheritance by using implicit interfaces and composition, demonstrates the Template Method pattern in Go, explores orthogonal design principles, details Go Modules versioning and migration from GOPATH/vendor, and reviews Go's concurrency models including goroutine, channel and context.
This article analyzes the challenges of handling millions of simultaneous train‑ticket purchase requests, presents a multi‑layer load‑balancing architecture, introduces a pre‑deduction inventory strategy using Redis and local memory, and demonstrates a complete Go implementation with performance testing and key architectural insights.
This article dissects the extreme‑load challenges of China’s 12306 train‑ticket service, explains its multi‑layer load‑balancing architecture, and provides a complete Go‑based spike‑system example that uses Nginx weighted round‑robin, Redis atomic stock deduction, and channel‑based locking to safely handle millions of concurrent purchase requests.
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.
