This article explains how a Go hello‑world program starts, tracing the ELF entry point, runtime initialization, GMP scheduler setup, creation of the main goroutine, and the flow into the user's main function.
The author reflects on how studying several programming languages—Java, Go, and Python—mirrors learning foreign tongues, revealing that cross‑language comparison sharpens understanding of data structures, HTTP fundamentals, and framework implementations, ultimately deepening overall software development expertise.
This tutorial walks you through the concepts of Kubernetes Operators, how they work, and provides a hands‑on walkthrough using Kubebuilder to set up the development environment, create a simple Foo operator, define CRDs, implement controller logic, and deploy and test the operator on a local cluster.
This article analyzes several bugs discovered in a Go goroutine pool implementation—incorrect active count, mismatched execution counters, slow scaling during QPS spikes, and inefficient recycling—and presents detailed code fixes and redesigns to achieve accurate metrics and faster, more graceful worker management.
This article explains the origins and purpose of Linux's standard input (0), standard output (1), and standard error (2) file descriptors, shows how they are defined in Rust and Go, and illustrates their behavior in terminal emulators and SSH sessions with detailed diagrams.
This article introduces Go to developers familiar with other object‑oriented languages, covering the language definition, basic syntax such as variable and constant declarations, control structures, functions with multiple returns and variadic parameters, data structures like arrays, slices and maps, struct‑based object‑orientation, interfaces, goroutine‑based concurrency, channels, mutexes, and the simple error‑handling model using error, defer, panic, and recover.
The article explains Go’s runtime finalizer mechanism, shows how a single blocked finalizer can stall all cleanup callbacks, and recounts a real‑world memory‑leak incident where an unrelated goroutine’s blocked finalizer for struct B prevented struct A’s resources from being released.
Unified Permission Management Service (MPS) at Baidu centralizes fragmented permission systems across internal platforms, integrating ACL, DAC, and RBAC models via Baidu's GDP framework, and provides modules for platform and node management, permission CRUD, workflow approvals, and audit/recovery, now serving over 20,000 users and managing more than 100,000 permission nodes.
This guide explains how to obtain a GitLab access token, download a Go-based cloning tool, configure its parameters, and run it to automatically fetch all groups and projects from a GitLab instance, with full source code examples for customization.
Go 1.21.0 introduces toolchain enhancements, new built‑in functions, expanded standard library packages, performance improvements through PGO and garbage‑collector tuning, experimental WASI support, and version‑number changes, all illustrated with concise code examples for developers.
Kscan is a pure‑Go, all‑in‑one network scanner that supports port scanning, protocol detection, fingerprinting, and brute‑force cracking across thousands of protocols, offering detailed usage instructions, command‑line options, and a GitHub download link for security professionals.
This article explains three typical pitfalls of Go slices—ignoring the slice returned by append, unintentionally sharing the underlying array which can cause memory leaks, and the value‑copy behavior of for‑range loops—while also showing how to inspect slice internals using unsafe pointers.
The article describes an eBPF‑based, language‑agnostic traffic recording framework that hooks low‑level socket operations and thread identifiers to capture complete request‑response flows across Java, PHP, and Go services without modifying application code, dramatically lowering implementation and maintenance costs for cloud‑native traffic replay.
Based on analysis of over 14 million developer job postings from January 2022 to May 2023, DevJobsScanner identified JavaScript/TypeScript, Python, Java, C#, PHP, C/C++, Ruby, and Go as the eight programming languages with the highest demand, accounting for roughly 29% of all language‑specific positions.
This article explores Go's channel implementation—from its CSP‑inspired design and internal hchan structure to real‑world memory‑leak debugging, creation nuances, send/receive mechanics, and proper closing—providing developers with a comprehensive understanding of safe concurrent programming in Go.
The article recounts a Go project's evolution of configuration handling—from hard‑coded DB credentials to a unified global struct and finally an init‑based implicit loader—highlighting how each teammate’s approach reflects distinct mindsets, knowledge gaps, and productivity trade‑offs, and invites readers to consider their own collaboration preferences.
This article details Tongcheng Travel's cloud‑native migration journey, describing the challenges of resource quota management, component versioning, and operational automation, and explains how a Kubernetes Operator platform built with Go, kubebuilder, and a watch‑broadcast mechanism addresses these issues while outlining future expansion plans.
Using Go’s pprof, the team traced a gradual CPU spike in a high‑throughput kafka‑go consumer to a saturated commit queue and repeatedly nested context values, which forced costly lookups; eliminating the unnecessary trace‑id context injection (or recreating a fresh context each loop) resolved the issue and reduced CPU usage to under 2 %.
This article presents a Go‑based dynamic QPS load‑testing framework that leverages a custom goroutine pool, explains the rationale behind reusing goroutines, provides core functions for task execution and console command handling, and includes a complete runnable demo illustrating high‑throughput performance testing.
This guide walks through the background, implementation, usage examples, and step‑by‑step open‑source contribution process for adding Redis cache expiration and memory‑limit chaos experiments to the ChaosBlade platform, including code snippets, Git workflow, and testing procedures.
The article explains Go closures, shows how capturing loop variables by reference can cause bugs like repeated values, demonstrates correct patterns such as copying variables inside loops or passing them as parameters, and offers guidelines to avoid common pitfalls with defer and concurrency.
This tutorial explains how Go developers can generate Tars RPC code from IDL, implement server and client logic, configure server and client settings, use various call patterns such as context, one‑way, mod‑hash and consistent‑hash, and quickly scaffold projects with the tarsgo tool.
This article explains how thorough code review, using tools like GoLand, Git plugins, and Postman, improves test case accuracy, data integrity, branch coverage, and overall software quality in Go projects, while offering practical tips on diff usage and highlighting the tangible benefits for testing teams.
The article details Shopee’s seadt‑SAGA framework—a Go‑based distributed transaction solution that implements the SAGA pattern via two modes, orchestration with a central coordinator and collaboration with embedded logic, explains their state‑machine designs, compares rollback ordering using vector clocks versus sequence numbers, and discusses each mode’s trade‑offs.
This guide explains how rtty combines a lightweight C client, a Go server, and a Vue front‑end to provide web‑accessible terminals for remote Linux device maintenance, covering its key features, installation steps, token generation, and browser‑based access.
The article explains how Bilibili’s senior engineer uses Domain‑Driven Design combined with hexagonal architecture to merge separate VOD and live‑stream Danmaku services into a unified platform, detailing sub‑domain decomposition, six‑sided ports, rich models, mapping logic, and the trade‑offs of improved modularity, maintainability, and reduced duplication versus added design and refactoring effort.
This article details Baidu Wenku App's backend migration from a PHP‑based stack to Go, covering the motivation, technical debt, technology selection, step‑by‑step migration strategy, quality assurance practices, performance improvements, and key takeaways for large‑scale service refactoring.
This article shares a detailed account of a Tencent testing engineer interview, covering self‑introduction, Go knowledge, Redis performance, distributed lock implementation, semaphore mechanics, RPC vs HTTP, concurrency usage, Git security practices, Linux commands, and a few brain‑teaser and algorithm questions.
This article explains how to implement a high‑performance Go coroutine pool by adapting key features of Java’s ThreadPoolExecutor, covering core parameters, task queue design, dynamic scaling, worker management, timeout handling, and provides complete code examples and self‑test results.
This guide introduces the Go‑based “diskusage” utility, shows how to install it with a single command, explains its usage with examples such as filtering specific file types, displaying sizes in gigabytes, and enabling colored output, and notes its cross‑platform support for Linux, macOS, and Windows.
The article explains why PHP programmers should learn Go, highlighting its faster execution, superior concurrency support, and built‑in web server capabilities, while providing simple code examples and mentioning a related training course.
Go maps are not safe for concurrent access, so programs can panic when multiple goroutines read and write the same map; to prevent this you can use sync.Once for immutable data, protect maps with sync.RWMutex, employ sharded locks via concurrent‑map, or use the built‑in sync.Map, each offering different performance trade‑offs depending on read/write ratios and concurrency level.
Learning Go offers PHP developers faster execution, superior concurrency, and a built‑in web server, making it easier to build high‑performance applications, and this article demonstrates these advantages with simple code examples while also providing resources for further study.
This article, the final installment of a DDD series, walks through a practical implementation of Domain‑Driven Design in Go using Kitex and Thrift, covering bounded contexts, layered architecture, domain modeling, persistence, factories, domain services, and cross‑cutting concerns in a fictional e‑commerce system.
An investigation of a 100k‑QPS Go monolith revealed that intermittent availability drops were caused by a memory‑leak in the third‑party gcache LFU implementation, which inflated GC work and produced long mark phases; upgrading gcache eliminated the leak and restored 0.999+ availability, highlighting the need for thorough observability and dependency monitoring.
This article explains why unit testing is essential for Go development, compares the legacy 2.0 approach with the new 3.0 plugin, details the plugin architecture, execution flow, code snippets, and shows real-world adoption results with clear HTML reports.
The article explains how Go's short variable declaration (:=) can cause variable shadowing across scopes, demonstrates the effect with a sample program, and recommends using the golangci-lint static analysis tool to automatically detect such hidden bugs.
This article explains the design principles of Seata-go's TCC mode, how it handles exceptions, and provides step‑by‑step guidance for implementing and using TCC in Go microservices, along with future roadmap insights.
This article explains how Go's efficient concurrency model, lightweight runtime, and rich standard library make it ideal for building scalable cloud computing solutions and microservice architectures, while also providing code examples for coroutines, HTTP services, and container integration.
In modern cloud‑native applications, distributed tracing is essential for pinpointing errors across microservices, and OpenTelemetry provides a standardized framework for collecting and analyzing trace data, with a hands‑on Go implementation demonstrated in an upcoming expert-led workshop.
The May 2024 TIOBE programming language index shows minimal changes in the top 20, with Go falling to #12, C++ climbing to #4 with over 3% growth, and newer languages like Swift and Rust still finding it hard to break into the top 100, while the CEO emphasizes the stability of language popularity.
This article explains the Go singleflight package, its original implementation, and a custom WriteGroup enhancement that merges concurrent read and write events to dramatically improve registration center performance under high load.
The Go 1.20.4 and 1.19.9 releases address three critical security vulnerabilities in the html/template package, including improper handling of CSS values, JavaScript whitespace, and HTML empty attributes, which could lead to unintended HTML injection and attribute manipulation.
This guide introduces the open‑source Nexttrace tool, explains how to install it on Linux and macOS, and demonstrates its core commands for ICMP, TCP, and UDP traceroutes, as well as advanced options like fast‑trace, interface selection, and map visualisation.
This article explores the design of a high‑concurrency ticket‑spike system like 12306, covering large‑scale architecture, load‑balancing strategies, inventory deduction techniques, and a complete Go/Redis implementation with performance testing and fault‑tolerance considerations.
The article details a year‑long refactoring case study of a fast‑iteration web project migrated from Python to Java/Go, describing inherited performance bugs, a prioritized migration plan, monitoring integration, concrete optimizations such as query reduction and cache redesign, and the resulting stability and latency gains, while outlining required developer skills and best‑practice recommendations.
This article explains how to simplify Kubernetes controller development by using the controller-runtime library and the Kubebuilder scaffolding tool, covering manager and webhook concepts, providing full Go examples, YAML configurations, and step‑by‑step commands for building, deploying, and testing a custom Foo controller.
This guide introduces NextTrace, a lightweight open‑source Go traceroute utility, explains how to install it on Linux, macOS and via GHPROXY, details its extensive command‑line options, and demonstrates advanced features such as TCP/UDP tracing, TTL control, parallel requests, map and table outputs.
This article introduces the open‑source Go‑based visual route‑tracking CLI tool Nexttrace, showcases its popularity, explains how to install it on Linux and macOS, and provides detailed usage examples—including ICMP, TCP, UDP tracing, fast‑trace mode, interface selection, and map visualization—plus advanced options such as TTL and concurrency control.
This article provides a comprehensive guide to the open‑source Capo cloud‑native network coordination service, covering its architecture, three deployment methods (Helm, Kustomize, plain YAML), detailed configuration parameters, observability setup, static code analysis with golangci‑lint, extensive unit and e2e testing using Kind, Helm chart packaging, registry publishing, and a full GitHub Actions CI/CD workflow.
This article presents six practical Go performance optimizations—including GOMAXPROCS tuning for Kubernetes, struct field ordering, garbage‑collection limits, zero‑copy unsafe conversions, jsoniter usage, and sync.Pool pooling—that together can dramatically lower CPU, memory, and latency in production services.
This article explains how Kubernetes uses the List/Watch API and the Informer client library to monitor resources, compares direct HTTP Watch with Informer, provides Go code examples for pod controllers, shared informers, custom CRD controllers, and introduces higher‑level frameworks such as controller‑runtime and Kubebuilder.
This article dissects the architecture of a 12306‑style ticket‑spiking service, explaining load‑balancing strategies, weighted Nginx routing, local and remote stock deduction using Go and Redis, and demonstrates performance testing that achieves thousands of requests per second while preventing oversell and undersell.
This article explains the underlying principles of Swoole coroutines, compares them with Go's goroutine model, outlines important usage considerations, contrasts Swoole with Workerman, describes coroutine communication methods, and provides practical PHP performance optimization tips.
This article explains the internal storage layout, on‑disk and in‑memory data structures, and the query execution flow of Prometheus V2, illustrating how blocks, chunks, WAL, indexes and postings are organized and accessed to serve time‑series queries efficiently.
This comprehensive guide walks Go developers through performance tuning fundamentals, recommended profiling tools, code-level optimizations, and real-world case studies, offering actionable insights to measure, diagnose, and improve CPU, memory, and concurrency efficiency in high‑throughput Go services.
This article explains how Go implements its own goroutine scheduler within the runtime, demonstrates it with sample code, and details the GMP (Goroutine‑M‑Processor) model, its scheduling strategies, and the evolution from the earlier GM model.
This article provides an in‑depth analysis of Prometheus V2's storage architecture, detailing the on‑disk block layout, chunk and index formats, the inverted index structure, memory representations, and the step‑by‑step query process that locates matching time‑series data.
The article describes the background, architecture, tool selection, key features, implementation challenges (including Go code for TCP/WebSocket handling), and real‑world deployment of a distributed simulation load‑testing platform that supports dynamic QPS control, multi‑protocol testing, and end‑to‑end data verification.
The article explains how to replace repetitive raw SQL and manual row scanning in Go by building a lightweight custom ORM that combines a chainable SQLBuilder for dynamic query construction with a reflection‑based Scanner that maps results to structs, also covering code generation and optional non‑reflection optimizations.
The article details Bilibili’s Comet workflow engine—a low‑code, plugin‑extensible platform built since 2019 that uses visual DAG templates, graph‑based legality checks, and asynchronous execution to automate diverse business processes such as SRE automation, permission requests, and push‑task approvals, improving operational efficiency across mobile and web services.
This article introduces the open‑source chatGPT-service backend and chatGPT-stream frontend, explains their WebSocket integration, provides Gitee mirrors, and offers step‑by‑step commands for cloning, configuring, Docker deployment, compilation, and testing the real‑time ChatGPT application.
This article explains what domain events are, how to define them with proper naming and attributes, explores multiple techniques for publishing events in Go—including parameter injection, static-like helpers, return‑based and repository‑based approaches—and describes strategies for consuming events safely and atomically.
This article combines a light‑hearted Valentine’s Day introduction for programmers with a detailed presentation of the classic Two Sum problem, including problem description, constraints, example inputs and outputs, multiple language implementations, and a complexity analysis.
This guide explains how to prepare a Go environment, install and configure the goreplay (gor) tool, capture real HTTP traffic from production, and replay it in a test environment with options for filtering, scaling, looping, and real‑time playback to achieve accurate performance testing.
This article explains how application services act as a façade for domain models, outlines key design principles, shows practical Go/Java implementation patterns, discusses transaction propagation and security handling, and provides concrete best‑practice recommendations for building thin, framework‑agnostic backend services.
Go 1.20, released six months after 1.19, brings major toolchain, runtime, and library updates—including new slice‑to‑array conversion, unsafe package functions, struct field comparison rules, comparable type enhancements, reduced binary size, build‑flag architecture support, coverage flags, and experimental RISC‑V FreeBSD support—while improving CPU performance by up to 2% and cutting memory overhead.
This article explains Linux signal fundamentals, the role of Dockerfile ENTRYPOINT and CMD directives, and demonstrates with Go and shell examples how using the exec form enables containers to receive termination signals for clean shutdowns instead of being force‑killed.
This article explains how Node.js uses the NODE_CHANNEL_FD environment variable to establish a socketpair for IPC between a parent process and its child, detailing the spawn implementation, underlying libuv handling, and how a Go subprocess can read and write through the shared file descriptor.
Loggie is a cloud-native, Go-based log-collection agent that replaces Filebeat and Flume by using a micro-kernel producer-consumer architecture with hot-swappable pipelines, achieving 2 GB/s read speeds, 1.6‑2.6× higher throughput while using only a quarter of the CPU, and providing built-in observability, reliability, and latency monitoring for large-scale enterprise deployments.
The article walks through a real‑world case of locating the K closest national weather stations to a Beijing site, explains why naive full‑scan using Vincenty's formula is slow, and details a tile‑based indexing solution that cuts query time to 900‑3000 ns and reduces CPU usage by about 10 percent.
This article presents a Go-based MySQL-to-MySQL data synchronization solution built on go-mysql-transfer, detailing its architecture, multi‑threaded design, binlog handling, DDL/DML ordering, and code implementation for reliable, ordered, and fault‑tolerant replication.
This article dissects Go’s select statement, explaining its I/O multiplexing purpose, compile‑time transformation via walkSelect and walkSelectCases, and the multi‑stage runtime algorithm in runtime.selectgo that handles various case patterns, lock ordering, polling randomness, and channel blocking behavior.
The article explains how a sudden Go service memory‑usage alert was traced with go tool pprof to a massive allocation in the quantile.newStream function, uncovered a Prometheus metric‑label explosion caused by the START_POINT label, and resolved the leak by disabling that label, while also reviewing typical Go memory‑leak patterns.
This tutorial explains what a Kubernetes Operator is, walks through setting up the development environment, creating a simple Foo operator with Kubebuilder, defining CRDs and controllers in Go, testing the operator on a local Kind cluster, and suggests further enhancements.
stl4go provides a generic Go 1.18 container library that implements an optimized skip‑list‑based ordered map, using adaptive levels, efficient random‑level generation, type‑specific paths, and cache‑friendly node structures to achieve near‑C++ performance, surpassing existing Go generic collections.
The article explains Go’s caller‑callee model, stack‑frame layout, and how parameter and return‑value passing shifted in Go 1.17.1—using registers for up to nine arguments or results and the stack for any beyond—highlighting the impact on performance and optimization.
This article explains the concepts of public and private IP addresses, NAT techniques, and the principle of intranet penetration, then demonstrates how to set up and analyze the open‑source FRP framework, including configuration files and core Go code for both server and client components.
This article explains how introducing factories in Domain‑Driven Design with Go separates object creation logic from domain responsibilities, hides implementation details, enforces invariants, and improves validation, while showing practical code patterns and design‑pattern choices for simple and complex domain objects.
This article explains how Domain‑Driven Design can be used to split monolithic applications into well‑structured microservices by introducing strategic domain modeling, tactical design patterns such as aggregates and value objects, and provides a concrete Go project example with full directory layout and code snippets.
This article explains how Domain-Driven Design can be used to split monolithic systems into manageable microservices, covering DDD fundamentals, strategic domain modeling, tactical design patterns, and a concrete Go implementation with a four‑layer architecture.
This article explains how Domain-Driven Design (DDD) can guide the decomposition of monolithic applications into microservices by introducing strategic and tactical design concepts, illustrating them with a membership‑center example, and providing detailed Go code structures and implementations.
This guide explains why and how to combine Tencent's open‑source Polaris service‑governance platform with the high‑performance dubbogo Go RPC framework, covering architecture, registration, discovery, dynamic routing and rate‑limiting, complete with configuration snippets and practical code examples.
The article argues that for most developers, especially those from ordinary schools, learning C++ is costly and inefficient, while Go can be mastered quickly and aligns better with current hiring demands that prioritize practical backend skills and project experience.
This article explains why using Go's init() function is discouraged due to readability, testing complications, and error‑handling limitations, and it offers practical alternatives such as direct variable initialization, custom init functions with sync.Once, and controlled error‑aware initialization patterns.
This article explains the concepts, design principles, and practical implementation steps of an open‑source decision engine—covering rule vs. decision flow, DSL creation with YAML, operator handling, workflow orchestration, and deployment considerations for production environments.
This article explains the role of domain services in Go‑based Domain‑Driven Design, outlines three situations where they are appropriate, shows how to implement them statelessly, recommends functional package organization, and demonstrates dependency inversion with interfaces and infrastructure implementations.
The article explains Go’s channel implementation as a lock‑protected FIFO queue composed of a circular buffer, send and receive wait queues, detailing creation, send/receive mechanics, closing behavior, a real‑world memory‑leak example, and why this design offers safe, performant concurrency comparable to mutexes.
The article offers a comprehensive Go‑language catalog of classic software design patterns—Interpreter, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Factory Method, Abstract Factory, Builder, Prototype, and Singleton—detailing each pattern’s concept, concrete implementation code, and passing unit‑test results.
Dongle is a lightweight, semantic Go library that offers extensive encoding/decoding capabilities and a full suite of encryption, decryption, and hashing algorithms, making it a developer‑friendly tool for data transformation and security tasks.
An accidental discovery by a GitHub engineer revealed that moving a single '&' operator in a Go program eliminated unnecessary copies, reduced heap allocations via escape analysis, and improved execution speed by 42%, highlighting common pitfalls in Go’s regex engine, malloc, and garbage collection.
The article shows how Domain‑Driven Design can guide microservice decomposition by using strategic layers (core, supporting, generic domains) and tactical building blocks (aggregates, entities, value objects, services, events), illustrated with a membership‑center example and a four‑layer Go code architecture, while noting DDD’s suitability for complex domains.
This article showcases practical Go implementations of classic behavioral design patterns—Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—providing concise explanations, full source code, and test programs that demonstrate each pattern’s problem‑solving workflow.
This article analyzes the challenges of traditional Kubernetes cluster installation, proposes a fully automated, zero‑touch deployment framework that abstracts and packages all required resources, and explores its architecture, implementation using Go, cloud‑edge collaboration with KubeEdge, and future extensions toward CRD‑based operators.
This article walks through building, compiling, containerizing, and deploying a simple mock‑response Wasm plugin for Higress on a Kubernetes cluster, explaining the code structure, configuration, plugin lifecycle, and the three revolutionary features of Wasm‑based gateway extensions.
Chaos Engineering and Fault Injection System Design combine steady-state hypotheses, controlled blast-radius experiments, and a lightweight interceptor layer using gRPC and protobuf to inject and report faults in micro-service architectures, enabling continuous testing, rapid MTTR reduction, and resilient services through automated, real-time experimentation and analysis.
This article explains the complete DeadMaster recovery workflow of Orchestrator, detailing how the system selects the appropriate check‑and‑recover function, handles emergency grace periods, reads topology information, registers recovery attempts, validates promotion constraints, executes the actual failover, and runs post‑recovery hooks, with extensive Go code examples.
The article reviews Go’s 13‑year journey, focusing on the major 2022 releases Go 1.18 and Go 1.19, and explains new features such as generics, fuzz testing, workspaces, documentation improvements, memory limits, VS Code extensions, security tools, and the team’s future roadmap.
This article explains how AlertManager processes Prometheus alerts through a pipeline of stages—including gossip settlement, inhibition, silencing, waiting, deduplication, retry, and notification—detailing each stage's purpose and providing Go code examples of their implementations.
This article walks through a simulated MySQL 3307 cluster failure, examines Orchestrator's source code to explain the ContinuousDiscovery loop, discovery queues, health ticks, caretaking tasks, raft coordination, topology snapshots, and the logic distinguishing UnreachableMaster from DeadMaster states.
