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.
This article compares Rust and Go, highlighting their shared goals, complementary strengths, performance, safety, team scalability, and real‑world experiences from companies like Dropbox, Fastly, and Cloudflare, and offers practical recommendations on when to choose each language.
Learn step-by-step how to create a custom Zabbix Agent2 plugin in Go that retrieves HTTPS certificate expiration dates, compile and install the plugin, configure Zabbix, and set up monitoring items and alerts to proactively avoid service disruptions caused by expired certificates.
OpenYurt adds edge‑computing capabilities to a vanilla Kubernetes cluster by providing a non‑intrusive, one‑click conversion that enables autonomous edge nodes, with YurtHub and dual‑read‑closer mechanisms handling cached, filtered, and streamed data efficiently.
This guide presents LazyDocker, a Go‑based terminal UI tool that simplifies Docker and Docker‑Compose container and service management with clear status views, log access, customizable ASCII metrics, and convenient keyboard shortcuts, plus multiple installation options.
This article explores the design and implementation of a high‑concurrency train ticket spike system, detailing load‑balancing strategies with Nginx, distributed inventory management using Redis, Go‑based services, and performance testing, while addressing challenges such as overselling, fault tolerance, and efficient resource utilization.
Learn how to set up Go in Linux, macOS, and Windows, understand its core syntax, manage packages, work with variables, arrays, slices, maps, control structures, goroutines, channels, interfaces, write unit tests, use Go Convey, connect databases with GORM, and build simple web servers with the standard library or Gin.
The article explores Go's seemingly simple syntax but hidden complexities, demonstrating how deleting slice elements, handling performance, and limiting massive numbers of goroutines require non‑trivial code patterns, benchmarks, and careful design to avoid bugs and inefficiencies.
This guide explains how to quickly and securely move files between two computers with the Go‑based Croc tool, covering its key features, command‑line usage, custom relay server setup, and practical examples for cross‑platform transfers.
The article details Go’s G‑M‑P scheduler, showing how lightweight Goroutines (G) run on OS threads (M) bound to virtual processors (P), describing runtime initialization, run‑queue management, work‑stealing, the main schedule loop, execution binding, and cleanup via goexit.
Analyzing several major Go projects, the article catalogs frequent concurrency pitfalls—such as unbuffered channels, WaitGroup deadlocks, context leaks, loop‑variable races, double channel closes, timer errors, and RWMutex misuse—and offers concise, idiomatic fixes to prevent blocking, leaks, panics, and deadlocks.
This guide walks you through Caddy 2’s features, how to compile it from source, install it via systemd or Docker, and configure powerful HTTPS, TLS, plugins, and modular Caddyfile snippets for modern web deployments.
This article introduces ten essential Go open‑source libraries—including Cobra, Viper, Echo, Fx, Swag, Logrus, Mockery, golang‑migrate, NSQ, and sqlx—explaining their purpose, key features, and providing concise code examples to help developers quickly build clean, modular, and maintainable backend services.
This article explains the long‑term benefits of unit testing such as saving time and money, reducing code complexity, providing documentation, and enabling performance evaluation, and then provides a detailed guide on writing, organizing, and running Go tests with code examples.
This article provides a comprehensive overview of KubeVirt, a Kubernetes plugin that enables virtual machine management alongside containers, covering its background, technical selection, core concepts, CRDs, component architecture, common operations, storage and networking options, SDK usage, and integration into a private cloud platform.
This guide introduces GoBoy, a multi‑platform Game Boy and Game Boy Color emulator written in Go, explains how to install it on macOS, Windows, and Linux, and details its usage, debugging commands, and saving features for a complete retro gaming experience.
This article introduces Caddy, a Go‑based web server, compares its advantages over Nginx, and provides step‑by‑step instructions for installing Go, compiling Caddy2 with plugins via xcaddy, configuring Caddyfile snippets, setting up TLS, HTTP/3, and deploying Caddy on both host and Docker environments.
This tutorial shows how to use the Go client-go library to create a command‑line tool that lists PersistentVolumeClaims, watches PVC events in a Kubernetes cluster, and triggers actions when total claimed storage exceeds a configurable threshold.
This article analyzes a microservice client’s connection‑timeout errors in a Kubernetes cluster, investigates Zookeeper‑based service discovery, uncovers one‑time watch semantics and a concurrency bug in rpcx’s channel handling, and presents a fix to ensure IP list updates.
This week’s developer newsletter highlights China’s 11.3‑billion‑parameter Wenhui AI model, Rokid’s dual‑camera MR glasses, the TypeScript 4.2 beta release, a Go generics proposal for 1.18, Docker’s 2021 priorities, the Industrial Internet action plan, a robust DARTS paper from ICLR 2021, and the open‑source TextBox library for text generation.
This article walks through designing and implementing a Go log‑collection agent that uses etcd for configuration storage, context for timeout and metadata handling, and Kafka for message consumption, complete with code examples, setup instructions, and a rate‑limiting utility.
This article examines whether Java microservices can be as fast as Go by presenting a series of benchmark tests using simple services, Helidon and Go toolkits, various JVMs, GraalVM native images, and Kubernetes deployments, and analyzing latency, throughput, and memory usage across multiple hardware configurations.
The article introduces go-mysql-transfer, a Go-implemented MySQL binlog incremental synchronization solution that avoids extra components, supports multiple downstreams like Redis, offers Lua scripting, Prometheus monitoring, high‑availability clustering, retry mechanisms, full data initialization, and provides installation, deployment, and performance testing details.
This article shares the author's experience migrating a high‑traffic platform from PHP to Go, detailing the challenges of framework selection, layered architecture design, incremental refactoring, and the eventual adoption of go‑kit for scalable microservices.
This article explores the Kubernetes kubelet source code, detailing its directory layout, the main kubelet.go entry point, the Run initialization sequence, the sync loop mechanics, and key questions about pod creation, synchronization, networking, volume management, and cleanup within a v1.13 cluster.
The article introduces my2sql, a Go‑written MySQL binlog parser that supports flashback, forward SQL generation, and transaction analysis, compares it with binlog2sql and MyFlash, details its command‑line parameters, demonstrates three practical scenarios, lists limitations, and summarizes its performance and usage advantages.
DeWu transformed its monolithic PHP‑based community platform, which had grown to over 10 million daily users, into a Java/Go microservice architecture using Docker, Kubernetes, gRPC, and modern CI/CD pipelines, establishing clear service boundaries, unified data models, enhanced monitoring, and plans for further scalability and resilience.
This tutorial explains how to create a command‑line interface (CLI) application in Go using the Cobra library, covering project initialization, command and flag definitions, configuration handling with Viper, and extending the tool with sub‑commands for integer, floating‑point, and even‑number calculations.
This article explores the design of a high‑concurrency train ticket‑seckill system, covering 12306 backend architecture, multi‑layer load balancing, Redis‑based stock deduction, Go code examples, performance testing, and strategies to prevent overselling and ensure fault tolerance.
Go 1.16 beta introduces support for 64‑bit ARM macOS, 64‑bit ARM NetBSD, MIPS64 OpenBSD, performance optimizations for RISC‑V, and enables module‑aware mode by default, with upgrade commands provided for developers to download and test the new release.
This article explains the concepts of task scheduling dependencies and workflow, introduces graph theory basics such as vertices, edges, and DAGs, and provides a complete Go implementation—including graph structures, BFS traversal, topological sorting, and concurrent execution—to efficiently manage dependent tasks in distributed systems.
This guide walks you through downloading the open‑source Screego server, configuring TLS, creating user credentials, setting up an Nginx reverse proxy, and launching the service so you can share your screen securely with minimal latency.
This article explains how to build a high‑concurrency ticket‑spike system by analyzing 12306's extreme load, introducing multi‑layer load balancing (OSPF, LVS, Nginx), comparing stock‑deduction strategies, and presenting a Go prototype that uses in‑memory stock, Redis centralized inventory, and weighted Nginx routing to achieve scalable, fault‑tolerant performance.
This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering distributed load‑balancing, Nginx weighted round‑robin configuration, Go‑based local and remote stock deduction with Redis, performance testing, and strategies to avoid overselling and underselling.
This article explores the architecture and implementation of a high‑concurrency ticket‑spike system inspired by China’s 12306 platform, covering load‑balancing strategies, Nginx weighted round‑robin, local and remote inventory deduction, Go concurrency patterns, Redis atomic operations, and performance testing results.
This article explains how Docker's multistage build feature, introduced in version 17.05, enables faster image creation and significantly smaller container sizes by separating build steps into distinct stages within a single Dockerfile, and shows how to target specific stages during the build process.
The article analyzes the extreme‑traffic challenges of China’s 12306 ticket‑spike service, presents a layered load‑balancing architecture using OSPF, LVS, and Nginx weighted round‑robin, and demonstrates a Go‑based prototype that combines local in‑memory stock deduction with Redis‑backed global stock control to achieve stable, high‑throughput ticket purchasing without overselling.
This article explains how Sentinel Go, Alibaba’s open‑source flow‑control library, provides high‑availability protection for microservices through traffic shaping, warm‑up, concurrency control, hotspot limiting, and adaptive system protection, and describes its cloud‑native integrations such as Kubernetes CRD data sources, Service Mesh support, and HPA‑based scaling.
The article explains the challenges of keeping interface model definitions synchronized between development and testing, compares code‑first and doc‑first approaches, introduces the Go‑based GinDoc library for generating Swagger documentation and client code from annotated routes, and provides step‑by‑step usage examples and integration tips.
This article shares Huawei Cloud’s practical experience of using Go to build cloud‑native microservices, covering the evolution of their Service Center, key design patterns such as static‑dynamic information separation, contract‑driven services, dependency management, caching, and the open‑source Go Chassis framework.
This guide shows how Go simplifies unit testing, benchmarking, CPU profiling with pprof, and live debugging using dlv, providing step‑by‑step code examples, command‑line usage, and visual analysis techniques for backend developers.
This guide explains how to embed robust unit tests in Go backend services, outlines the AIR testing principles and common pitfalls, and demonstrates three practical mocking techniques—database stubs, interface‑based gomock, and runtime monkey‑patching—plus CI integration and coverage reporting.
This article explains what Kubernetes Operators are, why they are useful, and provides a detailed walkthrough of building an etcd‑cluster Operator with Go, covering CRDs, reconciliation loops, controller features, permissions, validation, testing, and best‑practice recommendations.
Go's escape analysis determines whether variables are allocated on the stack or heap, influencing garbage collection overhead; this guide explains the analysis principles, shows how to enable compiler logs, and demonstrates through multiple code examples how different patterns cause or avoid variable escape.
This article presents a systematic performance comparison between Java and Go microservices—covering raw speed, memory usage, logging impact, GraalVM native images, and Kubernetes deployments—to reveal when each language excels and the practical trade‑offs involved.
This article walks through Go function fundamentals, showing how functions can be treated as variables, how to define function types, and demonstrating higher‑order functions, anonymous functions, and closures with clear code examples and visual outputs.
This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, covering load‑balancing strategies, Nginx weighted round‑robin configuration, local stock deduction in Go, remote stock control with Redis Lua scripts, and performance testing results.
This article walks through the Dubbo-go client side, showing how the client configuration file and source code are loaded, how URLs and registry protocols are built, how directories and cluster invokers are created, and how a proxy finally enables seamless remote method invocation.
This article delves into advanced Go function concepts, illustrating memory allocation diagrams, variable scopes, the use of const for globals, the behavior of defer statements, and handling errors with panic and recover, complete with code examples and visual outputs to deepen your understanding.
This step‑by‑step guide shows new Linux server users how to configure remote login, switch to fast mirrors, install essential tools like lrzsz and vim, set up environment variables, install Go, and add the vim‑go plugin on a CentOS 8 system.
This article introduces Go functions, explaining why they’re essential, how to define and call them, parameter and return value variations—including variadic arguments—and demonstrates clean code refactoring with practical examples and output screenshots.
This guide walks you through cloning the dubbo-go repository, configuring environment variables, launching a Go server and client, examining the key source files, and understanding the full export and invocation chain—including registry registration, proxy invokers, and filter wrappers—while highlighting common pitfalls.
This guide walks you through installing the Go MongoDB driver, establishing connections, and performing full CRUD operations—including inserting single and multiple documents, querying, updating, and deleting records—while also showing how to retrieve server status and explaining BSON handling in Go.
This tutorial introduces Go's fundamental operators—including arithmetic, relational, logical, bitwise, and assignment types—and explains the language's control flow constructs such as if, switch, for loops, and goto, complete with clear code examples for each concept.
This article introduces Go arrays, covering their definition as contiguous fixed-length collections of identical types, demonstrates various declaration syntaxes, shows how to initialize arrays with explicit values or automatic length inference, explains traversal techniques using for loops and range, and explores multidimensional arrays with practical code examples.
This article provides an in‑depth analysis of Sentinel‑Go, covering its fundamental concepts such as Resource and Rule, the Entry and SlotChain mechanisms, flow‑control components like TrafficShapingController, metric storage structures including BucketWrap and LeapArray, and practical code examples illustrating the library’s internal workflow.
This article provides a comprehensive guide to Go’s fundamental data types—including iota, integers, floats, booleans, strings, and multi‑line strings—complete with explanations, code examples, and common string operations, helping readers deepen their understanding of Go’s core type system.
This article explains Go slice fundamentals, covering how to create slices with make, the relationship between length and capacity, the behavior of append, why zero values appear, the automatic growth mechanism, and how to safely copy slices using the copy function, illustrated with code examples and diagrams.
This article introduces Go slices, explaining why they’re needed, how they differ from arrays, their memory layout, and demonstrates declaration, creation with make, slicing arrays, appending, modifying, deleting, and iterating over elements with clear code examples.
This article introduces Go language variable fundamentals, explaining why variables are needed, common types, various declaration methods—including explicit typing, type inference, short declaration, global and anonymous variables—and constant usage, complemented by code examples and practical tips for effective Go programming.
This tutorial walks you through creating a simple Hello World program in Go on Windows, running it in Goland, and using the go build command to compile the source into an executable file with custom naming options.
This guide explains how to use Sentinel‑Go with Nacos as an external dynamic data source, covering background, installation, configuration, code examples, deployment steps, and how to update flow‑control rules in real time for cloud‑native microservices.
This article explains how to design a Go project layout, differentiate internal and external packages, configure modules, write simple functions, import packages, create command‑line tools, and manage private code, providing practical code examples and best‑practice recommendations for backend developers.
This article explains Go's channel primitive, comparing unbuffered and buffered channels, demonstrates how to avoid deadlocks with proper goroutine coordination, and shows typical patterns such as select, closing channels, and building concurrency controllers for robust backend services.
The article explains Linux shared‑memory fundamentals, why it outperforms file‑based IPC, demonstrates the mmap() system call, and walks through a complete Go implementation that creates, synchronizes, reads, and protobuf‑serializes advertising‑tracking metrics in the VCS monitoring platform.
The article outlines dubbogo's five‑year evolution, its milestone‑driven roadmap, the launch of dubbo-go-proxy, community recruitment, management practices, tooling, code‑quality measures, and future challenges, providing a comprehensive view of this Go‑based backend framework.
This guide walks through deploying clickhouse-exporter, configuring Prometheus to scrape its metrics, and importing a Grafana dashboard to monitor ClickHouse single‑node or cluster performance, providing a practical monitoring solution for the database.
Analyzing recent Stack Overflow surveys and GitHub trends, this article explains why Go's efficiency, simplicity, and rising popularity make it a strong contender for the best backend programming language in 2021, even as JavaScript and Python dominate the market.
The article shares a developer’s firsthand comparison of Java and Go, covering their histories, syntax, garbage collection, concurrency models, reflection, inheritance, dependency management, and practical pros and cons, to help readers decide which language better fits their backend projects.
This guide walks you through setting up a GitLab CI environment, configuring a Docker‑enabled runner, writing Dockerfile and .gitlab-ci.yml files, and automating code compilation, container image creation, and deployment of a Go application, complete with command examples and troubleshooting tips.
Analyzing recent Stack Overflow and GitHub data, this article predicts that Python, JavaScript (Node.js), and Go will be the three most popular programming languages in 2021, explaining their broad applications, ease of use, and strong community support that drive their rising demand.
This article provides a comprehensive introduction to the Go programming language, covering its core features, basic syntax, concurrency with goroutines and channels, data types, error handling, and recommended development tools, all illustrated with clear code examples.
The article explains why serialization is essential for inter‑process communication, compares common formats like JSON, Protobuf, Kryo, and custom binary schemes, outlines selection criteria such as readability, complexity, speed and density, and provides code examples and interview‑style Q&A for high‑performance messaging systems.
This article explains why Python's ctypes returns incorrect values when invoking Go-compiled shared libraries, shows how to map C types correctly, and provides step‑by‑step code examples for handling both integer and string return values using proper restype declarations.
This article provides a detailed examination of Gin's routing mechanism in Go, describing the internal prefix‑tree data structures, the algorithms for building and searching the tree, code walkthroughs of key functions such as addRoute and findWildcard, and case studies of typical and edge‑case route configurations.
This article introduces Filebeat as a lightweight log shipper, explains its core components and processing flow, and provides step‑by‑step configuration examples for gathering container logs and forwarding them to Kafka or Elasticsearch in cloud‑native environments.
Learn how to overcome Python's GIL limitations by compiling Go code into a shared .so library, invoking it from Python, and comparing performance gains, with step‑by‑step instructions, code examples, and troubleshooting tips for faster computation‑intensive tasks.
Dubbo-go v1.5 introduces an application‑level service registration model, a metadata center for interface data, Kubernetes‑native registration, enhanced routing, and security features like TLS, while maintaining full compatibility with Dubbo 2.7.x and preparing for future cloud‑native evolution.
This article demonstrates how Go's support for recursive types enables elegant implementations of data structures such as tries and finite automata, functional constructs like stacks and pointers, and classic concepts including balanced braces, the Y combinator, and Church numerals, providing practical code examples throughout.
This article provides a comprehensive source‑level examination of Go's channel mechanism—including usage examples, the internal hchan data structure, creation, read/write operations, closing behavior, and common pitfalls—based on the Go 1.14 runtime implementation.
After years of using Python for AI and data science, the author examines its flexibility drawbacks and argues that Go+, with its static typing and concise syntax, can address Python’s limitations, offering comparable ease for tensor operations, potential for a new deep‑learning front‑end language.
This article outlines the challenges of scaling parking services to cloud SaaS—including network latency, real‑time processing, and data integrity—and presents a comprehensive stability strategy using MQTT, dual‑network backup, Go‑based process supervision, and edge‑cloud collaboration to achieve high‑availability unattended parking operations.
This article introduces Go (Golang) as a statically typed compiled language, walks through downloading and installing the Go toolchain, explains essential syntax such as slices, pointers, and channels with code examples, and briefly reviews popular Go web frameworks like Beego, Iris, and Buffalo.
This article introduces the Go programming language, guides readers through downloading and installing the Go toolchain, explains essential syntax such as slices, pointers, and channels with code examples, and surveys popular Go web frameworks like Beego, Iris, and Buffalo for backend development.
Learn how to create a simple interactive cat‑themed canvas game for mobile browsers using Go compiled to WebAssembly, covering environment setup with Docker, Go code for DOM manipulation, event handling, rendering, audio, and deployment, while explaining WASM concepts and differences from Service and Web Workers.
This article summarizes the key changes in the new Go generics design draft, explaining type constraints, multiple type parameters, type lists, generic structs, and method‑based constraints, and includes practical Go code snippets to illustrate each feature.
The article explains why creating unlimited Goroutines in Go can exhaust system resources, demonstrates the problem with a sample program, and presents practical methods—including channel throttling, sync.WaitGroup, and third‑party Goroutine pools—to safely limit concurrency and improve performance.
This article surveys the rise of microservices, explains their advantages, and provides a concise overview of the most popular Java, .NET, Node.js, Go, and Python frameworks that enable developers to build scalable, loosely‑coupled services.
This guide walks you through enabling the Windows Subsystem for Linux, installing Ubuntu from the Microsoft Store, configuring your user, updating packages, and adding the Go programming language, providing clear screenshots and command examples for a smooth cross‑platform development setup.
Douyu's Go team explains how the Jupiter framework was born from internal needs, its evolution through multi‑data‑center and cloud‑native transitions, its differences from other Go microservice solutions, and the company's open‑source strategy and future plans.
This article shares practical dubbo-go experience at Tuya Smart, covering the gateway architecture, generic invocation mechanics, step‑by‑step integration, configuration pitfalls, performance tuning, and extension points to help developers adopt the high‑performance RPC framework efficiently.
Monzo, the UK digital bank, shares how it built a Kubernetes‑based, cloud‑native platform to run over 1,600 Go‑written microservices backed by Cassandra, implements fine‑grained service isolation with network policies, and creates internal tooling to automate security and deployment at massive scale.
