This article introduces tldb's distributed lock mechanism, explains lock, trylock, and unlock methods, and provides step‑by‑step Go and Java client examples—including code snippets—for acquiring and releasing locks in a multi‑language environment.
This article introduces the YAML format, outlines its syntax rules, and demonstrates how the Go library gopkg.in/yaml.v3 can be used for parsing and generating YAML files, including basic examples, advanced struct mapping, and a summary of its key advantages for backend development.
Go 1.23 introduces a garbage‑collectable, synchronous timer channel implementation that eliminates resource leaks and race conditions, requiring code changes such as replacing len‑checks with non‑blocking selects and offering GODEBUG flags for toggling the new behavior during testing and production.
This article dissects Go's runtime GPM model and the lock‑free runq data structure, detailing its fields, core operations such as runqput, runqget, runqgrab, and their atomic implementations, while also comparing local and global queues and illustrating the code paths with concrete examples.
C++ graduates often fail backend interviews at major internet firms because those companies favor Java or Go and expect experience with databases, caches, and message queues, so candidates should either acquire those backend skills, switch to the dominant languages, or target C++‑friendly domains such as embedded, AV, gaming, or client‑side networking.
This guide explains the challenges of multiple logins in enterprises, introduces Single Sign‑On concepts and protocols, and provides a step‑by‑step deployment of an open‑source Go‑Vue SSO solution, covering authentication methods, supported protocols, security features, and Docker‑based installation.
The article analyzes why C++‑focused graduates receive few backend interview opportunities at major internet firms, highlights the mismatch between C++ skill sets and common backend components, and offers practical advice on switching languages or augmenting projects to better align with industry demands.
This article introduces GoFakeIt, a lightweight Go library for quickly generating diverse fake data—personal, address, financial, network, and more—explains its key features, shows how to install it via go get, and provides practical code examples for each data type.
This article examines Go’s internal lock‑free single‑producer multi‑consumer queues—PoolDequeue and its dynamic extension PoolChain—detailing their design, atomic operations, and benchmark comparisons that show they can be up to ten times faster than standard channels in a producer‑consumer workload.
This article introduces Go's benchmarking framework, explains its purpose and best practices, provides step‑by‑step code examples for measuring string concatenation performance, shows how to run benchmarks from the command line, and teaches how to interpret the detailed test reports.
This article presents ByteDance's compile‑time microservice merging technique, describing its background, performance benefits, technical challenges such as dependency isolation and call conversion, the implemented solutions, selection criteria, large‑scale impact, and future directions for service architecture governance.
This article shares the most frequent Go middleware pitfalls encountered at Alibaba, explains their root causes—from uneven request distribution and CPU leaks to transaction mishandling and SQL incompatibilities—and provides concrete solutions and best‑practice recommendations to help developers avoid repeating these errors.
This article explores Goja, a pure‑Go JavaScript engine, detailing its features, integration with the K6 load‑testing tool, and practical code examples for embedding scripts, passing values, handling structs, invoking Go functions, error handling, and VM pooling to achieve high performance in Go applications.
This article explains why bit manipulation is a staple technique in computer science, detailing performance gains, state flag encoding, mask operations, data compression, cryptography, image processing, hash structures, binary counting, and algorithm design, with practical Go examples.
This article explains ByteDance’s merge‑compilation technique that combines multiple microservices into a single binary at build time, detailing its performance benefits, architectural trade‑offs, dependency isolation, call conversion, version management, real‑world case studies, and future roadmap for large‑scale service optimization.
This article examines the concept of weak pointers and weak references in Go, Rust, Java, and C#, comparing their implementations, explaining their memory‑management semantics, presenting concrete code examples, and discussing the upcoming Go weak‑pointer proposal and practical scenarios such as caching and event handling.
This article explains Go's core concepts, covering package definitions and imports, variable declaration styles and scopes, as well as constant usage with iota, providing clear examples and code snippets to help developers understand and apply these fundamentals effectively.
Conan is an automated profiling solution for Go microservices that embeds an SDK to continuously or adaptively sample CPU, memory and goroutine metrics, detects anomalies via user‑defined rules, uploads data to a Pyroscope server, and reports results through Feishu or Pyroscope, delivering sub‑5 % overhead and faster root‑cause analysis.
This article compares the most popular Go web frameworks—Beego, Buffalo, Echo, Gin, Iris, and Revel—by popularity, learning curve, and core features, providing repository links and visual rankings to help developers choose the right tool for their projects.
This article explains how to add colors to terminal output using the Go language, introduces the fatih/color package with practical code examples, demonstrates mixing colors, writing to files, building a Cobra-based CLI demo, and details the underlying ANSI escape sequence mechanism.
This article dissects Kubelet's Pod admission pipeline, explaining how syncLoopIteration gathers pod data, how HandlePodAdditions invokes canAdmitPod, and how six registered admit handlers—Eviction, System Allowlist, Resource Allocation, Predicate, AppArmor, and Shutdown—evaluate each pod with concrete code examples and decision logic.
This article explains how to monitor MySQL slow queries by attaching eBPF uprobe/uretprobe probes to the dispatch_command function, handling symbol mangling across MySQL versions, and processing the captured data in a Go program to display latency and SQL statements.
This article introduces tldb's distributed lock mechanism, explains lock, trylock, and unlock methods, provides Go and Java client examples, and also includes promotional information about ChatGPT services and a developer community for developers.
This article explains how to monitor Go goroutine state transitions without modifying source code by attaching eBPF uprobes to the runtime.casgstatus function, defining a custom data struct, using a ring buffer to deliver events, and processing them in a Go user‑space program.
This article explores the internal structure and growth mechanism of Go's bytes.Buffer, demonstrates how the GWS library replaces gorilla/websocket, and presents a high‑performance bytes.Buffer pool implementation using sync.Pool with power‑of‑two sizing to reduce allocations and improve concurrency in backend services.
This guide introduces JsRpc, a lightweight WebSocket‑based bridge that lets a Go server communicate with injected JavaScript in the browser, enabling reverse‑engineering of encrypted functions and data extraction through easy API calls.
An in‑depth guide compares Go and Rust across memory management, learning curve, concurrency, ecosystem, performance, developer experience, and real‑world use cases, helping developers decide which language best fits cloud‑native services, system programming, web development, game development, or DevOps tools.
This article explains what an API gateway is, outlines its core data‑plane and control‑plane functions, compares popular open‑source gateways such as Nginx, Zuul, Spring Cloud Gateway, Kong and Traefik, and then details a custom Traefik‑based microservice gateway built with Go and Etcd.
This article dissects Kubelet's ImageManager and ImageGCManager, detailing their interfaces, implementation structs, pull‑policy handling, parallel image pulling, GC policy thresholds, and the step‑by‑step execution flow that governs image lifecycle on a node.
This article curates a collection of essential Go open‑source projects—including core libraries like Gin, go‑zero, and GORM, middleware such as etcd and Kubernetes, learning roadmaps, and useful resources—providing brief descriptions, star counts, and direct GitHub URLs to help developers deepen their Go expertise.
This article walks through SeaweedFS 3.46’s source code, showing how to launch Master, Volume, and Filer servers, how Raft leader election is wired, and the exact request‑response flow for uploading and downloading files, complete with command‑line examples and code snippets.
This article explains how to use eBPF fentry and fexit probes to monitor the Linux unlink system call, compares them with kprobes, provides complete C and Go examples, shows compilation with eunomia‑bpf, and discusses the low‑overhead advantages of fentry for kernel tracing.
This article introduces eBPF fundamentals, explains the Compile‑Once‑Run‑Everywhere (CO‑RE) approach, compares it with traditional eBPF, outlines best practices, and walks through a complete Go‑based example using the Cilium/eBPF library and the eunomia‑bpf runtime.
This guide walks through the purpose, advantages, required Linux packages, Go libraries, exact installation commands, and version details needed to set up a functional eBPF development environment on an Ubuntu system, while explaining each step’s rationale.
This article provides a comprehensive guide to Go's concurrency model, covering goroutine creation, the scheduler, communication via channels, handling race conditions, and synchronization techniques using atomic operations and mutexes, complete with practical code examples and visual diagrams.
This article analyzes a Go program that deadlocks due to misuse of unbuffered channels and select, explains the underlying behavior of channels, blocking conditions, and select semantics, and provides a simple fix by buffering the stop channel while also covering Go's CSP roots and best‑practice guidelines.
Mule is a Go library that lets developers craft custom UDP packets, capture ICMP unreachable responses, and perform low‑level network diagnostics such as port scanning, topology mapping, and security testing, offering fine‑grained control through raw socket operations and a net.Conn‑compatible API.
This course teaches developers with basic Go knowledge how to design and implement GraphQL servers, covering core GraphQL concepts, Go integration, practical examples, CI/CD deployment, and tools like gqlgen and GraphQL Playground to create modern, flexible APIs.
This article walks through creating a first eBPF program using C and Go on Ubuntu 22.04, covering required dependencies, kernel‑space vs user‑space concepts, event selection, BPF map definition, and a tracepoint function that measures per‑process CPU time.
This guide explains how to create a cross‑platform Go command‑line utility that efficiently splits multi‑gigabyte files on Windows into user‑defined chunk sizes, covering the rationale for using Go, core implementation steps, full source code, and practical usage instructions.
The article dissects Kubelet’s VolumeManager, detailing its asynchronous loops, the VolumeManager interface, how it is started from Kubelet.Run, the handling of Attach/Mount and Unmount operations during pod sync, the internal struct fields, and the plugin initialization process that together manage the full lifecycle of pod volumes.
This article explains how Go modules define version information through the go directive, toolchain directive, go env GOTOOLCHAIN variable, and system GOTOOLCHAIN environment variable, detailing their syntax, effects, interactions, and priority rules for reliable project builds.
Go 1.23 introduces a range‑over‑func iterator, generic type alias preview, optional telemetry, several go command enhancements, numerous standard library updates, and compiler and linker optimizations, providing developers with a more powerful and flexible programming environment.
This article compiles a series of technical interview questions and answers covering C++ and Go language differences, thread communication methods on Linux and Windows, stack versus heap memory, orphan processes, read‑write locks, Go goroutine concurrency, TCP three‑way handshake, and a sample SQL query for gender‑based grouping.
The article explains that the apparent probeCh in kubelet is actually three separate channels—livenessCh, readinessCh, and startupCh—managed by livenessManager, readinessManager, and startupManager, details the ProbeManager implementation that creates probe workers via AddPod, and shows how syncLoopIteration processes probe updates to adjust pod status.
The article presents ten classic software design patterns—Singleton, Factory, Observer, Decorator, Strategy, Adapter, Proxy, Command, Composite, and Iterator—explaining each pattern’s features, advantages, disadvantages, typical applications, and providing concrete Go code examples to illustrate their implementation.
Gocron is an open‑source Go scheduler that replaces Linux‑crontab with a lightweight, web‑driven interface, offering precise timing, retries, dependencies, and notifications for developers and operators seeking efficient task automation.
A Fastly engineer discovered that increasing CPU cores can degrade Go channel performance due to lock contention, and this article reproduces the benchmarks, explains why goroutine count—not CPU count—is the real culprit, and offers practical optimization techniques.
This article thoroughly examines the Gin Go web framework, focusing on its compressed radix tree routing mechanism, middleware handling, request lifecycle, and performance‑optimizing techniques, providing code examples and best‑practice recommendations for building high‑throughput backend services.
This article explains how Go's net/http package leverages function types combined with interfaces—particularly the Handler and HandlerFunc types—to create concise, flexible HTTP servers, reducing boilerplate, improving code reuse and testability, and demonstrates practical examples and underlying implementations.
This article explains how to implement graceful shutdown for Go programs, covering signal handling with os/signal, closing HTTP servers without interrupting active connections, managing goroutine lifecycles, and providing complete example code for both the standard net/http package and the Gin framework.
This article explains Go's unique error handling approach, covering the built-in error interface, creating errors with errors.New, wrapping errors using fmt.Errorf, defining custom error types, logging errors with the log package, and managing severe failures with panic and recover, complete with practical code examples.
This tutorial walks through setting up OpenTelemetry tracing from scratch for both Java and Go microservices, covering collector and Jaeger deployment, required dependencies, configuration parameters, code examples for automatic and manual instrumentation, and how to add custom span attributes and spans.
This guide walks through installing Viper, creating common and environment‑specific YAML configuration files, mapping them to Go structs, setting up a global configuration holder, and initializing the config with live watching, providing a complete, runnable example for Go backend projects.
This course teaches developers with basic Go knowledge how to design and implement GraphQL services, covering fundamentals of GraphQL, schema definition, request handling, and integration techniques through practical examples to build modern, flexible APIs.
This article compares five popular Go web frameworks—Gin, Echo, Beego, Revel, and Buffalo—detailing their strengths, weaknesses, and code examples to help developers select the most suitable tool for their project requirements and performance goals.
This article explains why mastering Kubernetes is key to cloud computing, outlines its rapid growth and ecosystem support, and provides practical steps, design‑pattern guidance, and community resources for effectively reading and understanding the Kubernetes source code.
Learn how to install the Viper library in Go, read and parse YAML, JSON, TOML, and ENV files, and leverage features like default values, automatic reload, environment variable binding, merging configs, dynamic updates, and struct unmarshalling through clear code examples.
This guide explains how to use Alibaba Cloud MSE to add traffic control, circuit breaking, gray release and other governance capabilities to Go microservices without modifying business code, covering compilation injection, deployment steps, and practical demo configurations.
This article explains Go’s dead code elimination (DCE) optimization, demonstrates it with sample code, shows how to inspect compiled binaries using go tool nm, and discusses factors that affect DCE such as code complexity, compiler flags, and reflection, helping developers reduce binary size.
Learn how to use Go's net package for low‑level socket programming—including TCP, UDP, and ICMP connections with the Dial function—and build HTTP clients with net/http, covering basic requests, POST forms, custom headers, and practical code examples.
The article investigates Go 1.22’s claim that simple type casting []byte(str) can replace unsafe‑based string‑to‑byte conversions, presents four implementation variants, runs detailed benchmarks on macOS M2 and Linux amd64, analyses compiler inlining and escape behavior, and explains the hidden pitfalls of capacity and mutability in the k8s shortcut.
This article walks through six common Go interview mistakes—incorrect function brace placement, map initialization without make, unexported struct fields for JSON, ineffective slice iteration, array versus slice parameter passing, and variable shadowing with :=—explaining each issue and providing the correct code examples.
This article explains the importance of caching, compares common replacement policies, and walks through a complete Go implementation of a thread‑safe local LRU cache, including interface design, data structures, linked‑list management, and concurrency handling.
This article demonstrates step‑by‑step how Go's reflection and unsafe packages can be leveraged to bypass the language's encapsulation, allowing reading, writing, and even assigning unaddressable private struct fields by manipulating internal flag bits and using low‑level pointer tricks.
This article introduces the Go Cobra library, outlines its key features such as multi‑command structures, flag handling, auto‑generated help and markdown docs, and provides step‑by‑step code examples for creating, configuring, and extending CLI applications with flags, positional arguments, persistent flags, and subcommands.
This article demonstrates how to analyze and optimize Go's garbage collection using go trace, comparing single‑threaded and concurrent implementations, and shows how tuning GOGC and GOMEMLIMIT can dramatically improve runtime and memory usage, with detailed code samples and performance metrics.
This article examines why Go’s fasthttp library can outperform the standard net/http package by up to tenfold, covering memory allocation strategies, zero‑copy techniques, connection pooling, and additional optimizations, and offers guidance on when to choose each library for high‑performance backend services.
This article explains the Adapter design pattern, illustrates its real‑world analogy, demonstrates a complete Go implementation for payment processing, and shows how the pattern can be used in production scenarios such as a multi‑cloud management platform and a model‑training service, highlighting its role in unifying incompatible interfaces.
This article explains how Alibaba Cloud's ARMS team collaborated with the language and compiler team to create an OpenTelemetry‑based, compile‑time automatic instrumentation solution for Golang applications, detailing its background, technical workflow, key optimizations, and practical impact on cloud‑native monitoring.
This article details the author's comprehensive refactor of the WorkQueue Go library, covering the redesign of its sorting heap using a red‑black tree, interface improvements, enhanced data structures, extensive performance benchmarks, and a step‑by‑step usage guide for developers.
This article dives deep into Uber's fx dependency‑injection framework for Go, explaining advanced constructs such as fx.Invoke, fx.Supply, fx.Populate, fx.Annotated, fx.In, fx.Out, fx.Module, fx.WithLogger and fx.As, and provides complete code examples that illustrate how to manage lifecycles, inject static values, differentiate multiple implementations, and customize logging in production‑grade applications.
This guide explains how to leverage Docker’s layer caching by separating dependency installation from source code copying, using Go as an example, and provides optimized Dockerfile patterns that cut build times and can be adapted to Node.js and Python projects.
This article explains the core concepts of dependency injection, introduces Uber’s Fx framework for Go, and provides step‑by‑step code examples that demonstrate how to register providers, manage application lifecycles, and use hooks for start‑up and shutdown logic.
This article demonstrates how to quickly build and benchmark a Spring Boot 2.x application as a native binary, compares its startup time, memory usage, and request throughput with equivalent implementations in Go and Rust, and concludes that AOT‑processed Java offers impressive performance despite longer compilation times.
This article presents a comprehensive technical deep‑dive into Go‑Job, a Go‑native distributed task scheduling framework, covering its background, three‑layer architecture, service and task design, SDK modules, code examples, practical integration steps, and future enhancements for robust backend operations.
This article provides a comprehensive guide to Viper, a powerful Go configuration library, covering its core advantages, step‑by‑step basic usage—including installation, defaults, file handling, environment variables, command‑line flags, remote providers—and advanced techniques such as sub‑tree reading, custom decoding, and managing multiple Viper instances.
This tutorial introduces the Gin web framework for Go, covering its core features, installation steps, a simple "Hello World" example, request and response handling, parameter binding, route groups, middleware patterns, and useful utilities for building fast RESTful services.
This article examines why Go's garbage collector can become a CPU bottleneck with large heaps, demonstrates the performance impact with benchmark programs, and presents practical strategies—such as using pointer‑free allocations, mmap‑backed memory, and string interning—to dramatically reduce GC pause times.
The article explains why a backend team moved from PHP to Go for high‑concurrency live‑streaming services and demonstrates two Go concurrency patterns—sync.WaitGroup and errgroup—with code examples and common pitfalls.
This article explains how to use Go's context package for managing request-scoped data, cancellation, deadlines, and timeouts, compares it with Java's ThreadLocal approach, and provides practical code examples for creating contexts, handling goroutine lifecycles, and applying context in network programming.
This guide demonstrates how to create a simple Go web API using the Gin framework, define a recipe data model, implement CRUD endpoints backed by MongoDB, add Redis caching for list queries, and provide a complete runnable example with testing scripts.
This article explains Go's memory management by detailing stack and heap differences, describing classic and modern garbage‑collection algorithms, tracing the evolution of Go's GC from version 1.3 to 1.8, and outlining a complete GC cycle with practical code examples.
This article explains Go's GMP model—how work threads (M), logical processors (P), and goroutines (G) interact, detailing their internal structures, scheduling strategies, run‑queue management, work stealing, and both active and passive preemptive scheduling with concrete code examples.
This article explores Polaris‑Mesh’s server‑side health‑check mechanism, detailing how client heartbeat requests are received via gRPC, processed through Apiserver, Resource Auth Filter, Service, Healthcheck, and Checker Plugin, and how the system’s configuration, plugins, and time‑wheel ensure reliable instance health monitoring.
This article explains how Prometheus generates and sends alerts, covering the definition of alert rules with PromQL, grouping, templating, configuring evaluation intervals, deploying a custom alert receiver in Kubernetes, and analyzing alert payloads and delivery frequency, while also detailing alert silencing and resolution behavior.
This article compares Python, Go, and Rust, outlining each language's strengths, weaknesses, and ideal use cases, and includes practical factorial code examples to help developers choose the most suitable language for their specific project requirements.
This guide explains how Beego's Controller component works within the MVC architecture, shows how to define and embed a controller in Go, demonstrates common request‑handling methods, and walks through the underlying source code and interface definitions for full backend control.
This article explains how the tunny library wraps goroutine processing units into a workWrapper to limit concurrency, describes the workerWrapper.run flow that queues workRequests via reqChan, details the workRequest structure with jobChan and retChan, and outlines the required Worker interface methods for custom processing.
This article explains how to leverage Redis Stack modules such as RedisJSON, RediSearch, and RedisTimeSeries to store, index, and query high‑dimensional vectors for image‑search services, providing Go code examples for index creation, bulk insertion, memory inspection, and K‑Nearest‑Neighbour vector searches with optional filtering.
The Go core team leader rsc recently marked several popular Go libraries that rely on the //go:linkname directive as incompatible with the upcoming Go 1.23 release, prompting urgent fixes and discussion about runtime symbol linking and migration timelines.
This guide introduces Gogs, a Go‑based open‑source Git server, outlines its key features, and provides step‑by‑step instructions for downloading the binary, extracting it, launching the service, and verifying a successful installation across multiple platforms.
This guide explains how Go Agent solves the manual instrumentation problem in Go microservices by injecting monitoring code at compile time, details its implementation using AST analysis and -toolexec, lists supported SDKs and product features, and provides step‑by‑step instructions for installing the ARMS component, compiling Go binaries, granting permissions, and enabling monitoring on Alibaba Cloud ACK clusters.
This article explains how to use Go's httptest package and the gock library to mock HTTP servers and external API calls, providing step‑by‑step code examples, test case structures, and installation instructions for effective backend unit testing.
This guide explains how the Go Agent injects observability code at compile time to provide automatic tracing and metrics for Golang microservices running on Kubernetes, covering its architecture, supported SDKs, compatibility, and step‑by‑step deployment instructions including component installation, binary compilation, and YAML configuration.
This article explains the concept of observability, details Prometheus metric definitions and types, and provides Go code examples for exposing, defining, generating, and scraping business‑level metrics in a Kubernetes‑based cloud‑native environment.
This article introduces etcd as a reliable distributed key‑value store built on Raft, outlines its key features and common use cases such as service discovery and configuration management, and provides a complete Go tutorial covering dependency setup, server launch, client implementation, read/write testing, and distributed lock usage.
This article explains Go's syntactic sugar—such as variadic parameters and the := assignment operator—showing how these language shortcuts improve readability, reduce boilerplate, and help developers write clearer, more maintainable code.
This article explores PolarisMesh’s server-side registration process, detailing how client registration requests are handled, the data flow through apiserver, resource auth filter, service and storage layers, and provides concrete code examples for both Java and Go SDKs, along with MySQL storage schema.
Aliaksandr Valialkin criticizes Go 1.23’s new iterator feature, arguing it adds hidden control‑flow, memory overhead and readability challenges to an already minimalist language, and warns that such complexity undermines Go’s goals of simplicity, productivity, and performance.
