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.
Rob Pike, one of Go’s creators, opened a GitHub issue urging the community not to add generics to the Go 1.18 standard library, citing the massive scope of changes and a lack of practical experience, and recommending thorough testing in external libraries before any core updates.
This comprehensive guide walks you through creating a gRPC user service in Go and PHP, from defining protobuf messages and generating code, implementing server and client stubs, adding client, server, and bidirectional streaming, securing communication with TLS certificates, and managing request deadlines with timeout controls.
Learn how to build a pure Go instant messaging platform with a three‑layer, distributed architecture—comet, logic, and job—featuring RPC communication, Redis‑based message pushing, and cluster support, plus step‑by‑step deployment instructions, required packages, and future enhancement plans.
This guide walks you through downloading the Go binary, extracting it to /usr/local, verifying the installation, and setting up essential environment variables like GOROOT and GOPATH so you can run Go commands directly from the terminal.
This article introduces d18n, a Go‑based, cross‑platform data‑desensitization tool that supports multiple databases and file formats, explains common desensitization scenarios, details its sensitive‑data identification techniques—including keyword, regex, and NLP‑based DFA—and outlines six practical masking algorithms with export and import workflows.
This guide walks through installing Redis, MariaDB, Go, configuring Open-Falcon's backend and frontend components, setting up Python virtual environments, and launching the monitoring system, providing complete command-line instructions and configuration details for a functional deployment.
This article walks through creating a reusable Go HTTP client wrapper, demonstrates its use in a test script, shows console output, and integrates a mock server with Moco to enable quick API testing while applying a learning‑by‑doing approach.
This article explains how to build a high‑concurrency ticket‑seckill system that can handle millions of simultaneous requests by using multi‑layer load balancing, Nginx weighted round‑robin, local stock deduction, Redis atomic scripts, and Go’s native concurrency, and it demonstrates the implementation with complete code and performance testing.
This step‑by‑step tutorial shows how to configure Vim with Vundle, vim‑go, NERDTree, Tagbar, neocomplete, goimports, golint, gocode, ack and custom shortcuts to create a full‑featured Go development environment on Linux.
This tutorial demonstrates how to use Go's standard and third‑party libraries to parse and generate YAML, JSON, and XML files, covering data structures, unmarshalling, marshalling, handling maps, and producing readable output with code examples.
This article explores the design of a high‑concurrency train‑ticket flash‑sale system, covering distributed load‑balancing strategies, Nginx weighted round‑robin configuration, local and remote stock deduction using Go and Redis, performance testing with ApacheBench, and key architectural lessons for preventing overselling and ensuring high availability.
This article explains what unit testing is, shows how to write Go unit tests using the testing package, demonstrates more expressive assertions with GoConvey, and introduces mock creation with mockery, providing practical code examples and best‑practice tips for backend developers.
The Hulk framework, built on GDP2, provides a business‑oriented Go web development platform with out‑of‑the‑box components, standardized architecture, rich observability, and tooling that together improve code quality, development speed, and SRE efficiency for large‑scale short‑video services.
This article explains how to create a non‑intrusive Kubernetes admission webhook that injects custom volumes and volume mounts into Knative pods, covering the underlying admission control concepts, Go implementation, TLS setup, deployment manifests, and verification steps.
The article presents a unified error‑handling strategy for Go backend services that combines idiomatic internal checks, Go 1.13’s %w wrapping with errors.Is/As, and a compact 4‑character base‑36 hash code system to deliver consistent machine‑readable codes and user‑friendly messages while preserving full log details.
Getty is a Go-based, layered network framework that provides data interaction, business control, and network layers with extensible monitoring interfaces, featuring custom SDKs, goroutine pool optimizations, lazy reconnection, sync.Pool tuning, and benchmark results demonstrating high throughput and low resource usage.
This article presents a comprehensive approach to quantifying MySQL slow‑query risk by defining scoring items, establishing boundary values, applying various scoring functions, and integrating business‑level weighting, ultimately enabling proactive identification and remediation of high‑impact slow queries.
This article explains the AutoHome Service Framework (ASF), its architecture, how it enables seamless migration from gRPC to Go services, the added Dubbo‑go support, configuration optimizations, advanced load‑balancing strategies, observability enhancements, and future plans for adaptive balancing and zero‑downtime deployments.
This article shares a 985 graduate's personal background, systematic interview preparation for C++ and Go backend positions, detailed interview question collections from major tech companies, and practical advice on study resources, project presentation, and coding practice to help candidates succeed in technical interviews.
This article describes how to design, implement, and evaluate a scalable backend that can simulate 10 billion WeChat red‑envelope requests by supporting up to 1 million concurrent users and handling 30 k–60 k QPS per server using Go, Linux tools, and custom monitoring.
This article lists ten typical Go programming pitfalls—from undefined enum values and misleading benchmarks to pointer misuse, slice initialization, error handling, context misuse, and goroutine closures—explaining why they hurt performance or correctness and offering concrete, idiomatic solutions.
This article explains what coroutines are, compares Python's coroutine implementation with Go's goroutine model, discusses their execution characteristics, and provides code examples illustrating producer‑consumer pipelines and async/await usage in both languages.
This article explores Go's channel primitives in depth, covering their atomic FIFO behavior, internal queues, blocking semantics, common usage patterns such as futures, condition variables, semaphores, mutexes, and safe closing techniques, all illustrated with practical code examples.
This article explains the challenges of iOS crash log symbolication on Linux, evaluates native tools like symbolicatecrash and atos, describes several prototype solutions, and details the final design that pre‑parses DWARF and symbol tables into a distributed cache to achieve massive latency and resource reductions.
This article explains the concept of Prometheus exporters, details the four metric types, provides step‑by‑step Go code for creating custom exporters and collectors, and outlines best practices for designing robust, production‑ready monitoring exporters.
Gaode migrated its high‑traffic rendering gateway from Java to Go to halve machine usage, validate middleware stability, and prepare for cloud‑native transformation, overcoming correctness and availability challenges by creating a real‑time traffic‑comparison tool, sandbox stress tests, and a staged gray‑release, ultimately achieving about 50% cost reduction.
This article explains Prometheus' custom Rule system, detailing the structure and components of alerting rules, the rule manager's loading and updating process, group scheduling, evaluation cycles, and the logic for generating, updating, and sending alerts, enabling advanced monitoring extensions.
This article explains how to implement efficient real-time WebSocket message pushing in a distributed system by using Redis as a coordination layer, defining Go-based Client and ClientManager components, and detailing the end‑to‑end flow from message production to client delivery.
This guide explains how WebSockets enable full‑duplex communication over a single TCP connection, compares popular Go WebSocket libraries, and provides complete client‑server code examples for TCP, UDP, and HTTP‑based WebSocket implementations, helping developers build real‑time applications such as chat, games, and monitoring tools.
Go 1.17 brings a 5% speed increase, smaller amd64 binaries, Windows ARM64 support, pruned module graphs to cut unnecessary dependencies, and three language upgrades—including slice‑to‑array pointer conversion and new unsafe functions—plus links to full release notes and downloads.
This article compares four popular programming languages—JavaScript, Haskell, Go, and PHP—by outlining their key advantages such as rapid prototyping, functional features, simplicity, and ecosystem support, as well as their notable drawbacks including dynamic typing, steep learning curves, lack of generics, and quirky language behaviors.
The article surveys a range of Go standard‑library performance tricks—from using sync.Pool and zero‑copy string/byte conversions to reducing lock contention, leveraging go:linkname, caching call‑frame data, optimizing cgo calls, employing custom epoll, SIMD, and occasional JIT—while urging profiling‑first, readability‑preserving optimizations.
This article explains the background, design, components, ecosystem, and real‑world benefits of the Hulk Go web framework developed by the short‑video R&D team, showing how it improves development efficiency, code quality, performance, observability, and incident response for large‑scale microservices.
Go 1.17 has been officially released, bringing a new function argument and result passing mechanism that improves performance by about 5%, reduces amd64 binary size by 2%, adds Windows ARM64 support, introduces pruned module graphs, and adds language features such as slice‑to‑array pointer conversion and unsafe.Add/Slice utilities.
Hulk is a Go‑based web service framework created by the short‑video R&D team to replace a PHP monolith, extending the unreleased GDP2 platform with business‑specific wrappers, a four‑layer architecture, and integrated monitoring, tracing, and deployment tools that dramatically boost development speed, runtime performance, and SRE efficiency for high‑traffic short‑video services.
This article presents six practical Go techniques—including loop labels for prime number generation, IP address conversion, octal UTF‑8 decoding, a lightweight HTTP utility library, a concise debug logging helper, and a Go‑based httpbin replacement—complete with code examples, usage notes, and visual results.
Gorse is an open‑source Go recommendation system that automates model selection, supports distributed training and prediction, offers a RESTful API and dashboard, and stores data in MySQL/MongoDB with Redis caching, enabling fast integration of personalized suggestions into online services.
Gorse is an open‑source, Go‑based recommendation system that automates model selection, supports distributed training and real‑time serving via RESTful APIs, stores data in MySQL or MongoDB with Redis caching, and offers a dashboard for monitoring, data import/export, and cluster health.
This article analyzes popular programming languages—including PHP, Java, C, C++, Python, Go, and JavaScript—to help beginners decide which language to start with in 2021, highlighting each language's strengths, job prospects, and suitability for newcomers.
This interview explores the six‑year evolution of the dubbogo project, the motivations, challenges, and biggest contributions of PMC member Wongoo, and his vision for the future of this high‑quality Go implementation of the Dubbo RPC framework.
The Go team announced minor releases Go 1.16.7 and 1.15.15 with security fixes and the Go 1.17 RC2 preview, which adds slice‑to‑array pointer conversion, new unsafe.Add and unsafe.Slice functions, and expanded platform support for macOS, Windows ARM, and OpenBSD MIPS.
The article details Go’s runtime memory architecture—including pages, spans, mcache, and size classes—and explains its non‑generational concurrent tri‑color mark‑and‑sweep garbage collector, the required write‑barrier techniques, and the collector’s evolution, phases, trigger mechanisms, and practical code examples across Go 1.0‑1.16.
This article examines several subtle Go programming issues—including unexpected loop variable addresses, the scope nuances of the := operator, proper handling of goroutine concurrency with worker pools, and how struct field ordering affects memory alignment—providing code examples and practical solutions to avoid these pitfalls.
This article explains how Go executables receive and process command‑line arguments and environment variables, compares C and Go implementations, dives into the Linux stack layout, and details the flag package's parsing mechanics with code examples and runtime internals.
The article explains why Go is gaining popularity, highlighting its superior execution performance, high development efficiency, and extensive adoption by leading companies in cloud infrastructure, microservices, and open‑source projects such as Docker, Kubernetes, and many Chinese tech firms.
This article explains the circuit breaker pattern, its three-state lifecycle, and provides a detailed Go implementation with code examples, state transition logic, metric tracking, and known limitations for improving service stability.
This guide explains Go’s built‑in testing framework, assertion libraries, table‑driven and sub‑tests, and demonstrates how to mock functions, structs, interfaces, databases, and Redis using tools such as ngmock, gomock, sqlmock and miniredis, while covering test setup, teardown, coverage handling, and best‑practice insights.
This article explains how Linux signals work, details common signals like SIGTERM and SIGKILL, and demonstrates how to use Dockerfile ENTRYPOINT and CMD in exec form together with Go signal handling to achieve clean, graceful shutdowns of containers.
This article explains why rate limiting is essential for high‑availability services, describes HTTP 429 standards and response headers, classifies rate‑limiting strategies by granularity, target, and algorithm, and provides detailed Go code examples using the time/rate library for fixed‑window, sliding‑window, leaky‑bucket, and token‑bucket implementations.
In this interview, Huawei Cloud MVP Wang Ming shares how a non‑computer‑science background led him to a successful IT career, discusses the advantages of interdisciplinary skills, offers entrepreneurship advice, predicts future tech trends, and explains the key concepts of his popular Go concurrency book.
This article provides a comprehensive beginner‑friendly walkthrough of Go, covering its origins, installation, environment variables, IDE setup, project structure, core syntax, data types, functions, object‑oriented concepts, and a practical concurrency example using goroutines and channels.
This article walks through the concepts, protocols, and complete Go code needed to implement both HTTP and HTTPS forward proxies, explaining request handling, header transformations, and TCP forwarding while providing clear diagrams and runnable examples.
F2 is a fast, safe Go‑based command‑line tool for batch renaming files and folders on Linux, macOS, and Windows, offering multiple installation methods, preview mode, undo, conflict resolution, built‑in variables, and powerful regex‑driven rename examples.
This article explores the architecture and implementation of a high‑traffic ticket‑spike service, covering load‑balancing strategies, Nginx weighted round‑robin configuration, local and remote stock deduction using Go and Redis, fault‑tolerant buffering, and performance testing results.
Pixiu is a Golang‑based, cloud‑native API gateway built on dubbo‑go that bridges RESTful and Dubbo services, offering high performance, extensibility, and easy configuration through Listener, Router, Filters, and Client modules, with roadmap plans for gRPC, mesh integration, and more.
This article introduces the lightweight Go microservice framework Kratos, covering its Protobuf‑driven API design, open and extensible architecture, logging and tracing integrations, functional‑option configuration, unified error model, and compile‑time dependency injection with code examples and diagrams.
This guide explains how to install the Go‑based Ascii Image Converter on Linux, use it to transform JPEG, PNG, BMP, WEBP, or TIFF files (or URLs) into monochrome or colored ASCII art, and customize output size, character sets, and saving options.
This article explains the inner workings of the Linux netstat command, walks through reading /proc/net/tcp and related files, demonstrates how to map sockets to processes, and provides a complete Go implementation of a lightweight netstat utility with code examples and detailed parsing logic.
The gout library is a Go‑based HTTP client that offers extensive request configuration, body encoding, response parsing, benchmarking, retry logic, raw packet sending, curl export, and custom client injection, with recent updates adding a WithTimeout option and improved handling of empty values.
This article explains what a Kubernetes Operator is, how it works, and provides a step‑by‑step guide with code examples for creating, building, deploying, and managing a simple Nginx Operator using the Operator SDK.
The article describes how a Go‑based high‑throughput service was tuned from 80k to over 200k QPS by enlarging the GC heap, reusing UDP connections with sync.Pool, reducing system‑call overhead, and applying several lightweight logging and discovery optimizations.
This article explains Go's MPG scheduling model, detailing how Goroutine, M, and P interact during blocking, asynchronous and synchronous system calls, the role of the netpoller, and the sysmon coroutine that enables preemptive scheduling and runtime monitoring.
At Gopher China 2021, Go expert Yang Le Duo presented a detailed exploration of a proactive in‑memory cache architecture, describing how his team tackled real‑time data, complex queries, hot‑cold data swapping, and language constraints to improve performance and developer productivity in large‑scale streaming applications.
This article explains common database logging mechanisms such as MySQL redo logs and binlogs, compares them with Redis AOF and etcd's Raft‑based WAL, and provides an in‑depth analysis of etcd's WAL source code, including key structures, creation process, record types, encoding, and file pipeline management.
This tutorial explains how to extract logs from a 16 GB file in about 25 seconds by reading the file in chunks, reusing buffers with sync.Pool, and processing those chunks concurrently with Go goroutines, avoiding full‑memory loads or slow line‑by‑line scans.
Despite Python’s explosive growth since 2010 and its dominance across data science, AI, and general programming, this article examines the language’s strengths—maturity, readability, extensive libraries—and its drawbacks such as speed, dynamic scope, and limited mobile support, while exploring whether emerging languages like Rust, Go, or Julia might eventually replace it.
This article explains the core mechanisms of the Raft consensus algorithm—including leader election, log replication, safety guarantees, message structures, state transitions, and key Go implementations in etcd-raft—providing code examples and detailed analysis of functions such as becomeLeader, tickElection, and appendEntry.
This article compares five widely used programming languages—JavaScript, Haskell, Go, PHP, and Elixir—by outlining each language’s major advantages such as rapid prototyping, strong type systems, performance, and ecosystem support, as well as notable drawbacks including dynamic typing quirks, steep learning curves, and limited language features.
This article explores how Go implements the empty interface (interface{}) at the binary level, detailing stack frame allocation, compiler‑generated helper functions, pointer structures, and runtime optimizations that together reveal why an empty interface is essentially two consecutive pointers in memory.
This article introduces Go's time package, explaining its core types such as Month, Weekday, Duration, Location, and Time, and demonstrates how to work with timers, tickers, and time parsing through clear examples and code snippets.
This article explains the origin of the "gopher" nickname for Go developers and provides a comprehensive guide on migrating legacy PHP services to Go, covering architectural decisions, project layout, concurrency control, error handling, and asynchronous task execution.
This article explains how to use the TiDB SQL parser to create custom SQL fingerprints by traversing the abstract syntax tree, replacing literal values with placeholders, and restoring the modified tree back to SQL, offering a more maintainable alternative to string‑based approaches.
The article walks through Go’s memory allocator by first demonstrating assembly‑level debugging with Delve, then detailing its TCMalloc‑inspired design where tiny, small, and large objects follow distinct paths through per‑P caches, central spans, and the global heap, highlighting the roles of mcache, mcentral, mspan, and mheap.
This article explains Go’s context package, covering its purpose for managing goroutine lifecycles, the key interfaces and implementations such as emptyCtx, cancelCtx, timerCtx, and valueCtx, and demonstrates how to use WithCancel, WithDeadline, WithTimeout, and WithValue to control execution, propagate cancellations, and pass values across call chains.
This article explains why changing dubbo-go's module path to dubbo.apache.org/dubbo-go/v3 caused CI failures, analyzes the version mismatch introduced by go‑mod replace, and provides a step‑by‑step fix that aligns major versions and clarifies Go's semantic import versioning, pseudo‑versions, and module nesting.
This article walks through building a Go exporter that collects OVS bond status via shell commands, formats the data as Prometheus metrics, and deploys the service in a Kubernetes DaemonSet, providing step‑by‑step code, Dockerfile, and testing instructions.
This article explains why Go's lightweight goroutines enable high concurrency, describes the need for a goroutine pool to control resource usage, outlines the pool's architecture with entry and job channels, and provides a complete Go implementation with example usage.
Ken Thompson, a Turing Award laureate, transformed computing by pioneering generic operating system theory, co‑creating UNIX after a failed Multics project, inventing the C language, and later shaping Google’s Go language, all while embodying the hacker spirit of curiosity and fun.
In a one‑hour interview, Python’s creator Guido van Rossum shares candid opinions on Rust, Go, Julia, and TypeScript, explaining why he finds Rust powerful, Go the most Pythonic, Julia a niche but interesting language, and how Python is learning from TypeScript.
The article shares Khan Academy engineers' journey migrating a large Python codebase to Go, highlighting their growing love for the language, the need for generics, performance and concurrency benefits, and overall impressions after producing more than 500,000 lines of production Go code.
This article provides a detailed walkthrough of the Calico CNI plugin source code, explaining how the calico and calico‑ipam binaries are built, how the ADD command creates WorkloadEndpoint objects, veth pairs, routes, and sysctl settings, and how these components integrate with the Calico datastore in a Kubernetes environment.
Khan Academy’s Goliath project migrated over 500,000 lines of backend code from Python 2 to Go, citing performance, fast compilation, better tooling, and developer preference, while also discussing the challenges of Python’s EOL and the role of generics in Go.
This article explains the classic Nim game where two players alternately remove 1‑3 stones from a pile, presents the LeetCode‑style problem of determining if the first player can force a win, analyzes the pattern of losing positions, provides a concise Go solution, and offers a formal proof based on game theory.
The article outlines why high‑load Go services need performance tuning and presents a systematic workflow—preparation, analysis with Linux tools and Go’s pprof/trace, targeted optimizations such as goroutine pooling, Redis MSET, efficient JSON handling and slice resizing—demonstrating how these changes boost throughput, lower latency, and stabilize memory usage while offering broader Go‑specific best‑practice recommendations.
The article explains RTMP’s multiplexed, packetized streaming over TCP, detailing its chunk structure, message types, handshake, and connection workflow, then demonstrates livego’s publishing and pulling processes, discusses typical latency sources, and offers mitigation strategies and reference resources for developers.
This article explains how to implement optimistic locking in Go using GORM by adding a version field, writing raw SQL updates, creating a reusable wrapper function with retry logic, and leveraging interfaces and type assertions to handle concurrency safely.
Ken Thompson’s remarkable journey—from early fascination with binary numbers, through winning the Turing Award, building UNIX at Bell Labs, influencing the creation of C, co‑designing Go at Google, and even piloting a MiG‑29—illustrates how curiosity and playfulness can drive lasting innovations in computer science.
This article introduces Seata, a high‑performance open‑source distributed transaction solution, explains the Seata‑Golang 1.0.0 release and its demo at a Go meetup, details the core AT‑mode architecture, describes the MySQL driver that integrates Seata‑Golang, and outlines future plans for broader database support.
This article introduces Go's Gin framework, compares its performance with other Go web frameworks, and walks through core features such as routing, middleware, data binding, and the underlying engine, providing code examples and visual diagrams for developers seeking efficient backend solutions.
This article explains how Go's built‑in testing tool gathers code coverage, detailing the relevant go test flags, configuration steps for unit and integration testing, instrumentation mechanics, output formats, and practical solutions used in real‑world projects.
This article explains the step‑by‑step process by which kubelet creates a sandbox container, invokes the CNI interface, runs Calico’s ADD command, and sets up routes, virtual interfaces, and IP allocation for pods in a Kubernetes cluster, including relevant Go code excerpts.
This article dissects how China’s 12306 ticket platform handles millions of simultaneous requests by using layered load balancing, distributed clustering, Nginx weighted round‑robin, Redis‑based pre‑deduction, and a Go implementation that demonstrates local and remote stock deduction, performance testing, and fault‑tolerant design.
This article explains the fundamentals of operating‑system processes and threads, how the OS scheduler enables concurrent execution, the cost of context switches, and why Go implements lightweight user‑level goroutines to achieve efficient concurrency in modern applications.
Through a series of benchmark tests comparing simple, logging‑enabled microservices written in Java (Helidon) and Go (Go‑Kit), the authors evaluate whether Java can achieve Go‑like performance, exploring JVM tuning, GraalVM native images, and Kubernetes deployments to uncover speed, memory, and scalability trade‑offs.
Instead of Docker, we leveraged Go 1.16’s //embed feature to create a single binary for our web service, detailing the rapid build, test, and deployment steps, and arguing that Docker’s overhead isn’t necessary for small teams focused on fast delivery.
This article explains how SuperEdge extends native Kubernetes with a service‑group mechanism that provides topology‑aware service routing at the edge, compares it with the upstream Kubernetes service‑topology feature, and details the controller, wrapper, cache, and handler implementations with code examples.
This guide presents a concise, step‑by‑step roadmap for mastering Go, covering beginner fundamentals, essential packages, and advanced cloud‑native projects like Etcd, Docker, Kubernetes, and Istio, while offering practical study tips and career insights.
This article explains what Casbin is, how its PERM model works, and provides a step‑by‑step guide to integrate Casbin’s RBAC authorization into a Go project using Gin, Gorm, and a MySQL adapter, including model configuration, policy storage, middleware enforcement, and verification.
OpenTelemetry, a CNCF observability project, standardizes telemetry data models, collection, processing, and export, offering vendor‑agnostic APIs, SDKs, and a configurable collector; the article explains its problem domain, solution components, history, future outlook, and provides a practical Go demo with code and configuration examples.
