This article introduces microservice concepts, explains GoKit's architecture and onion model, and walks through building a simple calculation service in Go, progressively adding logging, metrics, and middleware using the decorator pattern to achieve a clean, decoupled three‑layer design.
This guide explains how to configure Go 1.13+ to work with private GitLab repositories by using environment variables such as GOPRIVATE, GONOPROXY, and GONOSUMDB, covering common errors with go get, proxy settings, and checksum verification.
This article demonstrates how to use the Go-based FunTester framework to conduct performance tests—select, insert, update, and delete—on MySQL through GORM, providing code examples and explaining the setup of the testing harness.
This article explores the origins of the Go programming language by examining its earliest code commits, the role of Brian Kernighan’s historic "hello world" snippet, the transition through multiple version‑control systems, and the eventual establishment of the official Go specification.
The author recounts a failed Go pull‑request, detailing overflow bugs, missing tests, improper commit messages, and how proper code review practices can turn a buggy contribution into a successful merge.
The Go‑based GDP Streaming RPC framework extends Baidu’s internal brpc‑compatible RPC system with a high‑performance streaming transport that preserves message order, supports multiple concurrent streams per socket, offers customizable serialization and event‑driven handlers, and enables efficient large‑scale data transfers such as voice or replica synchronization, achieving comparable latency and throughput to the original C++ implementation.
The Go community’s arena proposal introduces a contiguous‑memory allocation method that reduces allocation overhead and enables bulk freeing, offering up to 15% CPU and memory savings for large applications while ensuring safety through dynamic checks.
The article introduces Promoter, a Go‑based webhook that fetches Prometheus metrics, renders alert graphs with gonum/plot, stores the images in S3‑compatible object storage, and embeds them in DingTalk notifications, providing deployment instructions, template customization, and core implementation details.
This article details a practical reproduction of a large‑scale WeChat red‑packet service, describing the design goals, hardware and software setup, concurrency architecture, monitoring tools, and performance results that demonstrate a single‑machine handling one million connections and up to sixty thousand queries per second.
This article explains how to programmatically render Prometheus alert charts, upload them to object storage, and embed the images in DingTalk notifications using the Go‑based Promoter tool, including template customization, deployment steps, and core rendering logic.
This guide walks through the complete setup of SQLE's development environment, covering the Go-based backend API, MySQL configuration, and the Node.js/React frontend, including required tools, code cloning, building, and testing steps on Linux.
This guide shows how to modify a Go custom DNS resolver to perform simple load balancing by predefining IP addresses and randomly selecting one for each new connection, including full code examples and test output.
This article explains how ZuanZuan's operations team applies Go's error handling mechanisms—including error values, panic/recover, sentinel errors, and custom error types—along with practical guidelines and code examples to improve reliability and maintainability of production services.
go-charts is a Go library that simplifies creating line, bar, and pie charts as SVG or PNG images, supports light, dark, and grafana themes, offers Apache ECharts‑compatible configuration, provides performance benchmarks, and includes guidance for handling Chinese characters.
This article provides a comprehensive analysis of Go's net/http library and the Gin framework, detailing request handling flow, router implementation, middleware chaining, and context management, while presenting key source code excerpts to illustrate how HTTP services are built and extended in Go.
Learn how Linux namespaces provide resource isolation and how cgroups enforce resource limits, with step‑by‑step commands, code examples in Go, and practical demonstrations of CPU sharing using unshare, cgcreate, cgset, and cgexec to control process behavior.
This article presents a comprehensive performance test of Go language channels, comparing them with Java's Disruptor and LinkedBlockingQueue across various object sizes, queue lengths, and producer/consumer thread counts, and provides practical recommendations based on the benchmark results.
This article demonstrates how to extend Go's HTTP client with a custom DNS resolver using net.Dialer, configure load‑balancing, and test the implementation with sample code and a simple mock service, providing a practical guide for backend developers.
The article explains Go’s table‑driven testing pattern, showing how separating test data into a slice of structs simplifies test code, improves quality, and enables subtests, parallel execution, assertions, mocking, and custom templates, illustrated with a GetWeekDay example and advanced techniques.
The TIOBE Index released its February 2022 ranking, showing the top‑20 programming languages with Python, C and Java each gaining over 1% and highlighting shifts such as PHP re‑entering the top ten, Go climbing to 11th, and detailed listings for positions 21‑100.
CGO lets Go programs call C functions and vice versa by importing "C", generating intermediate files, handling type conversion, managing runtime transitions, and requiring careful memory and pointer handling, with best‑practice guidelines to avoid leaks, scheduler issues, and thread explosion.
The article explains how K8ssandra, an Apache Cassandra distribution for Kubernetes, evolved from using Helm charts to developing a dedicated Operator to overcome Helm's limitations, improve multi‑cluster support, and align more closely with Kubernetes best practices.
This article explains the concept of middleware, demonstrates how to implement it in Go using the net/http Handler interface and the Negroni library, and provides complete code examples for logging and authentication middleware chains.
This article curates a wide range of high‑quality video tutorials, books, and online resources covering Python fundamentals, web crawling, data analysis, machine learning, Go language development, and front‑end technologies, offering practical recommendations and rating scores to help learners choose suitable study material.
This article explains how to design and implement a high‑concurrency ticket‑seckill system by analyzing the 12306 architecture, introducing multi‑layer load balancing, demonstrating Nginx weighted round‑robin configuration, and providing Go and Redis code to achieve stable, low‑latency ticket purchasing under massive simultaneous requests.
This article introduces JsRpc, a WebSocket‑based bridge between a browser and a Go server that lets you execute custom JavaScript from HTTP‑style calls, enabling reverse‑engineering, encrypted function calls, and data extraction.
This article demonstrates how to use Go to parse MySQL binlog events and synchronize data by implementing a lightweight replication client, covering configuration, server module, packet handling, handshake, registration, dump command, and providing complete source code examples with explanations.
This article details how the Beike instant‑messaging system was analyzed, bottlenecks identified, and a series of backend optimizations—including business isolation, increased concurrency, computation reduction, and Redis connection‑pool redesign—were applied to boost 300‑person group‑chat throughput from 15 QPS to over 320 QPS, achieving more than a twenty‑fold performance gain.
This article details a practical backend engineering experiment that reproduces the massive load of 100 billion WeChat red‑packet requests by simulating one million concurrent users on a single machine, covering target metrics, hardware/software choices, architecture, implementation steps, performance testing, and analysis of the results.
Go implements a two‑level N:M concurrency model where lightweight Goroutines (G) run on logical processors (P) backed by OS threads (M), with the GMP scheduler managing run queues and channels—mutex‑protected circular buffers with send/receive queues—providing efficient, preemptive multitasking and communication.
This article details the design, goals, hardware and software choices, implementation techniques, performance testing phases, and analysis of a prototype backend capable of handling one million concurrent connections and up to 60 k QPS to simulate the massive load of ten billion WeChat red‑envelope requests.
This guide explains how to measure the performance impact of the Sentry SDK on web servers by using the open‑source Sentry SDK Benchmark suite, which runs baseline and instrumented versions of TechEmpower framework tests inside Docker Compose and reports latency and resource usage.
This article introduces the Go programming language, explains why it is called Go rather than Golang, outlines its key advantages and common use cases, compares it with Python for beginners, and provides practical advice and resources for learning Go effectively.
This article explains the inner workings of the Kubernetes scheduler, details its pre‑score, score, and normalize‑score phases, discusses zone handling and resource fragmentation, and demonstrates how to extend the scheduler using the Scheduling Framework with a custom Go plugin.
This tutorial walks through adding pagination and flexible where‑filters to the User List interface, configuring gqlgen extensions, handling GraphQL errors, wrapping mutations in transactions, and building unit, integration, and end‑to‑end tests for a Go clean‑architecture project using Ent and gqlgen.
This comprehensive guide explores Go performance optimization techniques, covering pprof profiling, trace analysis, GODEBUG diagnostics, and escape analysis, while providing practical code examples and real‑world case studies to help developers identify and resolve CPU, memory, and goroutine bottlenecks in production services.
The article demonstrates how to structure a Go backend using Clean Architecture’s four‑layer model, interface‑driven design, and compile‑time dependency injection with Google Wire, providing concrete examples of repository, service, and API implementations and unit‑testing each layer with sqlmock, gomock, and httptest.
This article walks through integrating the four Clean Architecture layers—entity, use‑case, interface‑adapter, and framework/driver—into a Go application using ent for ORM and gqlgen for GraphQL, covering folder layout, ULID primary keys, Node interface support, and pagination implementation.
This article examines the motivations for rewriting the Java‑centric Dubbo RPC framework in Go, discussing language efficiency, company‑level technology choices, the advantages of Go’s lightweight concurrency for gateways, and how Dubbo‑Go bridges Java and Go in modern microservice and service‑mesh architectures.
This article examines Go’s memory management, explaining the distinction between RSS and VSZ, the runtime’s delayed memory return mechanism, common causes of memory spikes, and how to observe and force memory release using tools like ps and debug.FreeOSMemory(), illustrated with practical code examples.
This article walks through setting up GORM in a Go project, covering dependency management, database initialization, model definition, and practical examples of select, insert, update, delete, raw SQL execution, and transaction handling with detailed code snippets.
The article introduces Alibaba's open‑source Sentinel, a cloud‑native high‑availability protection component for distributed microservices that offers flow control, circuit breaking, concurrency limiting and adaptive overload protection, and highlights the new Sentinel Go v1.0.4 features such as Prometheus metrics, enhanced circuit‑breaker recovery, Apollo data source, and updated Kubernetes CRD support for version 1.22+.
This article details a step‑by‑step engineering effort to model and benchmark a high‑throughput red‑packet service capable of handling 10 billion requests, covering target metrics, hardware setup, Go implementation, load generation, monitoring, and performance analysis.
This article traces the historical origins of coroutines from early COBOL compiler challenges, explains their cooperative execution model, compares them with thread scheduling, and reviews how modern languages like Python, C++ and Go implement coroutine support to improve IO‑bound performance.
This article explains how to design a lightweight rule engine in Go by first using JSON‑defined rules, then leveraging Go's token scanner and AST parser to evaluate boolean expressions such as header and cookie checks, and finally discusses extending the engine with custom primitives and GoYACC for more complex grammars.
This tutorial walks through creating a maintainable GraphQL application using Go, demonstrating how to set up a Docker‑based MySQL database, configure Viper and Echo, define ent schemas, run migrations, integrate gqlgen with ent, and implement queries and mutations following Clean Architecture principles.
This article explains Linux signals, the difference between exec and shell forms of Dockerfile ENTRYPOINT and CMD, and demonstrates with Go and shell script examples how to configure containers so that docker stop sends SIGTERM correctly for a clean shutdown instead of a forced kill.
The 2021 year‑end summary details FunTester’s rapid growth, the expansion of its public account, major performance upgrades reaching over 100 k QPS, the design of a distributed testing framework, dynamic load models, log‑replay innovations, and the author’s deep dive into Go, Java and Groovy.
This article examines the motivations behind rewriting the popular Java RPC framework Dubbo in Go, discussing language efficiency, micro‑service architecture, RPC competition, thread‑pool challenges, and the emerging role of Dubbo‑Go in service‑mesh environments.
This guide explains how to keep Swagger annotations in sync with Yapi by generating a swagger.json file, exposing it via Nginx, and configuring Yapi’s automatic import, so that API documentation updates automatically after each code change without manual effort.
This guide explains how Tencent's open‑source PolarisMesh service mesh can be combined with the Go implementation of gRPC to add service discovery, health checking, dynamic routing, circuit breaking, graceful shutdown, and traffic limiting, providing step‑by‑step code examples and integration architecture.
This article explains how to use Go's test command with various flags such as -c, -run, -timeout, and -coverprofile, demonstrates writing test cases, TestMain setup, benchmarking, profiling with pprof, generating flame graphs, and interpreting coverage reports to improve Go application reliability and performance.
The article introduces a lightweight Go ORM for MySQL, explains native connection setup, details the SmallormEngine design with chainable methods for Table, Where, Insert, Update, Delete, and BatchInsert, and demonstrates how reflection builds SQL fragments while handling errors and supporting fluent query composition.
This article explains how Go's garbage collection has progressed from the simple stop‑the‑world mark‑and‑sweep algorithm in Go 1.3, through the tri‑color concurrent marking with insert and delete write barriers in Go 1.5, to the hybrid write‑barrier approach introduced in Go 1.8 that dramatically reduces pause times while preserving memory safety.
The article compares Go’s native map (which crashes under concurrent access), a map protected by sync.RWMutex, the lock‑free read‑optimized sync.Map introduced in Go 1.9, and the sharded orcaman/concurrent‑map, showing that sync.Map excels in read‑heavy workloads while sharded maps better handle frequent inserts, and suggesting other cache libraries for eviction or expiration needs.
This article explains the producer‑consumer concurrency model, its benefits such as decoupling and buffering, and demonstrates both unbuffered and buffered channel implementations in Go with complete code examples and a real‑world order‑processing scenario.
The article explains Go’s scheduler (M, P, G), demonstrates goroutine, channel, and select usage, covers sync primitives, atomic ops, context cancellation, singleflight, common pitfalls, debugging tools, and a channel‑driven chatroom case study, offering best‑practice guidance for efficient concurrent programming.
This comprehensive tutorial walks you through creating a complete web‑based blog using Go and the Gin framework for the backend, React for the frontend, PostgreSQL for persistent storage, JWT for authentication, and Docker for containerized deployment, covering code, configuration, and testing.
This tutorial explains Docker image layers, demonstrates step‑by‑step labs that build and progressively slim a Redis image using smaller base images, command chaining, compression tools, and scratch‑based builds, and shows how Go binaries can produce ultra‑small containers.
The Go 1.18 Beta1 release introduces generics support, workspace mode, fuzz testing, and performance improvements, while the newly announced Neo framework offers a lightweight, MIT‑licensed solution for building Go web applications with simple installation and example code.
This guide demonstrates how to create a Go-based WebSocket server and client using the gobwas library, enabling two services to exchange random numbers, handle connections, and gracefully manage disconnections, with complete code examples and testing instructions.
This article explains the evolution of Go's development workflow from the legacy GOPATH mode to the modern Go Modules system, details version‑specific changes, answers common migration questions, and provides a step‑by‑step tutorial with code examples for creating, testing, and managing Go modules in production projects.
The article outlines a systematic SOP‑driven approach for diagnosing online service alarms and performance issues in Go, detailing a toolbox that includes pprof, trace, goroutine visualizers, perf and eBPF, and recommends application‑level optimizations, system tuning, and continuous profiling to accelerate root‑cause identification and reduce incident frequency.
This roundup introduces the latest releases of several open‑source projects—including ahooks 3.0 with full SSR support, Tailwind CSS v3.0’s new runtime engine, the Go‑based Fiber web framework, Happy DOM’s performance benchmarks, the low‑code front‑end framework amis, and the multi‑framework compiler Mitosis—providing concise overviews and key features for each.
In this extensive interview, industry veterans Zhao Haiping and Zhang Hongbo discuss the evolution of programming languages, compiler development, language design trade‑offs, and practical experiences across companies like Facebook, Alibaba, and ByteDance, offering valuable guidance for developers and researchers alike.
This article explains Go Modules' major version suffix rules, how the Go tool resolves package paths to module paths using GOPROXY, and the structure and advanced features of the go.mod file, including deprecated warnings and programmatic manipulation.
The article explains Go module paths defined in go.mod, how they combine with package subdirectories, the semantic versioning scheme (major, minor, patch, pre‑release), and how Go generates and orders pseudo‑versions from tags, branches, or commits when fetching modules.
This article explains how to create a custom Kubernetes authentication webhook in Go that supports GitHub token and LDAP authentication, details the required API Server configuration, provides full code examples, and demonstrates testing both methods, illustrating a practical way to integrate external account systems with Kubernetes.
This article explains Linux signals, the differences between Dockerfile CMD and ENTRYPOINT formats, and demonstrates with Go and shell examples how using the exec form enables containers to receive termination signals for a clean shutdown.
This article details the evolution from a Node.js‑based WebSocket gateway to a Go‑implemented, gRPC‑driven architecture, describing the redesign of connection handling, TLS off‑loading, socket ID generation, session management, custom Kafka headers, code‑level optimizations, and extensive performance testing that validates the new gateway’s scalability and resource efficiency.
This article describes the architectural evolution from Gateway 1.0 to Gateway 2.0 for a high‑traffic document collaboration platform, detailing the redesign of the WebSocket layer, resource‑usage optimizations, heartbeat mechanisms, custom Kafka headers, message serialization, load‑testing results, and the operational lessons learned to support millions of concurrent connections.
Facing high memory usage and slow builds with Java SpringBoot, NetEase Media switched to Go in 2020, rebuilt core services, and created the cloud‑native ngo framework to deliver lighter containers, faster compilation, built‑in business libraries, tracing and monitoring, now running in production while hiring engineers.
This article details the redesign of Shimo Docs' WebSocket gateway—from a Node.js/Socket.IO 1.0 version to a Go‑based 2.0 architecture—covering handshake degradation, TLS memory savings, SnowFlake SocketID generation, Redis‑based session broadcasting, heartbeat tuning, custom Kafka headers, object pooling, MessagePack compression, extensive performance testing, and the resulting stability and scalability improvements for handling half‑a‑million concurrent connections.
This article describes the evolution from a Node.js‑based WebSocket gateway to a Go‑powered, gRPC‑enabled architecture, detailing the redesign of the gateway, resource‑saving techniques, heartbeat and TLS optimizations, message‑broker choices, extensive performance testing, and the resulting improvements in CPU, memory, and scalability for millions of concurrent connections.
This article details the design, refactoring, and performance testing of a high‑traffic WebSocket gateway for Shimo Docs, covering the evolution from a Node.js Socket.IO version to a Go‑based microservice architecture, TLS memory tuning, socket ID generation, heartbeat handling, custom Kafka headers, and resource‑efficient scaling to half‑a‑million concurrent connections.
This article details the evolution from a Node.js Socket.IO gateway to a Go‑based, gRPC‑enabled WebSocket gateway that supports millions of concurrent connections, covering architecture redesign, TLS handling, socket ID generation, session management, heartbeat optimization, custom Kafka headers, code‑level refinements, and extensive performance testing results.
The article presents a detailed performance comparison of three HTTP client implementations—Java FunTester, Go's net/http, and the high‑performance fasthttp library—across multiple thread counts and artificial latency settings, reporting CPU usage, memory consumption, and QPS to determine the most efficient choice.
This article introduces Go, highlights its concise and clean syntax, showcases core language structures and built‑in tools, explains module creation and cross‑compilation, and demonstrates how to build binaries and WebAssembly modules, making a compelling case for learning Golang.
This article explains how to use the Go gobreaker library to implement circuit‑breaker patterns, describing its three states, state transitions, configurable parameters, and providing full source‑code examples to help developers improve fault tolerance in micro‑service architectures.
This guide walks through using the Gorilla WebSocket library in Go, covering dependency setup, server implementation with an Upgrader, Java and Go client examples, testing procedures, and performance observations that highlight Go's advantages for WebSocket workloads.
The article traces Go’s shift from GOPATH to Go Modules—detailing their history, migration steps, practical commands, and best‑practice tips such as using replace directives, managing go.mod and go.sum, and emphasizing why teams should adopt modules now for reliable dependency handling, security, and developer efficiency.
This article analyzes the extreme‑traffic problem of Chinese train ticket sales, presents a multi‑layer load‑balancing architecture with Nginx weighted round‑robin, demonstrates Go and Redis code for local and global stock deduction, and shows benchmark results proving that a single machine can handle over 4 000 requests per second while preventing oversell and few‑sell.
This article dives deep into Go's channel implementation, explaining the hchan data structure, how make creates channels, the send/receive mechanics, goroutine scheduling, blocking behavior, and provides practical code examples to illustrate these concepts.
Security researchers at ESET reveal that the Hive ransomware group has expanded its attacks to Linux and FreeBSD systems, releasing a buggy yet feature‑rich Linux variant written in Go, while noting a broader industry trend of ransomware operators developing Linux encryptors to compromise virtualized server environments.
This article introduces Go's newly added generic support, explains its concepts, historical development, usage examples, constraints, and best practices, while providing code snippets for functions, slices, maps, queues, and pointers, helping developers grasp how to write type‑safe reusable code in Go.
This article walks through developing a simple Go WebSocket server that echoes the current time, shows a minimal client, compares startup speed with Java, and provides full source code and test logs for practical performance testing.
The article surveys Go's generics—from their historical origins and the generic dilemma of balancing productivity, compile speed, and runtime performance—to practical implementation using type parameters, constraints, and the built‑in comparable interface, illustrating common patterns such as generic arithmetic, slices, maps, and utility functions.
This article explains how to design a robust e‑commerce shopping‑cart service by separating business, system, and technical architectures, applying DDD, strategy and chain‑of‑responsibility patterns, and choosing Redis data structures for high‑performance storage.
The article explains how Go, traditionally a compiled language, can serve as a scripting language using the Yaegi interpreter—detailing its syntax‑compatible design, easy struct integration, quick‑start example, performance comparison with gopher‑lua and Tengo, and practical engineering guidelines for safe embedding.
After mastering Go's net/http and fasthttp client libraries, this article presents six distinct server‑side implementations—ranging from basic net/http handlers to Echo, Gin, and fasthttprouter—highlighting their syntax, readability, and configuration differences for rapid backend development.
This article presents an interview‑style overview of the Go programming language, covering its distinguishing features, typical use cases, concurrency model with goroutines and channels, basic syntax, data types, variable and constant declarations, error handling, and recommended development tools, all illustrated with code examples.
This article explains the concept of RabbitMQ dead letter queues, outlines the conditions that generate dead letters, provides step‑by‑step configuration instructions, and includes Go code examples for publishing messages with TTL and consuming from the dead‑letter queue to implement delayed processing.
The article reviews the most frequent errors encountered while adopting microservice architecture—excessive customization, uncontrolled complexity, and vague definitions—illustrating each with real‑world experiences, a saga implementation using Redis streams and Go, and practical advice to avoid similar pitfalls.
This article explains how to determine whether a singly linked list contains a cycle using three approaches—brute‑force, hash‑marking, and the optimal fast‑and‑slow pointer technique—providing Go and C++ implementations that achieve minimal time and O(1) space complexity suitable for a Tencent interview.
This guide walks readers through building a complete Raft consensus system in Go, detailing leader election, log replication, state persistence, snapshotting, and committed‑entry application, while explaining key structures, RPCs, golden rules, and offering advice on using mature libraries versus custom implementations.
This tutorial walks through installing the Go XORM library, generating Go structs from existing MySQL tables with the reverse tool, and demonstrates full CRUD, pagination, and transaction handling using both chainable queries and raw SQL.
In this article, Poki engineers explain why they abandoned PHP in favor of Go while migrating to a micro‑service architecture, discuss the performance and operational benefits of Go, evaluate NoSQL options like MongoDB and Cassandra, and justify sticking with MySQL for their high‑traffic gaming platform.
This article explains Go's sync.Once primitive, compares it with init, details various singleton implementations—including lazy, eager, and double‑checked locking—and provides practical code examples and a deep dive into its source implementation for thread‑safe one‑time initialization.
This article explores the fasthttp library as a high‑performance alternative to Go's net/http client, demonstrates basic and advanced API usage with object pools, shows how to set up a mock test server, and provides complete Go unit‑test examples with output verification.
This article explains how to create a Go‑based command‑line tool that queries Harbor projects and repositories, lists image tags, and automatically deletes older tags while retaining a configurable number of recent ones, streamlining storage management and avoiding manual page‑by‑page deletions.
