This article provides a comprehensive guide to Go's net/url package, covering import methods, key functions like PathEscape, PathUnescape, QueryEscape, QueryUnescape, as well as the URL type fields and methods such as Parse, ResolveReference, and utilities for query manipulation, all illustrated with practical code examples.
This article explains what ESBuild and SWC are, why they dramatically speed up JavaScript bundling and compilation compared to traditional tools, and provides practical guidance on integrating them into modern frontend workflows such as Vite, Webpack, and custom scripts.
This article explains how to avoid HTTP 429 rate‑limit errors when calling third‑party APIs by wrapping each request in a struct and processing them through a channel‑based request queue written in Go, complete with usage examples and optional throttling.
The article walks through building a minimal SQLite‑style database in Go, covering memory‑disk page storage, B‑tree indexing, simple SQL parsing for INSERT and SELECT, row serialization, a pager that flushes pages, and a basic REPL, while highlighting current single‑page limits and future extensions.
The article examines Go's origin, rapid adoption in China since 2014, market hiring trends, popularity metrics like TIOBE rankings, and highlights the language's ease of use, strong tooling, corporate backing, and cloud‑native ecosystem as the main drivers of its success.
This article demonstrates three Go black‑magic techniques—using go:linkname to call private runtime functions like memmove and growslice, employing cgo to invoke C code, and embedding Plan 9 assembly—to bypass safety checks and achieve significant performance improvements, though they rely on unsafe practices.
Learn how to implement the classic Tower of Hanoi puzzle in Go by exploring its origins, rules, recursive logic, and detailed code example, complete with step-by-step explanations and visual illustrations that guide you through solving the problem efficiently.
The article details a step‑by‑step investigation of why HTTP request latency increased after moving a Go‑based service to new hardware, focusing on DNS resolution delays, the role of DNSmasq, Go's resolver implementation, and the experiments that led to fixing the issue.
This article chronicles how 于雨 transformed Dubbogo—from a one‑person Go implementation of the Dubbo RPC framework into a large, cloud‑native open‑source community—detailing technical challenges, community building, personal sacrifices, and future goals for sustainable growth.
This article explains why Go programs can still exhibit memory growth despite automatic garbage collection, describes how to identify and diagnose such issues with the built‑in pprof tool, and details the underlying sampling mechanism, memory fragmentation, and cgo‑related allocations.
The article walks through Go 1.18’s new multi‑module workspaces, detailing prerequisites and essential commands, then demonstrates creating a simple “hello” module and a shared library, initializing a workspace with go work, and developing both modules concurrently without committing changes.
This article explains Go’s concurrency fundamentals, distinguishing concurrency from parallelism, describing the CSP model built on goroutines and channels, and detailing the underlying M‑P‑G scheduler architecture—including thread models, runqueues, and load balancing—providing a comprehensive overview for developers.
This guide presents five practical Go techniques—using a large ballast slice to control GC timing, leveraging benchmark and pprof for performance profiling, applying the monkey library for test stubbing, avoiding unreleased locks that cause OOM, and employing proper synchronization primitives to prevent stale memory reads.
This article explains how to engineer APIs by automating protobuf file management, code generation, CI/CD pipelines, error handling, validation, and documentation generation using tools such as GitLab, Kratos, Apifox, and quicktype, ultimately improving development efficiency across backend and client teams.
This article walks through the complete process of creating a custom SQL audit rule in the open‑source SQLE platform, covering API authentication, request construction, response analysis, rule insertion into the database, and the necessary Go backend code implementation.
This article explains how to create custom middleware for the Go Negroni framework, walks through a complete example with code, and details the internal functions such as UseHandler, Wrap, Use, build, and how Negroni ultimately runs the HTTP server.
This article describes how to set up a low‑maintenance, automated unit‑test and integration‑test environment for Go applications using a Java service in a pre‑integration platform, covering Docker packaging, Go tool installation, coverage plugins, diff‑cover for incremental coverage, and REST APIs for task management.
This article explains how to efficiently debug Go programs using Delve (dlv) and VSCode, covering both local launch debugging and remote attach debugging, configuration steps, breakpoint types, and useful console commands for backend developers.
This guide explains how to write effective GoDoc by installing and using the godoc and pkgsite tools, applying proper comment syntax, handling package overviews, deprecation notices, and example tests, and publishing documentation on pkg.go.dev with badges, illustrated through the go.jsonvalue library.
This article introduces a fully functional, open‑source Baidu Wenku‑style document library built with Go/Beego, Bootstrap, and MySQL, detailing its architecture, SVG‑based document rendering, point system, watermarking, and how to obtain the source code.
Kratos v2 is a lightweight, highly pluggable Go microservice framework that replaces the monolithic v1 design with a toolbox of interchangeable components—such as transport, middleware, logging, configuration, and service discovery—organized in a DDD‑inspired layout and extensible via protobuf‑defined plugins.
Yurthub, a non‑intrusive edge‑computing component of OpenYurt, acts as a kube‑apiserver proxy with caching to enable offline stability and reduce API load, employing four data‑filtering rules—ServiceTopologyFilter, EndpointsFilter, MasterServiceFilter, and DiscardCloudService—each detailed with implementation code and operational considerations.
This article, the second in a Go high‑performance series, details concurrency optimizations including lock‑free data structures versus locked lists, sharding and RWMutex to cut lock contention, controlling goroutine creation with pooling, using sync.Once for cheap one‑time initialization, and employing sync.Cond for efficient goroutine notification.
The guide details Go performance optimization techniques—including avoiding reflection‑based conversions, using proper capacity hints, preferring strconv over fmt, employing custom binary functions, optimizing string handling, struct layout, loop patterns, and sync.Pool reuse—backed by benchmarks that demonstrate significant speed and memory gains.
This guide explains how to create effective Makefiles for Go projects, covering prerequisites, syntax, common Go commands, a full example Makefile, and integration with CI/CD pipelines to streamline building, testing, and deployment.
This article details a step‑by‑step engineering experiment that reproduces a high‑throughput "red‑envelope" service, outlining the required hardware, software stack, load‑generation logic, monitoring setup, and performance results for handling up to 6 000 QPS on a 100‑million‑user scale.
Go 1.18 introduces generics, built‑in fuzzing, compiler enhancements, new ports, and up to 20% performance gains across several architectures, while also outlining experimental packages and known generic limitations for developers to consider.
The article reviews Dmitry Vyukov's 2019 talk on Go's goroutine scheduler, explains the GMP (goroutine‑M‑Processor) model, walks through its evolution from naive thread‑per‑goroutine to thread pools and work‑stealing, and discusses fairness, pre‑emptive scheduling, and possible future improvements.
The article dissects netpoll, a Go‑based high‑performance network framework that uses a Multi‑Reactor model with a main and sub‑reactors, detailing its server EventLoop, poll manager load‑balancing across epoll/kqueue, connection buffering and request handling, and the client’s non‑blocking dialing process.
Through systematic measurement, bottleneck identification, and targeted optimizations—including lock redesign, Redis caching, and URL parsing improvements—the author transformed a Go‑based Dubbo registry’s registration throughput from 40 QPS to over 1100 QPS, demonstrating practical performance‑tuning techniques for high‑scale backend services.
This article explains how Linux namespaces provide resource isolation while cgroups enforce resource limits, detailing the six namespace types, relevant system calls, practical commands like unshare and cgcreate, and demonstrates CPU share control with Go code and cgroup configuration examples.
This article dissects Go's net package, showing how its Listen, Accept, Read and Write functions combine goroutines with epoll to deliver synchronous‑style code that avoids costly thread switches, and walks through the underlying source code and runtime mechanisms step by step.
The author recounts submitting a Go PR to fix a benchmark timeout overflow bug, detailing the code review feedback, overflow detection issues, testing strategies, and proper commit‑message conventions, ultimately sharing insights from a largely unsuccessful contribution attempt.
The article explains Go’s GMP‑based goroutine scheduler, detailing how logical processors, thread‑local queues, and work‑stealing replace a naïve one‑goroutine‑per‑thread model, and discusses fairness, cooperative preemption, current limitations, and future optimizations compared with custom coroutine frameworks.
This article explains why side‑channel attacks threaten SM2, SM3, and SM4 algorithms, describes the vulnerabilities of table‑lookup and double‑and‑add implementations, and presents constant‑time scalar multiplication and selection methods in Go to protect private keys on blockchain platforms.
This article introduces the open‑source Go generic utility library samber/lo, explains how to install Go 1.18 beta and the library, and demonstrates common operations such as type conversion, concurrent processing, containment checks, filtering, deduplication, grouping, chunking, and ternary-like expressions with concise code examples.
Google’s Go 1.18 release introduces native fuzz testing, generics support, module workspaces, and up to 20% performance gains on ARM64 and Apple M1, enhancing security and productivity for developers while reinforcing Go’s pivotal role in cloud‑native projects like Kubernetes and Docker.
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.
