Tagged articles
1622 articles
Page 15 of 17
Liangxu Linux
Liangxu Linux
May 12, 2020 · Operations

Instant PC‑Phone File Transfer with QR Codes Using qrcp

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.

GoQR codefile transfer
0 likes · 5 min read
Instant PC‑Phone File Transfer with QR Codes Using qrcp
Huajiao Technology
Huajiao Technology
May 12, 2020 · Backend Development

How to Build a Real‑Time Sensitive Word Detection Service in Go

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.

GoJSON-RPCbackend service
0 likes · 7 min read
How to Build a Real‑Time Sensitive Word Detection Service in Go
360 Quality & Efficiency
360 Quality & Efficiency
Apr 24, 2020 · Backend Development

Root Cause Analysis of Connection Reset by Peer in a Go Backend Service

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.

Connection ResetDatabase Connection PoolGo
0 likes · 14 min read
Root Cause Analysis of Connection Reset by Peer in a Go Backend Service
360 Tech Engineering
360 Tech Engineering
Apr 13, 2020 · Backend Development

Understanding Exception and Error Handling in Go

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.

Error HandlingExceptionGo
0 likes · 6 min read
Understanding Exception and Error Handling in Go
58 Tech
58 Tech
Apr 13, 2020 · Backend Development

Diagnosing and Optimizing High CPU Usage of a Go Service Migrated to Kubernetes Using Flame Graphs

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.

ContainerGOMAXPROCSGo
0 likes · 12 min read
Diagnosing and Optimizing High CPU Usage of a Go Service Migrated to Kubernetes Using Flame Graphs
360 Tech Engineering
360 Tech Engineering
Mar 31, 2020 · Backend Development

Implementing Raft Command Handling and Log Replication in Go

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.

BackendConsensusGo
0 likes · 15 min read
Implementing Raft Command Handling and Log Replication in Go
Senior Brother's Insights
Senior Brother's Insights
Mar 31, 2020 · Backend Development

Building a 1M‑Request Ticket‑Grab System with Go, Nginx, and Redis

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.

GoNginxdistributed architecture
0 likes · 21 min read
Building a 1M‑Request Ticket‑Grab System with Go, Nginx, and Redis
360 Tech Engineering
360 Tech Engineering
Mar 20, 2020 · Backend Development

Implementing Raft Election Mechanism in Go – Part 2

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.

ConsensusElectionGo
0 likes · 21 min read
Implementing Raft Election Mechanism in Go – Part 2
Youzan Coder
Youzan Coder
Mar 20, 2020 · Backend Development

Exploring Go Unit Test Coverage, Static Analysis, and Incremental Coverage Integration

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.

GoKubernetesSonarQube
0 likes · 16 min read
Exploring Go Unit Test Coverage, Static Analysis, and Incremental Coverage Integration
MaGe Linux Operations
MaGe Linux Operations
Mar 12, 2020 · Cloud Computing

How to Build a Multi‑Cloud Management Tool with Go: Step‑by‑Step API Integration

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.

APIGoTencent Cloud
0 likes · 7 min read
How to Build a Multi‑Cloud Management Tool with Go: Step‑by‑Step API Integration
360 Tech Engineering
360 Tech Engineering
Mar 10, 2020 · Fundamentals

Introduction to Raft: A Comprehensive Overview of the Distributed Consensus Algorithm

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.

GoRaftState Machine Replication
0 likes · 11 min read
Introduction to Raft: A Comprehensive Overview of the Distributed Consensus Algorithm
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Mar 6, 2020 · Backend Development

Understanding Go's sync.Pool: Implementation, Usage Scenarios, and Evolution from Go 1.12 to 1.13

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.

Goconcurrencyobject pool
0 likes · 18 min read
Understanding Go's sync.Pool: Implementation, Usage Scenarios, and Evolution from Go 1.12 to 1.13
Mafengwo Technology
Mafengwo Technology
Feb 28, 2020 · Backend Development

How We Achieve Real‑Time MySQL‑to‑Elasticsearch Sync with Binlog and Kafka

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.

BackendBinlogElasticsearch
0 likes · 11 min read
How We Achieve Real‑Time MySQL‑to‑Elasticsearch Sync with Binlog and Kafka
Alibaba Cloud Native
Alibaba Cloud Native
Feb 14, 2020 · Cloud Native

How Kubernetes Schedules Pods and Secures API Access: A Hands‑On Deep Dive

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.

API ServerDockerGo
0 likes · 16 min read
How Kubernetes Schedules Pods and Secures API Access: A Hands‑On Deep Dive
21CTO
21CTO
Feb 7, 2020 · Backend Development

How to Build a High‑Concurrency Ticket‑Spike System Like 12306

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.

Godistributed architectureload balancing
0 likes · 18 min read
How to Build a High‑Concurrency Ticket‑Spike System Like 12306
360 Tech Engineering
360 Tech Engineering
Feb 4, 2020 · Backend Development

Gokeeper, Pepperbus, Peppercron, and Dashboard: Open‑Source Backend Services Overview and Deployment Guide

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.

BackendDockerGo
0 likes · 7 min read
Gokeeper, Pepperbus, Peppercron, and Dashboard: Open‑Source Backend Services Overview and Deployment Guide
Qunar Tech Salon
Qunar Tech Salon
Feb 4, 2020 · Backend Development

Bilibili's Exploration and Practice of Microservice Governance

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.

Circuit BreakingGoload balancing
0 likes · 13 min read
Bilibili's Exploration and Practice of Microservice Governance
dbaplus Community
dbaplus Community
Jan 22, 2020 · Backend Development

How to Simulate 100 Billion WeChat Red‑Packet Requests on a Single Server

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.

GoLoad TestingQPS
0 likes · 18 min read
How to Simulate 100 Billion WeChat Red‑Packet Requests on a Single Server
Huajiao Technology
Huajiao Technology
Jan 14, 2020 · Backend Development

How to Deploy and Use Huajiao’s Open‑Source Gokeeper, Pepperbus, Peppercron & Dashboard

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.

BackendConfiguration ManagementDocker
0 likes · 9 min read
How to Deploy and Use Huajiao’s Open‑Source Gokeeper, Pepperbus, Peppercron & Dashboard
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Jan 9, 2020 · Backend Development

Boost Go Performance: 7 Practical Optimization Techniques

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.

Gobenchmarkoptimization
0 likes · 14 min read
Boost Go Performance: 7 Practical Optimization Techniques
Alibaba Cloud Native
Alibaba Cloud Native
Jan 8, 2020 · Backend Development

Master Go Server Engineering: Formatting, Profiling, Testing, and Go2 Insights

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.

GoGo2Profiling
0 likes · 31 min read
Master Go Server Engineering: Formatting, Profiling, Testing, and Go2 Insights
vivo Internet Technology
vivo Internet Technology
Jan 8, 2020 · Fundamentals

Understanding Kotlin Coroutines, Go Coroutines, and JVM Threading

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.

CoroutinesGoJVM
0 likes · 20 min read
Understanding Kotlin Coroutines, Go Coroutines, and JVM Threading
Didi Tech
Didi Tech
Jan 5, 2020 · Backend Development

Investigation and Optimization of High‑Frequency Go Service Timeout in Containers

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.

CPUContainerGOMAXPROCS
0 likes · 14 min read
Investigation and Optimization of High‑Frequency Go Service Timeout in Containers
Alibaba Cloud Native
Alibaba Cloud Native
Jan 3, 2020 · Backend Development

Why Go Skips Inheritance: Master Interfaces, Composition, Modules and Concurrency

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.

GoInterfacesModules
0 likes · 53 min read
Why Go Skips Inheritance: Master Interfaces, Composition, Modules and Concurrency
Top Architect
Top Architect
Jan 2, 2020 · Backend Development

Designing a High‑Concurrency Ticket‑Seckill System with Load Balancing, Pre‑Deduction, and Go Implementation

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.

Distributed SystemsGohigh concurrency
0 likes · 18 min read
Designing a High‑Concurrency Ticket‑Seckill System with Load Balancing, Pre‑Deduction, and Go Implementation
ITPUB
ITPUB
Dec 28, 2019 · Backend Development

How to Build a High‑Concurrency Ticket‑Snatching System Like 12306 with Nginx, Redis, and Go

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.

GoNginxhigh concurrency
0 likes · 20 min read
How to Build a High‑Concurrency Ticket‑Snatching System Like 12306 with Nginx, Redis, and Go
Liangxu Linux
Liangxu Linux
Dec 28, 2019 · Backend Development

How to Build a Million‑User Ticket Spike System: Insights from 12306

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.

GoNginxhigh concurrency
0 likes · 21 min read
How to Build a Million‑User Ticket Spike System: Insights from 12306
Alibaba Cloud Native
Alibaba Cloud Native
Dec 25, 2019 · Backend Development

Master Go Panic/Recover, Thread Limits, and Error Handling – A Practical Guide

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.

Error HandlingGOMAXPROCSGo
0 likes · 34 min read
Master Go Panic/Recover, Thread Limits, and Error Handling – A Practical Guide
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Dec 20, 2019 · Fundamentals

Understanding Duck Typing and Interface Implementation in Go

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.

GoInterfaceRuntime
0 likes · 22 min read
Understanding Duck Typing and Interface Implementation in Go
Alibaba Cloud Native
Alibaba Cloud Native
Dec 18, 2019 · Backend Development

Why Go (Golang) Really Matters for Modern Server Development – A Complete Guide Overview

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.

GoModuleslanguage design
0 likes · 15 min read
Why Go (Golang) Really Matters for Modern Server Development – A Complete Guide Overview
Cloud Native Technology Community
Cloud Native Technology Community
Dec 18, 2019 · Cloud Native

Deep Dive into the Kubernetes Job Controller Implementation

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.

CloudNativeControllerGo
0 likes · 17 min read
Deep Dive into the Kubernetes Job Controller Implementation
System Architect Go
System Architect Go
Dec 15, 2019 · Operations

Using Makefile to Define Build Commands and Advanced Features

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.

DevOpsGoMake
0 likes · 5 min read
Using Makefile to Define Build Commands and Advanced Features
Mafengwo Technology
Mafengwo Technology
Dec 13, 2019 · Backend Development

How Go‑Powered IM Architecture Boosted E‑commerce Messaging Performance

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.

Distributed SystemsGoInstant Messaging
0 likes · 16 min read
How Go‑Powered IM Architecture Boosted E‑commerce Messaging Performance
360 Tech Engineering
360 Tech Engineering
Dec 11, 2019 · Backend Development

Implementing a Simple Load Balancer in Go

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.

GoLoad Balancerbackend-development
0 likes · 11 min read
Implementing a Simple Load Balancer in Go
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Dec 6, 2019 · Fundamentals

Understanding Go Slice Internals: Structure, Initialization, Append, Slicing, Copy, and Parameter Passing

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.

GoGolangMemory
0 likes · 24 min read
Understanding Go Slice Internals: Structure, Initialization, Append, Slicing, Copy, and Parameter Passing
dbaplus Community
dbaplus Community
Nov 20, 2019 · Backend Development

Designing a High‑Concurrency Ticket‑Spiking System for 1M Users and 10K Tickets

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.

Distributed SystemsGoNginx
0 likes · 20 min read
Designing a High‑Concurrency Ticket‑Spiking System for 1M Users and 10K Tickets
ITPUB
ITPUB
Nov 20, 2019 · Backend Development

How to Build a Million‑User Ticket‑Spike System with Nginx, Go, and Redis

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.

GoNginxSystem Design
0 likes · 20 min read
How to Build a Million‑User Ticket‑Spike System with Nginx, Go, and Redis
MaGe Linux Operations
MaGe Linux Operations
Nov 19, 2019 · Backend Development

How to Build a Million‑User Ticket‑Spike System with Nginx, Go, and Redis

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.

Gohigh concurrencyload balancing
0 likes · 19 min read
How to Build a Million‑User Ticket‑Spike System with Nginx, Go, and Redis
Programmer DD
Programmer DD
Nov 15, 2019 · Fundamentals

Why Concurrency Isn’t the Same as Parallelism: A Simple Analogy

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”.

GoParallelismWeb services
0 likes · 7 min read
Why Concurrency Isn’t the Same as Parallelism: A Simple Analogy
360 Tech Engineering
360 Tech Engineering
Nov 14, 2019 · Backend Development

Building a Simple TCP Port Scanner in Go

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.

GoNetwork programmingPort Scanner
0 likes · 8 min read
Building a Simple TCP Port Scanner in Go
Java Captain
Java Captain
Nov 14, 2019 · Backend Development

Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation

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.

Godistributed architecturehigh concurrency
0 likes · 20 min read
Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation
21CTO
21CTO
Nov 8, 2019 · Backend Development

How to Build a Million‑User Ticket Spike System with Nginx Load Balancing and Redis

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.

GoNginxload balancing
0 likes · 19 min read
How to Build a Million‑User Ticket Spike System with Nginx Load Balancing and Redis
Programmer DD
Programmer DD
Nov 7, 2019 · Backend Development

How to Build a High‑Concurrency Ticket‑Spike System with Go, Nginx, and Redis

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.

GoNginxhigh concurrency
0 likes · 19 min read
How to Build a High‑Concurrency Ticket‑Spike System with Go, Nginx, and Redis
Big Data Technology & Architecture
Big Data Technology & Architecture
Nov 4, 2019 · Backend Development

Designing a High-Concurrency Ticket Spike System with Go, Nginx, and Redis

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.

GoNginxdistributed-systems
0 likes · 19 min read
Designing a High-Concurrency Ticket Spike System with Go, Nginx, and Redis
Architect's Tech Stack
Architect's Tech Stack
Nov 4, 2019 · Backend Development

Design and Implementation of a High‑Concurrency Ticket Seckill System Using Go, Nginx, and Redis

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.

GoNginxSeckill
0 likes · 18 min read
Design and Implementation of a High‑Concurrency Ticket Seckill System Using Go, Nginx, and Redis
Java Backend Technology
Java Backend Technology
Oct 29, 2019 · Backend Development

How to Build a Million‑User Ticket‑Spiking System with Nginx, Go, and Redis

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.

GoNginxhigh concurrency
0 likes · 20 min read
How to Build a Million‑User Ticket‑Spiking System with Nginx, Go, and Redis
FunTester
FunTester
Oct 24, 2019 · Backend Development

Why qrpc Beats gRPC: A Lightweight, High‑Performance RPC Framework

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.

GoMicroservicesNetworking
0 likes · 12 min read
Why qrpc Beats gRPC: A Lightweight, High‑Performance RPC Framework
System Architect Go
System Architect Go
Oct 18, 2019 · Backend Development

Error Handling in Go Before and After Go 1.13

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.

Error HandlingGoas
0 likes · 5 min read
Error Handling in Go Before and After Go 1.13
Alibaba Cloud Native
Alibaba Cloud Native
Oct 18, 2019 · Cloud Native

Deploy WebSocket and gRPC Services on Knative: A Step‑by‑Step Guide

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.

DockerGoKnative
0 likes · 9 min read
Deploy WebSocket and gRPC Services on Knative: A Step‑by‑Step Guide
Big Data Technology Architecture
Big Data Technology Architecture
Oct 17, 2019 · Backend Development

Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation

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.

GoNginxhigh concurrency
0 likes · 19 min read
Designing a High‑Concurrency Ticket Spike System: Architecture, Load Balancing, and Go Implementation
21CTO
21CTO
Oct 14, 2019 · Backend Development

How to Build a Million‑User Ticket‑Snatching System with Nginx, Go, and Redis

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.

GoNginxhigh concurrency
0 likes · 18 min read
How to Build a Million‑User Ticket‑Snatching System with Nginx, Go, and Redis
360 Tech Engineering
360 Tech Engineering
Oct 10, 2019 · Cloud Native

Source Code Analysis of kube-proxy IPVS Mode in Kubernetes

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.

GoIPVSKubernetes
0 likes · 14 min read
Source Code Analysis of kube-proxy IPVS Mode in Kubernetes
vivo Internet Technology
vivo Internet Technology
Oct 9, 2019 · Fundamentals

Web Protocol Deep Dive: Chrome Network Panel, Connection Keep-Alive, Head‑of‑Line Blocking, and HTTP Body Transfer

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.

Chrome NetworkGoHTTP
0 likes · 28 min read
Web Protocol Deep Dive: Chrome Network Panel, Connection Keep-Alive, Head‑of‑Line Blocking, and HTTP Body Transfer
Alibaba Cloud Native
Alibaba Cloud Native
Sep 24, 2019 · Cloud Native

How Kubebuilder Simplifies Building Custom Kubernetes Controllers and CRDs

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.

CRDControllerGo
0 likes · 24 min read
How Kubebuilder Simplifies Building Custom Kubernetes Controllers and CRDs
GF Securities FinTech
GF Securities FinTech
Sep 23, 2019 · Backend Development

Why Our Team Switched from Node.js to Go: Lessons in Backend Engineering

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.

Backend EngineeringGoci/cd
0 likes · 16 min read
Why Our Team Switched from Node.js to Go: Lessons in Backend Engineering
Architecture Digest
Architecture Digest
Sep 17, 2019 · Backend Development

Evolution and Refactoring of the Mafengwo IM System: From PHP 1.0 to Go‑Based Microservices

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.

GoIMMessaging
0 likes · 14 min read
Evolution and Refactoring of the Mafengwo IM System: From PHP 1.0 to Go‑Based Microservices
Alibaba Cloud Native
Alibaba Cloud Native
Aug 29, 2019 · Cloud Native

Mastering Knative Serving SDK: Build Serverless Apps with Go Context

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.

GoKnativeSDK
0 likes · 11 min read
Mastering Knative Serving SDK: Build Serverless Apps with Go Context
Meitu Technology
Meitu Technology
Aug 29, 2019 · Backend Development

Memory Optimization in Long Connection Services: A Three-Year Journey

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.

Garbage CollectionGoMQTT
0 likes · 13 min read
Memory Optimization in Long Connection Services: A Three-Year Journey
360 Tech Engineering
360 Tech Engineering
Aug 21, 2019 · Backend Development

Practical Guide to gRPC Development for the Huajiao Service Backend

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.

GoMicroservicesProtobuf
0 likes · 12 min read
Practical Guide to gRPC Development for the Huajiao Service Backend
360 Tech Engineering
360 Tech Engineering
Aug 15, 2019 · Backend Development

Building a Simple RPC Framework in Go

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.

GoNetwork programmingRPC
0 likes · 11 min read
Building a Simple RPC Framework in Go
High Availability Architecture
High Availability Architecture
Aug 13, 2019 · Fundamentals

In‑Depth Study of Go’s Garbage Collection Algorithm and Its Evolution

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.

Concurrent Mark and SweepGarbage CollectionGo
0 likes · 22 min read
In‑Depth Study of Go’s Garbage Collection Algorithm and Its Evolution
System Architect Go
System Architect Go
Aug 12, 2019 · Backend Development

Why Switch to Go Module Proxy and Ditch the Vendor Directory?

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.

Build OptimizationGOPROXYGo
0 likes · 7 min read
Why Switch to Go Module Proxy and Ditch the Vendor Directory?
Didi Tech
Didi Tech
Aug 9, 2019 · Backend Development

Introducing Go‑Spring: A Spring‑like Application Framework for Go

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.

Backend FrameworkGoGo-Spring
0 likes · 10 min read
Introducing Go‑Spring: A Spring‑like Application Framework for Go
Architecture Digest
Architecture Digest
Aug 7, 2019 · Fundamentals

Understanding Clean Architecture: Principles, Layers, and Practical Reflections

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.

Clean ArchitectureDependency RuleGo
0 likes · 15 min read
Understanding Clean Architecture: Principles, Layers, and Practical Reflections
Didi Tech
Didi Tech
Aug 2, 2019 · Backend Development

Using Go pprof for Online Performance Profiling: Case Studies and Lessons

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.

CPU optimizationGobackend-development
0 likes · 16 min read
Using Go pprof for Online Performance Profiling: Case Studies and Lessons
System Architect Go
System Architect Go
Jul 29, 2019 · Backend Development

10 Common Go Mistakes That Can Sabotage Your Code

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.

Error HandlingGobenchmark
0 likes · 14 min read
10 Common Go Mistakes That Can Sabotage Your Code
Alibaba Cloud Native
Alibaba Cloud Native
Jul 19, 2019 · Cloud Native

Master Traffic Splitting and Version Control in Knative Serving

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.

Blue‑Green deploymentDockerGo
0 likes · 15 min read
Master Traffic Splitting and Version Control in Knative Serving
Mafengwo Technology
Mafengwo Technology
Jul 18, 2019 · Backend Development

How MaFengWo Scaled Its IM System: From PHP to Go and Service Splitting

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.

GoIMOpenResty
0 likes · 14 min read
How MaFengWo Scaled Its IM System: From PHP to Go and Service Splitting
360 Tech Engineering
360 Tech Engineering
Jul 17, 2019 · Information Security

Practical SSL/TLS and Cryptography Guide Using Go and kubeadm

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.

GoHashingKubernetes
0 likes · 18 min read
Practical SSL/TLS and Cryptography Guide Using Go and kubeadm
360 Tech Engineering
360 Tech Engineering
Jul 11, 2019 · Backend Development

Server‑Side Video Rendering with After Effects, Aerender, and FFmpeg

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.

After EffectsGoServer Architecture
0 likes · 9 min read
Server‑Side Video Rendering with After Effects, Aerender, and FFmpeg
dbaplus Community
dbaplus Community
Jul 9, 2019 · Databases

How Gaea Reinvents MySQL Middleware with Go‑Based Sharding and Hot‑Reload

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.

GoOpenSourcemiddleware
0 likes · 14 min read
How Gaea Reinvents MySQL Middleware with Go‑Based Sharding and Hot‑Reload
Huajiao Technology
Huajiao Technology
Jul 9, 2019 · Backend Development

Server‑Side Video Rendering for a Mini‑Program Using After Effects, Aerender, and FFmpeg

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.

After EffectsBackendGo
0 likes · 11 min read
Server‑Side Video Rendering for a Mini‑Program Using After Effects, Aerender, and FFmpeg
360 Tech Engineering
360 Tech Engineering
Jun 25, 2019 · Fundamentals

Building an LL(1) SQL Parser in Go

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.

GoLL(1) parserSQL parsing
0 likes · 9 min read
Building an LL(1) SQL Parser in Go
360 Tech Engineering
360 Tech Engineering
Jun 20, 2019 · Backend Development

Using inotify in Go for Configuration File Hot Reload

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.

File MonitoringGoLinux
0 likes · 8 min read
Using inotify in Go for Configuration File Hot Reload
360 Tech Engineering
360 Tech Engineering
Jun 6, 2019 · Backend Development

Hot Reloading Go Configuration Files Using System Signals

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.

ConfigurationGoGoroutine
0 likes · 10 min read
Hot Reloading Go Configuration Files Using System Signals
Ctrip Technology
Ctrip Technology
Jun 4, 2019 · Backend Development

Interview with He Xinming on dubbo-go: The Go Implementation of Apache Dubbo

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.

Apache DubboGoRPC
0 likes · 12 min read
Interview with He Xinming on dubbo-go: The Go Implementation of Apache Dubbo
Didi Tech
Didi Tech
Jun 1, 2019 · Backend Development

Testing Pyramid and Integration Testing Practices for a Go Service

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.

GoGoConveycoverage
0 likes · 12 min read
Testing Pyramid and Integration Testing Practices for a Go Service
360 Tech Engineering
360 Tech Engineering
May 28, 2019 · Backend Development

Introducing gobox: A Lightweight Go Framework with Modules and Usage Examples

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.

FrameworkGoLibrary
0 likes · 9 min read
Introducing gobox: A Lightweight Go Framework with Modules and Usage Examples