The article explains how to design and implement a sharded WorkQueue in Kubernetes' controller-runtime, enabling concurrent processing while guaranteeing that resources belonging to the same node are handled sequentially within a single goroutine, using hash-based partitioning and custom queue structures.
This article presents a comprehensive, step‑by‑step analysis of Go naming conventions, explaining why each rule matters, illustrating each point with concrete code snippets and real‑world examples, and showing how to apply the guidelines to variables, functions, packages, structs, interfaces, errors, constants, enums and comments for truly clean Go code.
This tutorial explains how to containerize a simple Go web application with Docker, set up a development workflow using Docker and Bee, build and run images, and automate continuous integration and deployment with Semaphore, covering prerequisites, Dockerfile creation, testing, and production deployment steps.
This course teaches developers with Go experience how to design and implement GraphQL APIs, covering fundamentals, server construction, request handling, schema definition, and practical deployment techniques to enhance data interaction flexibility and efficiency.
The proposal introduces a ‘?’ operator to automatically handle errors in Go, aiming to reduce boilerplate while preserving explicitness, but it raises concerns about code readability, variable shadowing, and the effort required to update existing codebases.
Learn how to integrate Go and Java by compiling Go code into a shared library, exposing functions via cgo and JNI, and invoking them from Java with detailed setup, code examples, handling of primitive and complex data types, and full build‑and‑run instructions.
This article walks through Go's concurrency model, detailing how goroutines are scheduled across logical processors, how to control parallelism with GOMAXPROCS, detect and resolve race conditions using atomic operations, mutexes, and channels, and provides practical code examples for each concept.
An in‑depth look at Go’s origins, design goals, and the trade‑offs that provoke both admiration for its simplicity in large‑scale server development and criticism over its limited generics, file‑system API, error handling, and FFI capabilities.
This article explains Go's Context concept, its role in managing Goroutine lifecycles, the standard library's context package API, how to create and cancel contexts, share values safely, and best practices for using Contexts in concurrent backend applications.
This comprehensive guide walks through Go’s net package, detailing how Listener functions create servers, how Dial functions initiate client connections, the nuances of network and address formats, and the behavior of various Conn types such as TCPConn, UDPConn, IPConn, and RawConn, complete with code examples and best‑practice tips.
Using a local Go server and Wireshark, the author measured that a basic HTTPS request transmits 2,164 bytes—about ten times more than an equivalent HTTP request—revealing the bandwidth impact of TLS handshakes and suggesting when HTTP may be preferable for internal, non‑sensitive traffic.
This article outlines a comprehensive guide to Go's concurrency model, covering fundamental concepts, goroutine scheduling, synchronization primitives, channel communication, common patterns, deadlock avoidance techniques, and performance‑optimizing mechanisms with concrete code examples and step‑by‑step explanations.
This article explains how Go 1.24 rewrote its built‑in map with a SwissTable‑based hash table, compares it to Dolt’s SwissMap implementation, and details the underlying data structures, algorithms, and performance benefits.
This article explains Go's untyped constants, how they inherit default types, the representability mechanism that lets them match target types, the hidden bugs it can cause in enums and APIs, and practical tips to write safer code.
This guide walks through the challenges of manual Go releases, compares two naive deployment approaches, and presents a streamlined solution using GitLab CI pipelines, Makefile automation, and Jenkins to decouple development from operations while ensuring reliable versioned deployments.
The article explains how Go 1.24 finally enables type aliases to have their own generic type parameters, provides background on the previous limitation, demonstrates usage with concrete code examples, and notes the experimental flag required in Go 1.23.
This article explains the Go runtime’s garbage‑collector optimization that skips scanning objects without pointers, describes how the noscan flag is set during memory allocation, shows the code paths that enforce the skip, benchmarks the performance gain, and offers practical tips for applying the technique in real‑world Go programs.
This article compares Java and Go across syntax, type systems, object‑oriented features, pointer usage, error handling, concurrency models, and reflection, providing code examples to illustrate the practical differences and trade‑offs for developers transitioning between the two languages.
This article reviews five leading Go frameworks and libraries—Gin, Beego, Echo, Buffalo, and GORM—detailing their core features, typical use cases, and reasons to choose each, helping developers select the most suitable tools for modern backend and full‑stack development in 2024.
This article compares Java and Go across syntax simplicity, type systems, object‑oriented features, pointers, error handling, concurrency, reflection, and community culture, providing concrete code examples and practical insights to help Java developers transition smoothly to Go.
This article compares three Go observability solutions—SDK instrumentation, eBPF‑based monitoring, and compile‑time code injection—explaining their mechanisms, open‑source implementations, trade‑offs, and why Alibaba Cloud's Instgo compile‑time approach offers a low‑overhead, non‑intrusive APM alternative.
This article introduces tcpw, a small eBPF‑based utility that traces TCP, UDP, and Unix‑domain sockets to display the five‑tuple of commands like curl or telnet, explains its command‑line options, shows concrete usage examples, and details the underlying BPF and Go implementation, including connect, accept, and fork tracing.
This article explains how Go's testing/synctest experiment speeds up cache expiration tests by using a virtual clock and bubble isolation, providing code examples that reduce a five‑second wait to milliseconds while ensuring reliable concurrent test execution.
This tutorial walks new Go developers through naming a project, initializing a module, creating the essential directory layout and files, adding tests, and building a simple CLI while emphasizing Go's KISS and YAGNI principles.
This article explains the limitations of Go's runtime.SetFinalizer, introduces the new runtime.AddCleanup function in Go 1.24, demonstrates proper usage with code examples, and highlights important pitfalls and best‑practice tips for reliable resource management.
This article evaluates the startup speed, memory consumption, and request‑handling throughput of a Spring Boot application built as a GraalVM native binary, a regular JAR, and equivalent services written in Go and Rust, highlighting the trade‑offs of AOT compilation for backend development.
This article explains how Go developers can break circular import problems in the context package by using XTest‑prefixed helper functions together with a regular Test wrapper, and also demonstrates the export_test.go "backdoor" technique for accessing unexported symbols in black‑box tests.
This article examines five Go implementations of a broadcast notifier—using sync.Cond, channels, context, sync.WaitGroup, and sync.RWMutex—detailing their code, execution flow, and trade‑offs so readers can understand how each primitive achieves notification broadcasting.
Postfix type declarations, as seen in modern languages such as Go and Rust, place the type after the variable name—a style the author links to cultural naming conventions, arguing it highlights identifiers and can enhance readability after compilation, a practice historically validated by Pascal and Delphi.
This article explains the newly added os.Root type and os.OpenRoot function in Go 1.24, demonstrates how they restrict file operations to a specific directory, and shows how they prevent classic directory‑traversal exploits such as CVE‑2024‑3400.
This article compares the most popular Go web frameworks—Beego, Buffalo, Echo, Gin, Iris, and Revel—by evaluating popularity, learning curve, core features, routing capabilities, middleware, server options, templating, testing, and more, helping developers choose the best fit for production applications.
The article benchmarks a Spring Boot 3 service as a GraalVM native image, a traditional JAR, and Go and Rust versions, showing the native binary starts in under a second with ~70 MB memory and 7 k requests/s, the JAR needs seconds and 200 MB, while Go and Rust use 10 MB and 3 MB respectively with throughput, illustrating native images’ fast startup and lower runtime footprint despite longer compilation.
This article analyses the pitfalls of traditional error‑checking and panic handling in Go order‑processing code, demonstrates how excessive inline checks and scattered defer statements lead to maintenance nightmares, and proposes a reusable try‑catch‑finally library that cleanly separates business logic, unifies panic recovery, and guarantees resource cleanup.
This article explains how the Go library BigCache uses sharding, efficient hash functions, and memory‑optimised data structures to deliver high‑concurrency, low‑latency caching, while avoiding GC bottlenecks and providing practical code examples and performance benchmarks.
The article compares Go’s stackful, green‑thread model with Rust’s stackless, future‑based approach, explaining how each runtime schedules tasks, the memory overhead of goroutine stacks (2 KiB minimum in Go 1.22), the challenges of async‑await integration, and why Rust’s performance gains come with a fragmented ecosystem.
The article analyses a large‑scale benchmark comparing Go, C, Rust, C# and other languages under single, 100 k and 1 M concurrent tasks, revealing how Go’s 64‑bit int array size and goroutine stack overhead cause dramatically higher memory consumption despite comparable CPU performance.
This tutorial walks you through the concepts of Kubernetes Operators, explains how to set up a development environment, create a simple Foo operator using Kubebuilder, explore its project structure, implement CRDs and controllers in Go, and test the operator end‑to‑end on a local cluster.
During a gray‑release, a Go‑Rust service repeatedly crashed when a dependent process was hot‑upgraded; the root cause was an unhandled SIGPIPE signal generated by the kernel on a broken TCP connection, which terminated the process without a core dump, and the article explains the kernel mechanics and the solution of ignoring SIGPIPE.
An in‑depth guide to Go’s net/http package explains its role as a standard‑library solution for HTTP client and server tasks, shows how to import it, demonstrates GET, POST and custom requests, builds simple servers with routing, adds middleware, and outlines common use cases such as APIs and web crawlers.
This article explains how Arkit, a Go‑based unified monitoring agent, collects and parses data from multiple sources, leverages Go plugins for flexible, high‑performance processing, provides custom plugin development guidelines, and discusses the performance benefits and limitations of the plugin system.
This article explains the shared behavior of Go's new and make functions, highlights their key differences—including supported types, return values, and initialization details—and provides concrete code examples to show how each should be used in practice.
This article explains how the Linux SIGPIPE signal is generated during broken TCP connections, why the default kernel handling can terminate Go services that call Rust code via cgo, and provides practical code examples to ignore SIGPIPE and avoid silent process exits.
singleflight, a Go concurrency primitive from the x/sync package, merges duplicate in‑flight requests to reduce server load, with detailed usage examples, source code analysis, and discussion of its differences from sync.Once and typical application scenarios such as cache‑penetration, remote calls, and task deduplication.
The article explains hash algorithm fundamentals, compares common hashes, presents extensive Go benchmark results across multiple data sizes, highlights the superior performance of Go's maphash (memhash) implementation, and shows how to access it via linkname and assembly details.
This article explains how to wrap Go goroutine execution in a reusable function that catches panics, logs stack traces, and automatically restarts the goroutine, discussing the underlying fault‑tolerance concepts, related design patterns, suitable use cases, and possible enhancements.
This article explains how the SIGPIPE signal is generated in Linux, why it can cause Go‑Rust services to crash without a core dump, and how to prevent it by configuring the signal handler to ignore SIGPIPE.
This article explains the fundamentals of RDMA, compares libibverbs and rdma_cm with the user‑space rsocket API, and walks through a complete Go implementation using the smallnest/rsocket library, including both server and client code examples and practical deployment tips.
This article walks through step‑by‑step how to create a simple CRUD service using Go's Gin framework with Gorm and MySQL, then shows the equivalent implementation with Java Spring Boot, MyBatis‑Plus and MySQL, comparing the two approaches and providing complete source code.
This course teaches developers with basic Go knowledge how to build GraphQL services, covering fundamentals, schema design, request handling, and practical integration using Go, while comparing graphql-go and gqlgen and demonstrating deployment with Drone CI/CD.
This article introduces a zero‑intrusive compile‑time automatic instrumentation framework for Go, explains its preprocessing and code‑injection mechanisms, and provides modular extension principles with concrete examples such as HTTP header logging, sort algorithm replacement, SQL injection protection, and gRPC traffic control.
Ten practical techniques—early validation, batch queries, asynchronous processing, parallel execution, caching, connection pooling, response compression, message‑queue decoupling, security best practices, and reusable design patterns—collectively reduce latency, boost throughput, and improve scalability of high‑concurrency interfaces.
This article introduces a compile‑time, zero‑intrusion auto‑instrumentation technique for Go applications that enables seamless monitoring, service governance, security checks, and traffic protection through modular JSON‑driven code injection, with practical examples covering HTTP headers, sorting algorithms, SQL injection prevention, and gRPC traffic control.
This article explains the browser same‑origin policy, defines cross‑origin requests, details the CORS mechanism—including simple and non‑simple requests and their required HTTP headers—and provides practical Go examples using Gin middleware and Kubernetes to solve CORS issues.
This article provides a detailed technical analysis of Go's runtime memory management, covering the initialization of the mheap structure, small‑object allocation via mcache, large‑object handling, the three‑color mark‑and‑sweep garbage collector, memory release mechanisms, and the optimization techniques that coordinate mcache and mheap for efficient concurrent execution.
This article provides a step‑by‑step guide to building a custom Kubernetes controller in Go that uses Prometheus metrics to intelligently schedule Flink TaskManager Pods, covering the underlying scheduler concepts, code implementation, Docker image creation, RBAC setup, deployment, testing, and advanced considerations.
The article teaches Go developers how to generate and analyze CPU, heap, allocation, and goroutine profiles with pprof and full‑runtime traces, interpret SVG flame‑graphs, top lists, and source views, and apply concrete optimizations—such as buffering channels and using sync.Pool—to dramatically speed up a Mandelbrot generator.
The article reflects on how perfectionism can hinder progress and contrasts the framework‑heavy, ecosystem‑rich world of PHP with Go's minimalist, low‑level approach, arguing that a sufficiently good solution and simplicity often outweigh the pursuit of an unattainable ideal.
This article explains the bitmap (BitVec) data structure, its memory efficiency for handling billions of integers, real‑world applications such as bloom filters and permission flags, and walks through Go’s internal BitVec implementation with concrete code examples and performance insights.
This article compares UUID v4 and UUID v7 as clustered index keys, explains their structures, lists pros and cons, describes a Docker‑based MySQL experiment using Node.js and Go, presents single‑ and multi‑thread insertion timings, and analyses why the time‑ordered UUID v7 (and serial IDs) outperform random UUID v4.
The article reveals a bug in Go 1.23’s newly added iterator that corrupts results in three‑level nested loops, demonstrates the issue with a reproducible code sample, explains the underlying cause, offers a temporary compile‑flag workaround, and notes the imminent fix.
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.
