This article explains the role of an API gateway in microservice architectures, walks through configuring the micro framework’s gateway with options like address, namespace and handler, shows how to modify server and client code, and demonstrates testing the gateway using curl.
This article introduces four widely used Go web frameworks—Gin, Beego, Echo, and Iris—explaining their key features, routing styles, middleware support, and session handling, and provides complete runnable code examples for each to help developers quickly build robust web services.
Explore the Go Actor model’s core concepts, compare popular Actor libraries, and follow a step‑by‑step implementation that introduces a mailbox, supervisor restart strategy, dynamic ActorPool with auto‑scaler, graceful shutdown via context, and Prometheus metrics, culminating in a complete, production‑ready concurrent framework.
This article walks through a production‑grade Go local cache implementation, covering TTL and LRU fundamentals, sharded concurrency, singleflight protection, asynchronous refresh, capacity control, persistence, performance testing, and real‑world usage scenarios.
This article presents ten practical Go code‑review guidelines—covering error handling, premature abstraction, concurrency, scope, safety, early returns, file organization, declaration order, semantic naming, and purposeful comments—to help teams write more reliable and maintainable backend code.
This article explores how a basic factorial calculation can be turned into a sophisticated concurrent system in Go, covering deadlock pitfalls, fan‑out/fan‑in pipelines, Redux‑style state management, and a controllable streaming factorial engine with pause and resume capabilities.
This article introduces pyproc, a library that lets Go applications invoke Python functions via Unix Domain Sockets with sub‑45 µs latency, explaining the problem of mixing Go and Python ecosystems, the architecture, performance benefits, suitable use cases, and a step‑by‑step quick‑start guide with full code examples.
This article explains how tldb implements language‑agnostic distributed locks, describes the Lock, TryLock, and Unlock APIs, and provides practical Go and Java code samples along with test results to help developers integrate reliable distributed locking into their systems.
The article explains the background and need for helper functions that return pointers to values in Go, introduces the upcoming Go 1.26 extension that lets the built‑in new function accept arbitrary expressions, shows practical code examples, demonstrates memory‑leak avoidance and performance gains, and concludes with a brief outlook on the feature’s release.
Learn how Go’s powerful conditional compilation system—using file suffixes and build tags—enables precise control over platform-specific code, debug/release modes, and feature toggles, with detailed explanations, common pitfalls, a full-featured logger example, Makefile automation, and CI/CD integration.
This article explains how using floating‑point numbers for money leads to precision loss, demonstrates common rounding pitfalls, and provides Go‑specific solutions—including integer cents and the high‑precision decimal library—to ensure accurate financial calculations.
Learn how to construct a low‑latency, scalable WebSocket server in Go using fasthttp, custom read/write pumps, priority message queues, a worker‑pool, and Prometheus metrics, with full source code, detailed module explanations, and deployment instructions for real‑time high‑concurrency applications.
The author recounts how selecting Go for a fintech startup initially seemed ideal due to its concurrency, performance, and simplicity, but a series of technical and organizational challenges—including missing generics, verbose error handling, ecosystem gaps, hiring difficulties, and productivity loss—ultimately forced a switch to Kotlin and Spring Boot.
This article explains how to build a high‑throughput, low‑latency, and scalable queue system in Go by leveraging Kafka, RabbitMQ, and Redis, covering core concepts, practical code examples, performance optimizations, and guidance on choosing the right solution for different workloads.
This guide walks you through setting up an Ubuntu environment, training a LightGBM stock‑movement model in Python, exporting it to ONNX, and deploying fast, cross‑platform inference in Go using ONNX Runtime, complete with code snippets and project structure.
This article demonstrates how Go's goroutines and channels can transform a sequential task that takes seconds per operation into a highly concurrent solution that completes millions of operations in just a few seconds, complete with code examples and performance benchmarks.
This guide shows how to quickly set up AKTools via Docker, retrieve high‑quality historical and real‑time stock data, upgrade AKShare, and create a flexible Gin‑based API to serve the data for quantitative analysis or stock‑screening applications.
This article details how to design and implement a scalable, low‑cost content moderation pipeline that combines a local Trie + Aho‑Corasick engine, Redis‑based hot‑updates, MySQL persistence, and third‑party machine‑review fallback to achieve millisecond‑level response, high accuracy, and controllable costs.
Learn how Go's sync package provides essential concurrency primitives—Mutex, RWMutex, WaitGroup, Once, Cond, and Pool—through clear examples and best‑practice patterns that prevent data races, deadlocks, and performance pitfalls, enabling safe, elegant, and efficient goroutine coordination.
This guide introduces Go’s built‑in command‑line tools—go build, go install, go get, go doc, godoc, go test, go list, and go fix—explaining their purposes, key flags, and typical usage scenarios to help developers efficiently compile, install, fetch, document, test, list, and modernize Go packages.
A senior backend engineer recounts how early database abstraction layers caused massive performance regressions across three real‑world systems, illustrates the pitfalls with Go and Node.js code examples, and shares concrete guidelines for letting databases do what they do best.
Over the past two years, Go’s sync and sync/atomic packages have introduced new APIs like WaitGroup.Go, enhanced Map methods, modernized atomic types, restructured internal implementations, and added developer‑friendly safeguards such as noCopy, all aimed at improving usability, safety, and performance for concurrent Go programs.
The article explains how the emerging Model Context Protocol (MCP) for AI tools lacks visibility, outlines security and monitoring challenges, compares alternative tracing methods, and presents MCPSpy—a Linux‑only eBPF‑based, non‑intrusive solution that captures MCP stdio traffic, parses JSON‑RPC messages, and outputs human‑readable or JSON logs.
This article introduces the Model Context Protocol (MCP) Go SDK v1.0.0, explains its stable API guarantees, provides quick‑start examples for building MCP servers and clients in Go, and outlines the SDK's modular design and error‑handling strategy for AI‑enabled backend development.
The article explains the Go 1.26 proposal introducing a standard Hasher[T] interface for custom hash and equality logic, outlines its definition, showcases practical examples, compares existing library approaches, and discusses the long‑term benefits and challenges for the Go ecosystem.
This article details version 3.0 of a Go‑based stock analysis system that adds sector classification, persistent watchlists, scheduled strategy evaluation, real‑time WebSocket market feeds, K‑line charting with technical indicators, a Vue front‑end, deployment steps, future roadmap, and a public GitHub repository.
This article presents version 2.0 of a Go-based stock analysis system that upgrades data storage to SQLite, adds MA/MACD indicators, modular strategy engines, daily scheduling, and a Vue3 front‑end, providing full code snippets, configuration examples, and deployment instructions.
Drawing from real incidents like SQLite crashes, missing logs, unthrottled APIs, slow container startups, queue bottlenecks, network partitions, unreliable clocks, and weak alerts, this article shares ten concrete infrastructure lessons with code examples, performance data, and practical recommendations to avoid costly pitfalls.
This tutorial walks through why Redis is essential for Go services, how to choose and install the go‑redis client, and provides step‑by‑step code for connections, common commands, cache‑aside, distributed locks, leaderboards, and lightweight queues, followed by performance tuning and best‑practice recommendations.
The article reviews Go 1.25’s major updates—including the removal of core types for generics, Cgroup‑aware GOMAXPROCS, the experimental greentea GC, a revamped JSON package, and toolchain enhancements—while offering migration tips and highlighting future language trends.
This article introduces the open‑source Go AI Agent framework Blades, showing how to quickly set up a chat with a large model, enable streaming responses, and implement multi‑turn conversations using prompts, memory, and custom middleware, with complete code examples.
This article explains why high‑concurrency Go programs suffer from CPU spikes, memory bloat, and GC jitter, then introduces the architecture of a goroutine pool, provides a step‑by‑step implementation, compares a simple channel‑based pool with the high‑performance Ants library, and shares benchmark results and optimization tips.
This article explains Go's defer semantics, its interaction with return statements, parameter evaluation rules, performance impact in hot paths, and proper use with panic‑recover, providing practical code examples and best‑practice recommendations.
This article compares the three leading Go web frameworks—Fiber, Gin, and GoFrame—by examining their routing mechanisms, middleware ecosystems, configuration options, microservice and cloud‑native support, real‑world code examples, and benchmark results to help developers choose the most suitable solution for their projects.
This article explains how the Model Context Protocol (MCP) bridges large language models and external services by converting OpenAPI specifications into callable tools, covering generation with openapi‑generator, mapping rules, three runtime modes (stdio, streamable, SSE), and implementation details in Java, Python, and Go.
This guide walks through a complete set of Bash scripts for building, starting, stopping, rolling back, and monitoring a Go backend service, explains signal handling in Go, and provides a curated list of useful open‑source Go projects and libraries.
This guide walks Go developers through the OSI and TCP/IP layering models, explains key transport and application protocols such as TCP, UDP, HTTP/1.1, HTTP/2, HTTP/3, RPC, WebSocket, and TLS, and provides practical Go code snippets and deployment tips for building performant, secure, and real‑time services.
This guide walks you through installing Ollama, pulling the open‑source DeepSeek‑R1:1.5B model, wrapping it with a Go‑based Model Context Protocol (MCP) server, creating a client example, and enhancing the experience with Open‑WebUI while offering performance‑tuning tips.
Learn how to combine PHP's ease of use with Go's high-performance concurrency by integrating gRPC services into an API Platform project, covering environment setup, protobuf definitions, Go server implementation, PHP client integration, and troubleshooting tips to dramatically reduce API latency.
This article compares eight popular Go web frameworks—fasthttp, Fiber, Gin, Echo, Beego, Revel, Hertz, and Kratos—by evaluating their performance, developer friendliness, and ideal application scenarios, and provides concise code examples to help you select the best fit for high‑performance backend development.
Discover how Caddy, a Go‑based open‑source web server, simplifies HTTPS with automatic certificate management, offers a minimalist installation, supports modern protocols, and provides powerful features like reverse proxy, load balancing, and built‑in security, making it a compelling alternative to Nginx and Apache.
Learn how to extend GORM with custom plugins by implementing the Plugin interface, registering lifecycle callbacks, and creating an asynchronous audit‑log module that records Create, Update, Delete, and Query actions to a dedicated table, with configurable batch size, flush interval, and buffer settings.
This guide introduces the open‑source Go web framework Beego, covering its core concepts, one‑click installation, MVC layer responsibilities, modular design, advanced programming tips, deployment workflow, and example applications to help developers build high‑performance web services quickly.
Learn how to dramatically improve Go program throughput and stability by tuning GOMAXPROCS, using buffered channels, optimizing lock contention, implementing worker pools, leveraging efficient data structures, and applying compiler tools such as escape analysis, PGO, and build flags for smaller, faster binaries.
This article explains why horizontal sharding becomes essential for billion‑row tables, introduces the non‑intrusive GORM Sharding plugin, walks through installation, configuration, and code examples, and evaluates its advantages, limitations, common issues, and suitable use cases for Go back‑end services.
Learn how to use GORM's DBResolver plugin in Go to achieve efficient read/write separation and load balancing across master and replica databases, with detailed code examples, configuration tips, production best practices, and strategies for connection pooling, transaction consistency, and handling replication lag.
Go 1.25 introduces Trace Flight Recorder, a lightweight circular‑buffer tracing tool that lets developers capture recent execution data in production with minimal overhead, and the article walks through its concepts, configuration, code demos, analysis workflow, and practical use cases.
This article explains the fundamentals of Prometheus Histogram metrics, covering data format, metric types, how histograms work as cumulative time series, provides Go code examples for collection, and demonstrates practical queries for rate, bucket analysis, and quantile calculations to monitor service performance.
This article explores Go's map type in depth, covering its underlying hash table mechanics, key requirements, concurrency considerations, and a comprehensive set of practical techniques—including existence checks, JSON conversion, sorting, slicing, multi-dimensional maps, and real-world examples for analytics and log processing.
This article examines why GORM is popular in Go, outlines common performance pitfalls such as default transactions and N+1 queries, and provides practical optimization techniques—including disabling default transactions, selective field queries, batch processing, prepared statements, and indexing—illustrated with real‑world case studies for high‑concurrency and large‑scale data scenarios.
This article provides a comprehensive guide to Go cryptography, covering fundamental concepts, common mistakes like using math/rand for keys or RSA v1.5 padding, correct implementations with crypto/rand, AES‑GCM, RSA‑OAEP/PSS, password‑derived keys, performance benchmarks, and practical testing strategies.
This guide explains how to implement symmetric (AES‑CBC, AES‑GCM) and asymmetric (RSA) encryption as well as hashing in Go, providing clear explanations and complete, runnable code samples for each technique.
This article thoroughly explains Go's reflection mechanism, showcases typical scenarios such as function calls, ORM mapping, and dependency injection, highlights common pitfalls and performance concerns, and provides optimization tips along with a concrete lightweight DI container example.
The article analyzes the long‑standing issues of Go's original encoding/json package, explains the design and API of the experimental encoding/json/v2 and jsontext packages, and shows how the new implementation improves correctness, flexibility, and performance while preserving compatibility.
The Go core team proposes an experimental HTTP/3 implementation in the x/net/http3 package, outlining its background, development stages, sample code, and the potential benefits for compatibility, stability, and performance in backend networking.
This guide explains why Go pointers matter, covers their definition, memory model, and safe usage, provides practical best‑practice checklists, performance comparisons, and code examples—including handling large structs, optional fields, and complex data structures—while highlighting scenarios where pointers should be avoided.
Client‑Go is the official Go client library for Kubernetes, offering low‑level HTTP handling, local caching, and event‑driven List‑Watch mechanisms; the article explains its architecture, client types, cache components, code examples, and best practices for building production‑grade controllers and operators.
This article explains how Go's sync.Pool works, shows practical usage examples, walks through its source code, and details the underlying implementation, including Put/Get methods, pinning, and garbage‑collection interaction, helping developers efficiently reuse objects in concurrent programs.
Discover how Go transforms massive concurrency challenges into elegant communication using goroutines, channels, select, and the GMP scheduler, and learn practical patterns such as producer-consumer, pub/sub, worker pools, pipelines, and a prime sieve, complete with runnable code snippets and engineering tips for robust backend systems.
This article explains the core principles of timers, compares heap‑based and timing‑wheel algorithms, analyzes Go's built‑in timer implementation versus C#'s approach, and provides practical optimization techniques for high‑concurrency, high‑precision scenarios.
This article explains how the Jenkins Role Strategy plugin’s UI can become unresponsive with many users, introduces a Go SDK that wraps its REST API, demonstrates permission template, role, and user/group management code, and shows how to build a simple Gin‑based web UI for role assignment.
Go’s built‑in concurrency primitives make parallel programming easy, but testing such code is tricky; this article explains the experimental testing/synctest package introduced in Go 1.24/1.25, shows how to rewrite flaky, slow tests into fast, reliable ones, and demonstrates its use with real‑world examples.
This article explains how to re‑implement ByteDance's DeerFlow deep‑research framework in Go (Deer‑Go), covering the multi‑agent architecture, control‑hand‑off, interrupt & checkpoint mechanisms, integration with the Hertz SSE server, and step‑by‑step deployment instructions.
This guide outlines a structured roadmap for learning Go, covering entry‑level syntax, essential concurrency primitives, project‑based practice, engineering best‑practices, and deep runtime and ecosystem exploration, with recommended resources and practical project ideas for each stage.
This article provides a comprehensive overview of Go's powerful GORM ORM library, covering its core concepts, architecture, internal logic, common pitfalls, practical tips, and advanced features such as soft deletes, transaction handling, batch operations, and integration with trpc-go, helping developers master GORM's inner workings.
This article explains Go's memory management mechanisms—including GC fundamentals, stop‑the‑world marking, tri‑color marking with write barriers, hybrid write barriers, and practical optimization techniques such as reducing heap allocations, using caches, concurrency patterns, and profiling tools—to help developers identify and eliminate performance bottlenecks.
This guide explains why combining Domain‑Driven Design with Go, outlines core DDD concepts such as hexagonal architecture, entities, value objects, aggregates, services, repositories, and application services, and provides a complete project structure and runnable code examples.
This guide explains why and how to use Go's pprof and trace tools to diagnose memory leaks, goroutine stalls, and CPU bottlenecks, providing step‑by‑step commands, example code, a cheat‑sheet of core commands, and a practical workflow for microservice tracing.
This article outlines Xiaohongshu's 2024 autumn recruitment details, salary ranges for different offer tiers, work‑schedule changes, and provides in‑depth answers to common backend interview questions covering Redis performance, HTTP vs RPC, virtual memory layout, Go's GMP model, coroutine advantages, C++ class size, diamond inheritance, static variables, core‑dump analysis, and a median‑finding algorithm challenge.
This article walks you through the fundamentals of instant‑messaging systems, explains the WebSocket protocol in depth, and provides a complete Go implementation for a scalable, high‑availability IM service with registration, authentication, single‑ and group‑chat, emoji and image support, plus optimization and architecture recommendations.
This article explains why scalable systems are essential, outlines core design principles such as the open‑closed and modular approaches, demonstrates Go implementations of strategy, middleware, plugin, and configuration‑driven architectures, and provides validation metrics and an evolution roadmap for building extensible backend services.
FrankenPHP lets developers write PHP extensions in Go, offering a generator and tool library that replace complex C code, simplify deployment, and leverage Go's concurrency, while being officially supported by the PHP Foundation.
This article explores the origin of the Go programming language’s name, detailing its creation by Rob Pike, Robert Griesemer, and Ken Thompson, the emergence of the “golang” moniker, official naming conventions, and why the correct term remains simply Go.
Go 1.25, released in August 2025, brings a suite of toolchain, runtime, and standard‑library upgrades—including default memory‑leak detection, a new go.mod ignore directive, container‑aware GOMAXPROCS, experimental greentea GC, JSON V2, and several new diagnostics—without changing the language syntax.
Go 1.25 introduces a container‑aware default for GOMAXPROCS that automatically aligns the runtime’s parallelism with CPU limits in orchestrated environments, reducing throttling latency, improving efficiency, and making Go applications production‑ready out of the box.
This guide introduces the free, open‑source Go web framework Beego, covering quick installation, its MVC architecture, modular design, advanced programming tips, deployment steps, and example applications, providing a concise roadmap for building high‑performance web or RESTful services.
This guide explains how to use Jenkins together with Buildah to automatically build and push multi‑architecture (amd64 and arm64) container images for Go applications, covering prerequisites, a complete Jenkinsfile, tips for faster builds, and a test pipeline demonstration.
This article details how a Laravel‑based PHP system was enhanced by introducing Go components, covering architecture design, cross‑language communication, performance optimizations, lessons learned, and measurable improvements in response time and server load.
This article walks through extending the K8s Chat command‑line tool by adding an ‘analyze event’ command that gathers warning‑level events and pod logs, stores them in a map, and sends the information to a large‑language model via OpenAI’s API to receive actionable troubleshooting recommendations, while also suggesting further enhancements such as self‑healing and visualization.
Microsoft’s TypeScript team migrated the compiler from JavaScript to Go, achieving up to ten‑fold performance gains, halving memory usage, and enabling shared‑memory concurrency, while preserving compatibility and exploring future AI‑driven code analysis and language‑service APIs.
This article explains how the Go dyno package lets you effortlessly read, modify, and serialize deeply‑nested JSON/YAML structures by providing Get, Set, Delete, Append and conversion utilities that work with map[string]interface{}, map[interface{}]interface{} and []interface{} without using reflection.
This guide explains why Go's Context timeout is essential for managing goroutine lifecycles, details the WithDeadline and WithTimeout APIs, reveals the internal timer and cancellation mechanisms, and provides practical HTTP request patterns and best‑practice recommendations for building stable, high‑performance backend services.
This tutorial shows how to combine Kubernetes client‑go, the Cobra CLI framework, and OpenAI function calling in Go to create an interactive command‑line assistant that can generate YAML, deploy resources, query objects, and delete items in a Kubernetes cluster.
This article explains why converting a YAML document containing both numeric and string keys (e.g., 1 and "1") to JSON fails in Go using yaml.v3, demonstrates the resulting errors, and shows how to resolve the issue with dyno.ConvertMapI2MapS or alternative libraries, while also comparing behavior in Python and JavaScript.
By imposing a strict 1 GB memory cap on identical workloads across Go, Rust, Node.js, Python (Flask/Gunicorn), and Java Spring Boot, this study reveals how each language’s runtime handles memory pressure, detailing survival times, performance quirks, and ultimate failure modes.
In the AI‑driven era, Go programmers face a dilemma about mastering Python, and this article explains when Python is essential, how to prevent naïve code translation, and provides concrete examples of writing truly Pythonic code versus direct Go‑style conversions.
This article explains WebSocket fundamentals, compares pull and push models, details the WebSocket handshake flow, presents a complete Go server and client implementation, analyzes performance bottlenecks of a million‑user bullet‑screen system, and proposes concrete optimizations such as packet merging, lock granularity, JSON encoding reduction, and HTTP/2‑based clustering.
This comprehensive guide walks readers through Go's origins, core syntax, data types, operators, control structures, functions, and project organization, providing clear explanations and code examples that make the language accessible for both beginners and experienced developers.
This article explores using Go as a scripting language, covering its strengths such as fast compilation and strong typing, the use of the go run command, helpful third‑party packages, Linux shebang workarounds, alternative interpreters like Gomacro, and the remaining limitations compared to traditional scripting languages.
This article explains the role of the doc.go file in Go projects for centralized package documentation, demonstrates its structure with real examples, shows how to generate docs using godoc and go doc, and explores advanced uses like canonical import paths and code generation annotations.
This article walks through designing and implementing a zero‑intrusion, real‑time network anomaly detection system for Kubernetes using eBPF, covering architecture, kernel‑space eBPF programs, Go user‑space collectors, deployment via DaemonSet, performance optimizations, alerting integration with Prometheus/Grafana, and real‑world case studies.
This article explains the historical limitations of Go modules with repository subdirectories, describes why the cmd/go tool cannot locate sub‑module sources, and details the Go 1.25 proposal that extends go‑import meta tags to support subdirectory modules, improving monorepo management.
This tutorial walks you through setting up Consul with Docker, designing a three‑layer configuration hierarchy, implementing a Go loader that merges Consul and file sources, and enabling hot‑reload for robust, environment‑aware microservice configuration.
This guide explains Go's net/http ServeMux as a request router, demonstrates built‑in handlers like RedirectHandler, shows how to create custom http.Handler implementations, use functions as handlers, and pass variables via closures, complete with runnable code examples.
This comprehensive guide explores Go 1.23's iterator system, detailing the underlying principles of push and pull iterators, code transformations performed by the compiler, coroutine implementation, and practical examples that compare Go's approach with Python and JavaScript, helping developers master iterator usage and design.
This article compares Go, Python, and Rust across execution speed, memory usage, developer productivity, ecosystem, and salary trends, offering guidance on when to choose each language for high‑throughput services, I/O‑bound APIs, or rapid prototyping in 2025.
Choosing a programming language now requires weighing execution speed, memory usage, developer productivity, ecosystem tools, and salary trends; this article compares Go, Python, and Rust across benchmarks, cloud‑native suitability, AI/ML dominance, and market demand to guide teams on when to adopt each technology.
This article explains the benefits of functional programming in Go, outlines four core concepts, presents practical rules, and demonstrates five concrete examples—including pure functions, immutability, higher‑order functions, currying, and recursion—to help developers write clearer, more testable code.
This article explores the newly introduced iterator feature in Go 1.23, explaining what iterators are, why they were added, how to implement them manually, how to use the new iter package, and how the slices and maps packages provide iterator‑friendly utilities for Go developers.
A collection of engineers' perspectives discusses Go's strengths, challenges, and future prospects over the next five to ten years, highlighting its role in cloud‑native infrastructure, AI limitations, industry adoption, and the importance of continuous learning for developers.
