This article reports that C++ has overtaken C to rank second in the latest TIOBE index, outlines the historical evolution of C++ across three phases, highlights the recent record climbs of Go and Rust, and notes the broader usage of these languages despite the presence of promotional material.
This guide explains how Docker containers can be gracefully stopped by handling Linux signals such as SIGTERM, details common exit codes, demonstrates a Go program that captures these signals, and provides best‑practice Dockerfile configurations to ensure proper shutdown behavior.
This article explains Go's socket programming workflow, detailing the traditional steps of creating, binding, listening, and communicating over sockets, then shows how net.Dial simplifies connections for TCP, UDP, and ICMP, and demonstrates practical HTTP client usage with code examples.
This article walks through creating a Go‑based desktop pet that follows the mouse, reacts to clicks with sounds and visual changes, and runs transparently using the Ebiten game engine, complete with code snippets, configuration options, and launch instructions.
This article explains the cache‑stampede problem when hot Redis keys expire under massive traffic, illustrates why simple caching fails, and presents a mutex‑lock solution with Go code to safely rebuild caches while protecting the database.
In three months the author recruited a 20‑person Go team in Wuhan, managed simultaneous business handover and ongoing delivery, coordinated demand across three product groups, and reflected on the challenges, collaboration tactics, and personal growth experienced throughout the process.
This tutorial walks through installing Go, using the Go‑Gin framework, creating a simple cron‑enabled web service, building Docker images with and without multi‑stage builds, pushing them to a registry, deploying on a server, and comparing the final image size with an equivalent Koa implementation.
This article describes a real‑world incident where rapid pod scaling caused order‑submission failures in a serverless e‑commerce platform, analyzes the root causes, and presents a Go‑based graceful‑shutdown solution—including ASyncClose, SyncClose, and ForceSyncClose modes—implemented in the open‑source GS library to help developers reliably terminate services.
This article walks through Go’s net/http package, explaining how http.HandleFunc registers handlers via DefaultServeMux, how ServeMux stores routes, performs exact and longest‑prefix matching, and how to extend the server with custom ServeMux and middleware for panic recovery and request timing.
This article explains what Protocol Buffers are, how they work through .proto definitions and the protoc compiler, provides a simple example, shows how protobuf powers gRPC services with Go code, and compares its efficiency and type safety to JSON.
The author benchmarked Go's standard HTTP library against PHP frameworks Workerman, Webman, and Swoole (including coroutine mode) on a 4‑core Ubuntu 20.04 Aliyun instance using ApacheBench with and without keep‑alive, revealing that Workerman and Webman often outperform Go in raw request‑per‑second throughput.
SlashData’s 26th Developer Nation survey, covering over 10,000 developers from 135 countries, shows JavaScript remains the most popular language, Python overtakes Java for second place, and emerging languages like Rust and Go experience rapid growth, while new developers face distinct adoption challenges.
This article demonstrates how to apply Google’s Wire tool in a production‑grade Go web service, covering project layout, a four‑layer architecture, code generation for constructors, comparisons with dig and inject, and practical CLI usage to streamline dependency injection and improve development efficiency.
This guide walks through the PolarisMesh polaris-server startup process, detailing configuration loading, bootstrap sequencing, and the initialization of core modules such as apiserver, cache, auth, namespace, service discovery, and config center, with code snippets and structural diagrams.
This guide introduces Uber’s open‑source Zap library for Go, explains its performance‑focused features, shows how to install and configure it, and provides step‑by‑step code examples for basic logging, sugared logging, level control, file output, and log rotation.
This guide explains Go's various operators—including arithmetic, assignment, relational, logical, bitwise, and pointer operators—provides clear code samples for each type, demonstrates their output, and clarifies how they behave in different scenarios.
This tutorial explains how Docker can streamline building, testing, and deploying Go web applications, introduces the use of Semaphore for continuous deployment, and walks through creating development and production Dockerfiles, configuring CI/CD pipelines, and managing updates on the server.
This guide explains why Go commands like go get fail to download golang.org/x packages, and provides step‑by‑step solutions using HTTP/HTTPS proxy settings, manual repository cloning, go.mod replace directives, and the GOPROXY environment variable to reliably fetch dependencies.
This article explains the concept, use cases, and common implementations of delay queues—including JDK's DelayQueue, RabbitMQ plugins, and Redis ZSet—followed by a detailed guide to installing, configuring, and using the open‑source lmstfy project, and concludes with promotional information for ChatGPT‑related services.
This article introduces the Go library grequests—a clone of Python's requests—demonstrates its installation, compares its API with net/http, and provides concise examples for GET, POST, query strings, basic authentication, and file upload/download, highlighting its simplicity and advantages for HTTP client development.
This article explains containerd’s role in Docker, outlines its core responsibilities and design goals, shows how to install and configure it on Ubuntu, and provides a complete Go example that pulls a Redis image, creates a container, runs and cleans up the task.
Go slices are dynamic, flexible data structures built on arrays, offering automatic growth, efficient memory use, and powerful operations such as creation via make or literals, slicing, appending, copying, iteration, and passing to functions, with detailed examples and visualizations illustrating their internal mechanics.
This article explains how Go’s standard database/sql package uses a driver registration mechanism to integrate third‑party MySQL drivers, detailing the global driver map, registration function, init process, and a complete example showing how to define, register, and use a custom MySQL driver.
This article introduces Google Wire, a static‑analysis‑based dependency injection tool for Go, covering its key features, installation steps, core usage patterns—including defining dependencies, creating providers, generating code, and best practices such as modular management, interface abstraction, and testing with mock implementations.
This guide walks through creating a name‑based injection system in Go by defining a processor interface, implementing concrete processors, building a registration map with init functions, and demonstrating usage in a main program, while also covering best practices such as global variable handling, initialization order, and error checking.
This article explains the Dependency Injection (DI) pattern, its benefits and drawbacks, the two main injection types, and provides concrete Go examples of constructor and property injection using interfaces and structs.
Learn how to create a Go-based command-line tool that accepts user-supplied parameters to connect to an Oracle database using the loginWithServiceName function, execute arbitrary SQL queries, and display results, complete with full source code, flag parsing, and error handling.
This article explains the characteristics and ideal use cases of UDP, then walks through step‑by‑step Go code for creating UDP connections, sending and receiving datagrams, and a complete client‑server example, helping developers leverage UDP’s low latency and lightweight nature for real‑time communication, streaming, and IoT scenarios.
This article explains how to design a unified business error‑code system for RESTful APIs, demonstrates the structure and format of such codes, provides a Go implementation with structs, interfaces and formatting methods, and shows practical usage in a Gin web server including logging and notification strategies.
This article explains how to use a Trie data structure in Go to efficiently store API paths with associated permissions, insert paths, perform fast permission validation, and demonstrates the approach with a complete, runnable code example and sample test cases.
Since its 2009 debut, Go’s simple syntax, strong concurrency, and performance have driven its adoption, and this article examines how those strengths position Go for future growth in cloud computing, microservices, blockchain, data science, IoT, and web/API development.
This article explains the concept, working principle, common use cases, and various implementations of delay queues—including JDK's DelayQueue, RabbitMQ plugins, Redis sorted sets, and the Go‑based lmstfy project—along with installation, configuration, and sample client code.
Java developers can quickly establish a Go development environment by installing Homebrew, Go, and the Delve debugger, configuring essential environment variables, choosing an IDE such as GoLand or VS Code, organizing projects with standard cmd/internal layouts, managing dependencies via go.mod, automating builds with a Makefile, and debugging or packaging the resulting binaries.
This article introduces the Trie (prefix tree) data structure, explains its basic architecture, demonstrates insertion, search, and deletion operations with complete Go implementations, and provides practical unit tests and real‑world applications such as autocomplete, spell checking, and IP routing.
This article explains how to apply Dependency Injection in the Go Gin framework to separate routing logic from business services, reducing code coupling, improving testability, and enhancing reusability through concrete interface definitions, a simple DI container, and practical code examples.
This article explains Unix domain sockets as a high‑performance inter‑process communication mechanism, describes their types and workflow, outlines advantages and typical use cases, and provides a complete Go example of a server and client communicating via a Unix socket.
This article explains the fundamentals of coroutines, comparing blocking and non‑blocking concepts, process/thread models, and how PHP and Go implement coroutine solutions using event loops, schedulers, and system calls.
This article compares the Go web frameworks Echo and Gin, detailing their main features, performance, API design, middleware and routing capabilities, community support, and provides side‑by‑side code examples to help developers choose the most suitable framework for their projects.
This article outlines six practical techniques—input validation, leveraging Go's secure standard library, avoiding concurrency pitfalls, using defer for resource cleanup, rigorous error checking, and employing context for timeouts—to help developers write more secure and reliable Go applications.
This article explains three core abstraction techniques—simplifying, generalising, and layered abstraction—illustrates each with clear Go code examples, discusses their benefits and trade‑offs, and shows how to apply them effectively to improve maintainability and reuse in software projects.
This article explains the concept of context switching, compares process, thread, and coroutine switches, and details how Go’s M:N scheduler implements low‑cost coroutine switches with examples, costs, and optimization tips for writing efficient concurrent programs.
This article explains how to reduce server load and improve performance of Go applications on Kubernetes by using lightweight base images, fine‑tuning resource limits, adjusting garbage‑collection settings, employing connection pools, configuring health probes, and leveraging autoscaling, load balancing, and caching techniques.
This article explains how Go's garbage collector manages adjusted, old, and new stacks, detailing the stack adjustment process, expansion and contraction steps, and practical techniques—including debugging tools, stack printing, memory profiling, and stress testing—to verify correct behavior.
The article explains why a backend developer moved from PHP to Go, highlights Go’s popularity and simplicity, and demonstrates how Go’s concurrency primitives like sync.WaitGroup and errgroup can transform serial live‑stream data fetching into parallel execution, drastically reducing request latency.
This article introduces the xgo tool for Go, explains its cross‑platform monkey‑patching capabilities, demonstrates how to write unit tests with mock.Patch, shows installation, usage of Trap, Trace, and incremental coverage features, and evaluates its advantages and drawbacks for backend development.
This comprehensive guide teaches Go developers how to generate CPU, memory, and goroutine profiles with pprof, interpret SVG, top, source, and peek visualizations, understand the runtime’s sampling and allocation internals, use the trace tool to analyze events, and apply these techniques to real‑world optimizations such as speeding up a Mandelbrot image generator.
This article explains Go's runtime Frame struct, shows how to retrieve call‑stack details with runtime.Callers and runtime.CallersFrames, and demonstrates practical uses in debugging, logging, performance profiling, and error handling with clear code examples.
This article provides an in‑depth tutorial on the sqlx package for Go, covering installation, type design, database connection methods, query execution, named parameters, transaction handling, prepared statements, unsafe scanning, field‑mapping customization, and practical code examples to simplify working with relational databases.
This article provides a comprehensive overview of Go's debug library, detailing each subpackage—buildinfo, dwarf, elf, gosym, macho, pe, and plan9obj—and explains how they can be leveraged in system operations for version control, fault diagnosis, performance tuning, and cross‑platform debugging.
This article explains Go’s built‑in database/sql package, detailing the Open function’s signature and workflow, the DB struct’s key fields, and how classic design patterns such as Singleton, Factory, Proxy, and Strategy are applied to achieve safe, flexible, and high‑performance database connection pooling.
This guide walks through deploying Xenon, an open‑source Raft‑based MySQL high‑availability solution, covering environment setup, installation of Go and Percona XtraBackup, configuring Xenon’s JSON, starting the cluster, monitoring status, and troubleshooting backup failures caused by misconfigured host settings.
This guide walks through Go's pprof tool, detailing each command‑line option, its purpose, and example usage so developers can comprehensively profile, visualise, and optimise Go applications for better performance and stability.
This guide explains how to use Go's built‑in pprof tool and the go tool pprof command to profile CPU and memory usage, generate analysis files, interpret interactive console output, create flame graphs, and apply practical optimizations for faster, more efficient Go applications.
The article analyzes recent rumors of Google laying off many Go core developers, outlines what resources and support could be lost, explores possible scenarios for the language’s future, and compares the situation to Rust’s evolution, highlighting risks for the Go ecosystem.
This article explains how Go's sync.Pool enables efficient object reuse to cut memory allocation and garbage‑collection overhead, detailing its features, basic usage, underlying mechanics, ideal scenarios, performance‑boosting examples, and important considerations for safe and effective implementation.
This article explains the CPU cache locality principle, shows how to restructure Go data access patterns—including data structures, field ordering, memory allocation, and false sharing avoidance—and demonstrates measurable performance gains with a matrix‑multiplication benchmark.
This article demonstrates how to apply Monkey Patching in Go using the gomonkey library to unit‑test a simple HTTP service, covering code examples, dependency analysis, patch creation, test execution parameters, and practical considerations such as inlining and concurrency limitations.
This article provides a comprehensive guide to Go performance optimization, covering fundamental strategies such as proper Goroutine usage and memory leak avoidance, advanced techniques like concurrency pattern tuning and efficient use of interfaces, as well as essential profiling tools and practical case studies.
This article explains how to resolve external file dependencies in Go unit tests by creating temporary files with os.CreateTemp, initializing global variables, and leveraging the embed package to embed changelog files as []byte or a file system, providing complete code examples and test results.
Go treats functions as first‑class citizens, enabling higher‑order functions that accept other functions as arguments or return them, and this article explains their definition, demonstrates practical examples—including callbacks, closures, and functional‑style map/filter operations—while highlighting common use cases such as decorators and event handling.
This guide explains how to use Go's strings.NewReplacer function, covering its signature, parameter rules, practical examples, key features, common use cases, and error handling to help developers perform efficient and reliable bulk string replacements.
This article introduces the Go json-patch library, explains its RFC 6902‑based operations, provides step‑by‑step code examples, details each operation, and offers advanced usage tips and best practices for applying JSON patches in backend applications.
This article walks through the concepts of forward and reverse proxies, explains HTTP and HTTPS proxy protocols, and provides a complete, step‑by‑step Golang implementation with code samples and diagrams for building a functional HTTP proxy server.
This article explains how to efficiently detect changes in complex Kubernetes Operator objects by comparing current and desired states using methods such as reflect.DeepEqual, hash‑based comparison, JSON Patch generation, deep copying, and custom comparison functions, and offers best‑practice guidance for reliable controller implementations.
This article explains how to implement a generic deep‑copy function in Go using reflection, detailing the Interface definition, the Copy and Iface wrappers, the recursive copyRecursive logic, and key techniques such as interface design and recursive traversal to produce fully independent copies of complex data structures.
This article explains how to write Go unit tests for HTTP handlers that depend on MySQL by using fake implementations and the gomock library to replace the store layer, demonstrating both fake object and mock approaches, code examples, and best practices for isolating external dependencies.
This article explains the concepts of statistical and cryptographic randomness, compares their characteristics, outlines common tests, and reviews various random number generator types with code examples for PRNG and CSPRNG implementations.
This article explains Go's pointers, slices, and maps, detailing their internal relationships, demonstrating how slices share underlying arrays via pointers, and showing how maps store pointers for efficient data access, accompanied by practical code examples and usage tips for safe, high‑performance programming.
This article explains Go's pointer model, why the language forbids generating pointers from non‑pointer values, how garbage collection and memory compaction cause object addresses to change at runtime, and provides best practices and code examples for safely using pointers in Go programs.
This article explains how to write reliable unit tests for Go HTTP applications by isolating external dependencies, covering server‑side handlers, client‑side monitoring, and using tools such as net/http/httptest, testify, and gock to create test doubles and mock HTTP services.
This article examines the trade‑offs of converting a Go method from a pointer receiver to a value receiver, illustrating the change with concrete code examples, outlining benefits such as simpler logic, zero‑value safety, clearer semantics, and offering guidance on when this refactor is appropriate.
This article explains how integrating Go with assembly language can overcome Go's performance and low‑level control limits for system and driver development, covering basic concepts, integration methods, multi‑CPU architecture support, practical code examples, and the resulting performance and portability benefits.
Go’s goroutine model lets developers replace complex thread‑pool management with lightweight, runtime‑scheduled functions, enabling simple concurrent execution; this article explains how to launch single or multiple goroutines, synchronize them with WaitGroup, and understand the underlying G‑P‑M scheduler.
This guide explains the essential Go commands—including build, install, get, doc, godoc, test, list, and fix—detailing their purposes, typical usage scenarios, and how they help developers compile, manage dependencies, document, and test Go code efficiently.
This guide outlines a comprehensive Go project layout—including cmd, pkg, internal, test, configs, and docs directories—alongside modular design principles, middleware usage, dependency injection, error handling, logging, database access layers, testing strategies, performance tuning, and documentation practices to improve code readability, maintainability, and scalability.
Yearning is an open-source MySQL SQL audit platform built with Go and Vue.js that automates statement review, generates rollback scripts, provides audit logging, supports multi-channel notifications, and offers fine-grained permission control, with installation instructions and configuration details for rapid deployment.
This article explains how Go leverages the Plan 9 assembly language as an intermediate representation, covering its history, portability benefits, performance advantages, cross‑platform challenges, and provides a step‑by‑step example of writing, compiling, and running a simple assembly‑backed Go program.
This article explains how to choose consistent, short, and precise names in Go, covering general naming principles, the first rule about declaration‑use distance, CamelCase style, local variables, parameters, return values, receivers, exported identifiers, interface naming, error naming, package naming, import paths, and useful standard‑library examples.
This guide explains Go's addr2line tool, covering its core function of translating memory addresses to source file locations, typical debugging and performance‑analysis scenarios, command‑line usage with examples, and how it streamlines error tracing and profiling in Go applications.
This article explores the origin of the term “byte,” explains why Go defines byte as an alias for uint8 to improve semantic clarity and readability, and shows how the byte type is used in file I/O, networking, and binary data processing.
This article explains the concept and operation of mutexes, outlines their lock‑unlock workflow, and provides a complete Go example demonstrating how sync.Mutex protects shared data and avoids race conditions in concurrent programs.
This article explains how to use Go's standard flag package for command-line argument parsing, demonstrates various flag definitions and parsing techniques, and provides an in‑depth analysis of its source code, including flag types, syntax, internal structures, and execution flow.
This article explains Go's container/ring package, detailing its Ring type, core methods, performance characteristics, practical code examples, and typical use cases such as schedulers and resource pools for efficient circular data handling.
This article provides an in‑depth exploration of Go’s container/list package, detailing its internal linked‑list structures, core methods, performance characteristics, practical code examples, and ideal use‑cases for scenarios requiring frequent insertions and deletions.
This article explores Go’s builtin package, detailing its fundamental types, essential built‑in functions, and practical usage examples, while explaining why mastering these built‑ins is critical for efficient Go programming and deeper understanding of the language’s type system and memory model.
This article explores Go's experimental arena library, detailing its design principles, core features such as fast allocation and memory reuse, suitable use cases like object pools and game development, provides a practical code example, and discusses performance benefits and limitations for high‑concurrency applications.
This article provides an in‑depth tutorial on Viper, a full‑featured Go configuration library, covering its features, usage scenarios, loading priorities, reading from files, environment variables, command‑line flags, remote stores, and best practices for managing application settings.
This article explains how Go's archive/zip package enables developers to easily create and extract ZIP archives, covering core types, step‑by‑step code examples for writing and reading ZIP files, and a UML overview of the processing flow.
This article explains how Go's native structs and interfaces can replace traditional Data Transfer Objects, offering a more concise, performant, and maintainable way to move data across application layers while highlighting best‑practice patterns and potential pitfalls.
This article explains why high‑concurrency systems need an asynchronous queue, walks through a producer‑consumer design implemented with Go and Gin, shows a complete code demo with configurable workers and capacity, and provides benchmark instructions to evaluate its performance.
Data Transfer Objects (DTOs) are essential for clean layered software design, and this article explains their purpose, key design principles such as encapsulation, orthogonality, and layer isolation, illustrates their role between presentation, service, and data layers, and provides a Go code example with benefits and challenges.
This article explains Gin's Bind() method, detailing how it detects request content types, selects appropriate binders for JSON, form, and XML data, performs parsing and validation, handles errors, and provides a practical code example for Go web developers.
This article explores Gin's request and response converters, detailing their roles, classifications, and practical code examples to help Go developers efficiently handle data binding and rendering in high‑performance web services.
This article introduces Uber's open‑source Zap library for Go, explains its high‑performance, structured, leveled logging features, demonstrates basic and advanced usage with code examples, compares production and development configurations, shows how to use SugaredLogger, customize loggers, apply options, and integrate the library into custom logging packages.
Learn how to improve maintainability and scalability in Go web applications by using a layered architecture with explicit data‑conversion between controller, service, and data layers, illustrated through a Gin‑based user‑registration example and practical guidelines for organizing conversion logic.
This guide explains Go's conditional statements, covering the basic if syntax, the use of else and else‑if clauses, initialization statements, limitations such as the lack of a ternary operator, and provides multiple practical code examples illustrating simple, chained, and nested conditions.
This article explains Go's uintptr type, its definition, typical scenarios such as cgo interaction and system calls, provides Linux and Windows code examples, and highlights key differences from regular pointers to help developers use it safely and effectively.
This guide explains how to use the Go debugger Delve to inspect program memory, covering stack and heap layout, byte order, setting breakpoints, disassembling code, and reading raw memory values, with step‑by‑step commands and screenshots that illustrate each operation.
An empty interface in Go, defined as interface{}, can hold values of any type because it has no methods, enabling flexible data structures like slices, maps, and structs, and is commonly used in functions such as fmt.Println, though copying between typed and empty interface slices requires careful handling.
This article explains how Go's generics feature improves type safety by enabling compile‑time checks, reducing the need for type assertions, and making code clearer and more maintainable, illustrated with concrete code examples and comparisons.
