Research areas: Windows & Linux platforms, C/C++ backend development, embedded systems and Linux kernel, etc.
This article explains how C++ implements polymorphism through virtual tables and virtual pointers, walks through their generation, memory layout, single‑ and multiple‑inheritance scenarios, distinguishes compile‑time and runtime polymorphism, and shows practical guidelines for when to use or avoid polymorphic designs.
This article explains how an operating system divides a C/C++ program's virtual address space into four distinct regions—code, global, stack, and heap—detailing their lifetimes, permissions, management rules, and common pitfalls such as memory leaks, dangling pointers, and stack overflow.
The article explains compile‑time polymorphism in C++, shows why traditional SFINAE is hard to read and debug, and demonstrates how C++20 Concepts provide clearer syntax, precise errors, and better multi‑condition support, backed by side‑by‑side code examples and a detailed feature comparison.
The author recounts how a naïve generic C++ object pool caused data residue, construction failures, and incompatibility with primitive types, then demonstrates a refactored, thread‑safe pool that leverages compile‑time Type Traits, std::enable_if, and constexpr if to apply distinct creation, reset, and destruction logic for trivial, Clear‑able, and non‑trivial types, eliminating the earlier bugs.
The article explains why high‑concurrency programs suffer from memory fragmentation and system‑call overhead, compares memory pools and object pools, outlines their distinct use‑cases, provides step‑by‑step C and C++ implementations, and highlights optimization tips and common pitfalls.
The article explains how off‑heap memory and mmap enable zero‑copy I/O for high‑performance Linux services, but because the JVM does not manage it, careless allocation or missing releases can cause off‑heap memory leaks that lead to OOM, and it provides concrete detection and mitigation techniques.
Although Linux pipes avoid disk I/O and seem faster, misuse such as tiny frequent writes, mismatched read/write speeds, non‑blocking tight loops, and improper fd handling can drive a single core to 100 % CPU, but the article explains the underlying reasons and step‑by‑step optimizations to prevent it.
This article explains the fundamentals of Linux dynamic linking, compares .so shared objects with static libraries, walks through creating and compiling a simple math library, shows how to link and run an executable, and details runtime loading, library path configuration, and common troubleshooting techniques.
This article explains the Linux kernel networking components—veth pairs, Linux bridges, and overlay networks—detailing their creation, configuration, packet flow, and troubleshooting with concrete Docker and Kubernetes examples, commands, and packet‑capture analysis.
This article walks readers through the fundamentals of Linux PCI/PCIe buses, explains the kernel PCI subsystem, details core data structures such as struct pci_dev, struct pci_driver, and struct pci_device_id, and provides step‑by‑step code examples for device enumeration, driver matching, resource allocation, and practical driver implementation.
