# balloonwj/cppguide

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/balloonwj-cppguide).**

6,030 stars · 977 forks

## Links

- GitHub: https://github.com/balloonwj/CppGuide
- awesome-repositories: https://awesome-repositories.com/repository/balloonwj-cppguide.md

## Description

CppGuide is a curated collection of educational resources and practical guides focused on C++ server development, Linux kernel internals, concurrent programming, network protocols, and security exploitation. It provides structured learning paths for backend developers, covering everything from interview preparation to building high-performance network servers and understanding operating system fundamentals.

The guide distinguishes itself by offering in-depth, hands-on tutorials that walk through real-world implementations, including building a Redis-like server from scratch, designing custom network protocols, and constructing remote control tools. It also delves into advanced topics such as shellcode injection, kernel module development, and the architecture of the Linux kernel, providing a mental model for how the kernel operates as a responsive, object-based system.

Beyond core C++ and kernel topics, the repository covers a broad range of supporting areas including memory management strategies, concurrency and synchronization patterns, network communication diagnostics, and performance optimization techniques. It also includes material on modern C++ language features, standard library usage, and software architecture patterns like the reactor model and event-driven design.

The documentation is organized as a series of guides and tutorials, with practical code examples and step-by-step explanations that trace execution paths through both user-space and kernel-space code.

## Tags

### Part of an Awesome List

- [Networking and Servers](https://awesome-repositories.com/f/awesome-lists/data/networking-and-servers.md) — Implements TCP, UDP, and HTTP communication with secure connections and custom protocols. ([source](https://cppguide.cn/pages/system-programming-essentials-with-go/))
- [Cross-Platform Thread Management](https://awesome-repositories.com/f/awesome-lists/devops/concurrency-threading/cross-platform-thread-management.md) — Teaches thread creation, synchronization, and management across Windows and Linux. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch03/))
- [Concurrent Programming](https://awesome-repositories.com/f/awesome-lists/devops/concurrent-programming.md) — Provides a comprehensive tutorial on managing threads, synchronization, and lock-free data structures in C++ and Go.
- [Linux Kernel Development](https://awesome-repositories.com/f/awesome-lists/devops/linux-kernel-development.md) — Offers an in-depth guide to Linux kernel architecture, memory management, scheduling, and device driver development.
- [Security and Penetration Testing](https://awesome-repositories.com/f/awesome-lists/security/security-and-penetration-testing.md) — Covers building remote control tools, shellcode injection, and kernel-level security mechanisms for penetration testing.
- [Exploit Development Guides](https://awesome-repositories.com/f/awesome-lists/security/security-and-penetration-testing/exploit-development-guides.md) — Offers hands-on resources for shellcode injection, remote control tools, and kernel-level security mechanisms.
- [Lazy Range Views](https://awesome-repositories.com/f/awesome-lists/data/sequence-processing/lazy-range-views.md) — Teaches C++20 range views for lazy, composable sequence transformations without intermediate allocations. ([source](https://cppguide.cn/pages/cpp20completeguides/))
- [Non-Thread-Safe Function Identification](https://awesome-repositories.com/f/awesome-lists/devops/concurrency-threading/thread-safe-assertions/non-thread-safe-function-identification.md) — Provides a guide for identifying and safely using non-thread-safe C library functions in multithreaded programs. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch03/))
- [Boot Sequence Walkthroughs](https://awesome-repositories.com/f/awesome-lists/devops/linux-kernel-development/boot-sequence-walkthroughs.md) — Walks through the Linux kernel boot process from architecture setup to core initialization. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch14/))
- [CPU Task Scheduling and Preemption](https://awesome-repositories.com/f/awesome-lists/devops/tasks-and-scheduling/cpu-task-scheduling-and-preemption.md) — Explains kernel-level task scheduling and preemption, a core operating system concept. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch04/))
- [Debugger Interfaces](https://awesome-repositories.com/f/awesome-lists/devtools/debugger-interfaces.md) — Open a terminal-based or visual front-end for common debugger commands to reduce typing and improve navigation. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch02/))
- [Error Handling](https://awesome-repositories.com/f/awesome-lists/devtools/error-handling.md) — Returns, wraps, and inspects errors, and recovers from panics with structured context. ([source](https://cppguide.cn/pages/gopracticeguides00/))

### Data & Databases

- [Collection Manipulators](https://awesome-repositories.com/f/data-databases/data-manipulation-libraries/collection-manipulators.md) — Teaches creating and manipulating arrays, slices, and maps for ordered and keyed data storage. ([source](https://cppguide.cn/pages/gopracticeguides00/))
- [Data Structure Implementations](https://awesome-repositories.com/f/data-databases/data-structure-implementations.md) — Teaches implementing hash tables, AVL trees, and heaps in C for real-world server use. ([source](https://cppguide.cn/pages/writemyredisfromscratch01/))
- [Thread-Safe Sharded Caches](https://awesome-repositories.com/f/data-databases/distributed-caching/distributed-data-caching-layers/thread-safe-sharded-caches.md) — Guides building a thread-safe, sharded distributed cache with configurable eviction policies. ([source](https://cppguide.cn/pages/system-programming-essentials-with-go/))
- [Read-Copy-Update Mechanisms](https://awesome-repositories.com/f/data-databases/zero-copy-data-access/concurrency-mechanisms/read-copy-update-mechanisms.md) — Teaches read-copy-update synchronization for lock-free concurrent reads, a key kernel concurrency mechanism. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch07/))
- [Runtime Variable Inspection](https://awesome-repositories.com/f/data-databases/application-state-management/state-inspection-interfaces/runtime-variable-inspection.md) — Pause execution and examine variables, memory, and call stacks to understand behavior during a crash or hang. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch02/))
- [Atomic Transaction Coordinators](https://awesome-repositories.com/f/data-databases/concurrent-write-optimizations/atomic-transaction-coordinators.md) — Teaches coordinating concurrent reads and writes with atomic transactions for data consistency. ([source](https://cppguide.cn/pages/writingmyowndatabasefromscratchingo/))
- [Network Communication Module Analyses](https://awesome-repositories.com/f/data-databases/connection-managers/redis/network-communication-module-analyses.md) — Analyzes Redis's network communication module for connection handling. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch08/))
- [Swap Compression](https://awesome-repositories.com/f/data-databases/data-compression/external-memory-block-compression/swap-compression.md) — Compresses swapped-out pages in RAM before they reach disk to reduce memory pressure. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch11/))
- [Slab Caches](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/caching-performance/caching/git-object-caches/slab-caches.md) — Provides slab caches that reuse fixed-size objects to reduce allocation overhead. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch10/))
- [Crash-Recovery Persistence Mechanisms](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/data-persistence-management/write-persistence-guarantees/crash-recovery-persistence-mechanisms.md) — Writes data to disk with crash recovery guarantees, preventing corruption from power loss or program failure. ([source](https://cppguide.cn/pages/writingmyowndatabasefromscratchingo/))
- [Non-Owning Array Views](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/data-transformation/array-tensor-manipulation/array-filtering/array-view-creation/non-owning-array-views.md) — Teaches std::span for non-owning views over contiguous sequences in C++. ([source](https://cppguide.cn/pages/cpp20completeguides/))
- [Memory-Efficient Data Streaming](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/stream-processing-systems/stream-processing/memory-efficient-data-streaming.md) — Streams results through worker pools and pipelines to handle high-volume data efficiently. ([source](https://cppguide.cn/pages/gopracticeguides00/))
- [Kernel State Signaling](https://awesome-repositories.com/f/data-databases/persistent-application-state/job-state-persistence/state-querying/atomic-state-updates/kernel-state-signaling.md) — Teaches atomic flag and counter updates for signaling between kernel execution contexts. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch23/))
- [B-Tree](https://awesome-repositories.com/f/data-databases/storage-engines/b-tree.md) — Uses on-disk B-trees or LSM trees for logarithmic-time record lookups even when indexes exceed memory. ([source](https://cppguide.cn/pages/writingmyowndatabasefromscratchingo/))
- [Type-Safe Format String Construction](https://awesome-repositories.com/f/data-databases/text-formatting/type-safe-format-string-construction.md) — Teaches C++20 std::format for type-safe string formatting with locale-aware placeholders. ([source](https://cppguide.cn/pages/cpp20completeguides/))
- [Integer Column Compression](https://awesome-repositories.com/f/data-databases/transparent-column-compression/integer-column-compression.md) — Encodes numeric fields using fewer bytes than native representation to reduce wire size. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch06/))
- [Type-Erased Value Containers](https://awesome-repositories.com/f/data-databases/variant-data-type-storage/type-erased-value-containers.md) — Teaches std::any for type-erased storage of any copy-constructible value in C++. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))

### Education & Learning Resources

- [Concurrent Connection Server Designs](https://awesome-repositories.com/f/education-learning-resources/architectural-design-guides/concurrent-connection-server-designs.md) — Guides structuring servers for many concurrent connections with low latency. ([source](https://balloonwj.github.io/cpp-guide-web/))
- [C++ Specific Preparation](https://awesome-repositories.com/f/education-learning-resources/coding-interview-preparation/c-specific-preparation.md) — Preparing for C++ backend developer interviews with curated questions, coding patterns, and system design topics.
- [String Processing](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/computer-science-foundations/string-processing.md) — Teaches string manipulation including formatting, splitting, trimming, encoding, and regex operations. ([source](https://cppguide.cn/pages/gopracticeguides00/))
- [Multithreaded](https://awesome-repositories.com/f/education-learning-resources/programming-tutorials/multithreaded.md) — Delivers practical tutorials on concurrent programming with threads, synchronization, and lock-free data structures.
- [Redis-like Server Building Tutorials](https://awesome-repositories.com/f/education-learning-resources/redis-like-server-building-tutorials.md) — Provides a tutorial on building a Redis-like server from scratch. ([source](https://cppguide.cn/pages/writemyredisfromscratch01/))
- [C++ Server Development Guides](https://awesome-repositories.com/f/education-learning-resources/server-architecture-guides/c-server-development-guides.md) — Offers a comprehensive guide to C++ network programming, server architecture, and system-level development.
- [Reactor Pattern Server Designs](https://awesome-repositories.com/f/education-learning-resources/server-architecture-guides/reactor-pattern-server-designs.md) — Guides server architecture using reactor patterns and reconnection mechanisms. ([source](https://balloonwj.github.io/cpp-guide-web/))
- [Socket Programming Tutorials](https://awesome-repositories.com/f/education-learning-resources/socket-programming-tutorials.md) — Teaches fundamental socket functions for building TCP/IP network applications. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch04/))
- [Interview Preparation Guides](https://awesome-repositories.com/f/education-learning-resources/interview-preparation-guides.md) — Provides a structured collection of C++ interview questions, coding patterns, and system design topics.
- [Pimpl Idiom Implementation](https://awesome-repositories.com/f/education-learning-resources/programming-idioms/pimpl-idiom-implementation.md) — Teaches the Pimpl idiom to hide private members and reduce compilation dependencies. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [String Search Algorithm Study](https://awesome-repositories.com/f/education-learning-resources/string-search-algorithm-study.md) — Applies Boyer-Moore and other search algorithms for efficient substring matching using std::search. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))

### Hardware & IoT

- [Device Completion Interrupts](https://awesome-repositories.com/f/hardware-iot/connectivity-iot/internet-of-things/device-management/peripheral-device-managers/interrupt-handlers/device-completion-interrupts.md) — Describes how hardware interrupts signal the CPU when a device operation completes. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch27/))
- [Hardware Action Coordination](https://awesome-repositories.com/f/hardware-iot/programmable-i-o-controllers/i-o-operation-concepts/hardware-action-coordination.md) — Explains how the kernel translates user-space operations into coordinated DMA, IOMMU, and interrupt actions. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch09/))
- [Driver to Device Mapping](https://awesome-repositories.com/f/hardware-iot/driver-to-device-mapping.md) — Scans buses for connected hardware and pairs each discovered device with a driver that knows how to operate it. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch09/))
- [Hardware Device Discovery](https://awesome-repositories.com/f/hardware-iot/hardware-device-discovery.md) — Scans buses such as PCIe and USB to detect connected devices and creates internal objects for each one. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch09/))

### Networking & Communication

- [Custom Network Protocols](https://awesome-repositories.com/f/networking-communication/custom-network-protocols.md) — Defines structured data formats and encoding rules for reliable message exchange over a network. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch06/))
- [Custom Protocol Implementations](https://awesome-repositories.com/f/networking-communication/custom-protocol-implementations.md) — Defines binary packet formats with compression and retransmission for reliable communication. ([source](https://cppguide.cn/gh0st-code-analysis/))
- [Reactor Pattern Network Servers](https://awesome-repositories.com/f/networking-communication/high-performance-networking/reactor-pattern-network-servers.md) — Guides building network servers using Reactor patterns and epoll. ([source](https://cdn.jsdelivr.net/gh/balloonwj/cppguide@master/README.md))
- [Thread Management](https://awesome-repositories.com/f/networking-communication/network-infrastructure-routing/network-infrastructure-configuration/network-and-server-infrastructure/server-frameworks/thread-management.md) — Explains structuring server applications with thread management and reconnection logic. ([source](https://cdn.jsdelivr.net/gh/balloonwj/cppguide@master/README.md))
- [Network Protocol Implementations](https://awesome-repositories.com/f/networking-communication/network-protocol-implementations.md) — Includes hands-on tutorials for implementing custom application protocols, WebSocket endpoints, and TCP/UDP communication patterns.
- [Protocol Implementation Tutorials](https://awesome-repositories.com/f/networking-communication/network-protocol-implementations/protocol-implementation-tutorials.md) — Provides hands-on guides for implementing TCP, UDP, HTTP, and custom protocols with socket programming.
- [Network Server Implementations](https://awesome-repositories.com/f/networking-communication/network-server-implementations.md) — Guides building TCP, UDP, and HTTP servers with TLS support and streaming file handling. ([source](https://cppguide.cn/pages/gopracticeguides00/))
- [Reactor Patterns](https://awesome-repositories.com/f/networking-communication/reactor-patterns.md) — Teaches the reactor pattern with non-blocking I/O and event loops for managing concurrent connections.
- [Kernel Packet-to-Stream Delivery](https://awesome-repositories.com/f/networking-communication/stream-reassemblers/kernel-packet-to-stream-delivery.md) — Explains how the kernel delivers a coherent byte stream from NIC packets to the owning process. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch25/))
- [Automatic Reconnection Logic](https://awesome-repositories.com/f/networking-communication/communication-protocols-architectures/communication-paradigms/server-to-client-event-emissions/connection-reconnection-policies/automatic-reconnection-logic.md) — Implements automatic reconnection logic that restores dropped network connections without manual intervention. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch09/))
- [Source Code Tracing Walkthroughs](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-computing/communication-protocols/websocket-implementations/websocket-clients-and-servers/source-code-tracing-walkthroughs.md) — Provides detailed source code walkthroughs tracing network message flow between server and client. ([source](https://cppguide.cn/pages/teamtalk-source-analysis/))
- [Network Diagnostics](https://awesome-repositories.com/f/networking-communication/network-diagnostics.md) — Diagnoses network issues by inspecting TCP connections and packet flows with diagnostic tools. ([source](https://cdn.jsdelivr.net/gh/balloonwj/cppguide@master/README.md))
- [Stream Reassembly Processes](https://awesome-repositories.com/f/networking-communication/network-packet-parsers/stream-reassembly-processes.md) — Explains how raw network packets are reassembled into a coherent byte stream for the owning process. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch25/))
- [Message Extraction from Buffers](https://awesome-repositories.com/f/networking-communication/packet-buffering/message-extraction-from-buffers.md) — Extracts individual messages from a buffer by applying framing or length-prefix schemes. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch06/))
- [Packet Fragmentation and Reassembly](https://awesome-repositories.com/f/networking-communication/packet-fragmentation-and-reassembly.md) — Splits oversized messages into smaller chunks and reassembles them at the receiver. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch06/))
- [Remote Access Clients](https://awesome-repositories.com/f/networking-communication/remote-access-clients.md) — Creates a client that connects to a control server and executes received commands. ([source](https://cppguide.cn/gh0st-code-analysis/))
- [Non-Blocking Socket I/O](https://awesome-repositories.com/f/networking-communication/socket-networking/non-blocking-socket-i-o.md) — Explains socket behavior differences between blocking and non-blocking modes. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch04/))
- [Sticky Packet Resolution](https://awesome-repositories.com/f/networking-communication/streaming-data-protocols/tcp-stream-reassembly/sticky-packet-resolution.md) — Separates and reassembles complete messages from a continuous byte stream to prevent data merging. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch06/))
- [WebSocket Implementations](https://awesome-repositories.com/f/networking-communication/websocket-implementations.md) — Upgrades an HTTP connection to a persistent, bidirectional channel for real-time communication. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch06/))

### Operating Systems & Systems Programming

- [Architecture Abstraction Layers](https://awesome-repositories.com/f/operating-systems-systems-programming/architecture-abstraction-layers.md) — Translates CPU-specific entry, context switching, and paging into a consistent interface for portable kernel code. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch03/))
- [Context-Aware Synchronization Selection](https://awesome-repositories.com/f/operating-systems-systems-programming/context-aware-synchronization-selection.md) — Explains how to choose synchronization primitives based on kernel execution context constraints. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch05/))
- [Cross-Subsystem I/O Routing](https://awesome-repositories.com/f/operating-systems-systems-programming/file-i-o-management/cross-subsystem-i-o-routing.md) — Explains how I/O requests are routed across kernel subsystems to access files, pipes, or sockets. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch02/))
- [Disk I/O Resolution Chains](https://awesome-repositories.com/f/operating-systems-systems-programming/file-i-o-management/disk-i-o-resolution-chains.md) — Traces the complete kernel path from file descriptor through inode and block mapping to physical disk I/O. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch25/))
- [Logical Interface Abstractions](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-interfacing-drivers/logical-interface-abstractions.md) — Explains how the kernel abstracts physical devices into stable logical interfaces like /dev/sda and eth0. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch09/))
- [Intent-Based Memory Allocation](https://awesome-repositories.com/f/operating-systems-systems-programming/intent-based-memory-allocation.md) — Explains the kernel's philosophy of memory as an intent-driven resource for each subsystem. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch10/))
- [Kernel Architecture References](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-architecture-references.md) — Describes the Linux kernel as a layered, responsive system covering memory, scheduling, and module isolation. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-contents/))
- [Object-Based Kernel Models](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-architecture-references/object-based-kernel-models.md) — Models the Linux kernel as a network of persistent objects with defined roles, lifecycles, and access rules.
- [Lifecycle Tracing](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-architecture-references/object-based-kernel-models/lifecycle-tracing.md) — Traces the lifecycle of kernel objects like task_struct and inode across execution contexts. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch06/))
- [Kernel Interfaces](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/ebpf-tooling/kernel-interfaces.md) — Describes syscalls, virtual filesystems, ioctl, mmap, ptrace, Netlink, and eBPF for user-kernel interaction. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch26/))
- [Task Control Block Management](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/kernel-development/paging-and-context-switching/task-control-block-management.md) — Explains saving and restoring full CPU register state across tasks during context switches. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch17/))
- [Conceptual Maps](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/operating-system-kernels/kernel-mechanism-deconstructions/conceptual-maps.md) — Provides a conceptual map of kernel request handling, mechanism enforcement, and service delivery. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-contents/))
- [Process and Memory Management](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management.md) — Orchestrates memory, scheduling, I/O, interrupts, and security to reliably run user processes. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch02/))
- [Physical Address Mapping](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management-systems/physical-address-mapping.md) — Describes mapping user-space pointers through per-process page tables to physical memory for isolation. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch25/))
- [Policy-Based Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/policy-based-allocators.md) — Provides layered allocators and protected APIs for varying memory allocation requirements. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch03/))
- [Subsystem-Tailored Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/slab-allocators/subsystem-tailored-allocators.md) — Provides specialized allocation interfaces like kmalloc, Slab caches, vmalloc, and DMA API. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch10/))
- [Privileged Operation Isolation](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/stack-allocation-optimizations/privileged-operation-isolation.md) — Explains how the kernel assigns a private stack per task for safe privileged operation isolation. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch17/))
- [Process Address Space Allocation](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/system-memory-allocation/process-address-space-allocation.md) — Assigns each process a virtual address space tracked by a descriptor with regions and flags. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch11/))
- [Namespace-Based Isolation](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/process-isolation/namespace-based-isolation.md) — Explains Linux kernel namespace-based isolation for process and resource separation. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch19/))
- [Process Visibility Remappings](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/process-isolation/namespace-based-isolation/process-visibility-remappings.md) — Describes how to remap a process's view of system resources for isolation. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch13/))
- [Wait Queue Blocking](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/process-queue-managers/wait-queue-blocking.md) — Places a process into a sleep state on a wait queue until another context signals a condition has been met. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch23/))
- [System Calls](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/system-calls.md) — Teaches how to invoke low-level OS services through system calls for file and process operations. ([source](https://cppguide.cn/pages/system-programming-essentials-with-go/))
- [System Call Handlers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/system-calls/system-call-handlers.md) — Responds to user-space requests by coordinating subsystems to validate, allocate, and execute operations. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch02/))
- [Work Deferral Mechanisms](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/system-programming-primitives/system-programming/hardware-interfaces/pci-bus-management/interrupt-controllers/interrupt-vector-handlers/work-deferral-mechanisms.md) — Explains how to schedule softirqs and tasklets to defer heavy processing after interrupt handlers. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch23/))
- [Kernel Execution Context Layering](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-context-layering.md) — Explains how the kernel stages work across interrupt, softirq, workqueue, and kernel thread contexts.
- [Constraint Enforcement Mechanisms](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-context-layering/constraint-enforcement-mechanisms.md) — Describes how the kernel enforces different operational constraints across execution contexts. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch05/))
- [CPU-Kernel Coordination](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-context-layering/cpu-kernel-coordination.md) — Describes how the kernel and CPU coordinate context switches, interrupts, and system calls. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch28/))
- [Hardware-Coordinated Synchronization Explainers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-context-layering/hardware-coordinated-synchronization-explainers.md) — Explains how the kernel coordinates context switches and interrupts with CPU-level timing for predictable execution. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch28/))
- [Inter-Context Data Exchange](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-context-layering/inter-context-data-exchange.md) — Explains how kernel contexts exchange data and coordinate execution using shared memory and locks. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch23/))
- [Work Delegation Chains](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-context-layering/work-delegation-chains.md) — Explains how the kernel delegates work across execution contexts to satisfy constraints. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch05/))
- [Kernel Execution Environment Concepts](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-environment-concepts.md) — Provides a foundational explanation of the Linux kernel as a privileged execution environment. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch01/))
- [Kernel Memory Layouts](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-memory-layouts.md) — Explains how the kernel structures memory into distinct regions for code, data, devices, and per-CPU variables. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch12/))
- [Kernel Thread Distinctions](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-process-internals/kernel-thread-distinctions.md) — Explains the distinction between kernel threads and user processes, a key operating system concept. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch01/))
- [Kernel Subsystem Coordination Rules](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-subsystem-coordination-rules.md) — Describes the global rules that coordinate kernel subsystems for safe operation. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch05/))
- [Kernel Subsystem Service Sequencing](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-subsystem-service-sequencing.md) — Explains how kernel subsystems are sequenced to fulfill a single process request. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch02/))
- [Memory-Mapped I/O](https://awesome-repositories.com/f/operating-systems-systems-programming/memory-mapped-i-o.md) — Describes writing to device control registers exposed as physical addresses for hardware configuration. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch27/))
- [Contention-Minimizing Locking Strategies](https://awesome-repositories.com/f/operating-systems-systems-programming/mutexes-and-locks/contention-minimizing-locking-strategies.md) — Teaches fine-grained locking with spinlocks and per-CPU structures, a core concurrency topic in the kernel guides. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch07/))
- [Responsive System Models](https://awesome-repositories.com/f/operating-systems-systems-programming/operating-system-kernels/responsive-system-models.md) — Provides a conceptual model of the kernel as a responsive, context-driven system. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-contents/))
- [Context-Switch Protection Enforcement](https://awesome-repositories.com/f/operating-systems-systems-programming/paged-memory-management/page-table-entry-management/context-switch-protection-enforcement.md) — Explains how the kernel configures page tables and switches them on context switches for memory protection. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch17/))
- [Per-Task Indirect Reference Isolations](https://awesome-repositories.com/f/operating-systems-systems-programming/per-task-indirect-reference-isolations.md) — Explains how the kernel resolves all references through per-task mappings to prevent direct object access. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch04/))
- [Resource Limit Enforcements](https://awesome-repositories.com/f/operating-systems-systems-programming/per-task-indirect-reference-isolations/resource-limit-enforcements.md) — Covers per-task resource limits using cgroups and security modules. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch04/))
- [Per-Task Stack Isolation](https://awesome-repositories.com/f/operating-systems-systems-programming/privileged-kernel-operations/per-task-stack-isolation.md) — Explains how the kernel assigns a private stack to each task for safe privileged execution. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch16/))
- [Preemptive Scheduling](https://awesome-repositories.com/f/operating-systems-systems-programming/task-priority-management/preemptive-scheduling.md) — Explains how timer interrupts and rescheduling flags enforce time slices and prioritization in kernel scheduling. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch17/))
- [Virtual Memory Mappers](https://awesome-repositories.com/f/operating-systems-systems-programming/virtual-memory-management/virtual-memory-mappers.md) — Maps virtual addresses to physical pages on demand with protection and lazy filling via page faults. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch10/))
- [C-to-Shellcode Compilers](https://awesome-repositories.com/f/operating-systems-systems-programming/assembly-injection-interfaces/shellcode-generators/c-to-shellcode-compilers.md) — Ships a compile-time pipeline that converts C code into position-independent shellcode, a distinctive capability. ([source](https://cppguide.cn/pages/windows-shellcode-advanced-practice/))
- [C-to-Shellcode Conversions](https://awesome-repositories.com/f/operating-systems-systems-programming/assembly-injection-interfaces/shellcode-generators/c-to-shellcode-conversions.md) — Transforms C source files into position-independent shellcode at compile time for in-memory execution.
- [Executable Infection Payloads](https://awesome-repositories.com/f/operating-systems-systems-programming/assembly-injection-interfaces/shellcode-generators/dns-shellcode-execution/executable-infection-payloads.md) — Provides hands-on tutorials for creating trojans by infecting executables, a core security exploitation topic. ([source](https://cppguide.cn/pages/windows-shellcode-advanced-practice/))
- [Polymorphic Payload Generators](https://awesome-repositories.com/f/operating-systems-systems-programming/assembly-injection-interfaces/shellcode-generators/polymorphic-payload-generators.md) — Teaches generating polymorphic shellcode to bypass signature-based antivirus, a key evasion technique. ([source](https://cppguide.cn/pages/windows-shellcode-advanced-practice/))
- [Process Injection Payloads](https://awesome-repositories.com/f/operating-systems-systems-programming/assembly-injection-interfaces/shellcode-generators/process-injection-payloads.md) — Provides tutorials on injecting shellcode into running processes, a core security exploitation capability. ([source](https://cppguide.cn/pages/windows-shellcode-advanced-practice/))
- [Conditional Breakpoints](https://awesome-repositories.com/f/operating-systems-systems-programming/conditional-breakpoints.md) — Halt execution only when a specified condition is met to focus debugging on relevant code paths. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch02/))
- [CPU Affinity Binding](https://awesome-repositories.com/f/operating-systems-systems-programming/cpu-affinity-binding.md) — Restricts where a task, interrupt, or memory allocation may run by respecting affinity masks and memory policies. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch21/))
- [Device Class Organizations](https://awesome-repositories.com/f/operating-systems-systems-programming/device-class-organizations.md) — Organizes devices into classes (block, character, network) and provides uniform system-call interfaces for each class. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch09/))
- [Device Node Interfaces](https://awesome-repositories.com/f/operating-systems-systems-programming/device-node-interfaces.md) — Presents hardware through consistent abstractions like /dev files and network interface names, hiding bus and driver details. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch09/))
- [DMA Controllers](https://awesome-repositories.com/f/operating-systems-systems-programming/direct-memory-access/dma-controllers.md) — Uses a device controller's DMA engine to move data between device and system memory without CPU involvement per byte. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch27/))
- [Hardware Abstraction Layers](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-interfacing-drivers/hardware-abstraction-layers.md) — Explains how the Linux kernel hides hardware details behind standard operation tables for portable code. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch04/))
- [Kernel Extension Loaders](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-interfacing-drivers/hardware-drivers/graphics-drivers/kernel-driver-injection/kernel-extension-loaders.md) — Documents how to load kernel modules (.ko files) to extend functionality without rebooting. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch15/))
- [System Call and Driver Callback Routings](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-interfacing-drivers/hardware-drivers/usb-subsystem-drivers/system-call-and-driver-callback-routings.md) — Explains how the kernel routes control through system call tables and driver callbacks per subsystem. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch19/))
- [Hardware Subsystem Translation Bridges](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-subsystem-translation-bridges.md) — Explains how the kernel translates between independent hardware subsystems for coherent interaction. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch25/))
- [Configuration Selection](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-configurations/configuration-selection.md) — Teaches how to select kernel features and drivers via the .config file during build time. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch15/))
- [Interrupt Handling](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/interrupt-handling.md) — Builds a pre-configured interrupt architecture with declared routing and priority. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch20/))
- [eBPF Program Verifiers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/kernel-development/kernel-observability-programs/ebpf-program-verifiers.md) — Covers writing, verifying, and attaching eBPF programs to kernel hooks for secure kernel extension. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch15/))
- [Kernel Structure Resolutions](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management-systems/native-resource-lifecycle-managers/file-descriptor-managers/direct-file-descriptor-i-o/kernel-structure-resolutions.md) — Traces how file descriptors are resolved through kernel structures to physical disk I/O. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch25/))
- [Flag-Based Allocation Constraints](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/managed-memory-allocators/flag-based-allocation-constraints.md) — Allocates memory with flags matching subsystem needs for speed, lifetime, or hardware access. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch10/))
- [Polymorphic Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/polymorphic-allocators.md) — Teaches C++ pmr polymorphic allocators for custom memory strategies in containers. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Demand Paging](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/memory-demand-analyzers/demand-paging.md) — Resolves page faults by traversing page tables, checking permissions, and allocating physical memory on demand. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch11/))
- [Pipe-Based Communication](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/system-programming-primitives/inter-process-communication/pipe-based-communication.md) — Provides tutorials on creating anonymous and named pipes for inter-process data streaming. ([source](https://cppguide.cn/pages/system-programming-essentials-with-go/))
- [DMA and IOMMU Translations](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/system-programming-primitives/system-programming/hardware-interfaces/pci-bus-management/interrupt-controllers/interrupt-masking/multiprocessor-interrupt-routing/dma-and-iommu-translations.md) — Coordinates direct memory access, IOMMU translations, and interrupt routing to move data efficiently and securely. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch09/))
- [Interrupt Handlers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-context-layering/interrupt-handlers.md) — Explains how kernel code runs as immediate interrupt handlers restricted to atomic operations. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch18/))
- [Process Context Handlers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-context-layering/process-context-handlers.md) — Describes how kernel code runs within a user process context, permitting sleep and memory allocation. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch18/))
- [Context Validation Rules](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-execution-context-layering/process-context-handlers/context-validation-rules.md) — Checks whether code runs in process or interrupt context and enforces rules like blocking or sleeping only where allowed. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch22/))
- [Kernel Fault Diagnosis](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-fault-diagnosis.md) — Uses knowledge of kernel memory mapping to identify sources of page faults and crashes. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch12/))
- [Load-Time Symbol Resolution](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-symbol-resolution/load-time-symbol-resolution.md) — Teaches how kernel modules resolve undefined symbols against the exported symbol table at load time. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch24/))
- [Deadlock-Free Mutex Locking](https://awesome-repositories.com/f/operating-systems-systems-programming/mutexes-and-locks/deadlock-free-mutex-locking.md) — Teaches deadlock-free mutex locking using std::scoped_lock, a key C++ concurrency pattern. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Locality-Based Page Relocations](https://awesome-repositories.com/f/operating-systems-systems-programming/paged-memory-management/locality-based-page-relocations.md) — Relocates pages based on access patterns to improve performance via page faults or background scanning. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch11/))
- [Physical Page Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/paged-memory-management/physical-page-allocators.md) — Represents every physical memory page with a descriptor used by all memory subsystems. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch11/))
- [Handle-to-Object Resolutions](https://awesome-repositories.com/f/operating-systems-systems-programming/per-task-indirect-reference-isolations/handle-to-object-resolutions.md) — Explains how the kernel resolves file descriptors and PIDs into internal objects for safe access. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch06/))
- [Processor State Preservation](https://awesome-repositories.com/f/operating-systems-systems-programming/processor-state-preservation.md) — Maintains the full context of each execution path so tasks can be paused and resumed seamlessly. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch16/))
- [Live Function Replacement](https://awesome-repositories.com/f/operating-systems-systems-programming/system-administration-maintenance/system-administration-utilities/system-modification-frameworks/kernel-patching-utilities/live-function-replacement.md) — Describes how to replace kernel functions at runtime without rebooting the system. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch15/))
- [Multi-Threaded Debugging](https://awesome-repositories.com/f/operating-systems-systems-programming/thread-inspection/multi-threaded-debugging.md) — Inspect and control individual threads in a running program to find concurrency bugs and race conditions. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch02/))

### Programming Languages & Runtimes

- [Automatic Type Deduction](https://awesome-repositories.com/f/programming-languages-runtimes/automatic-type-deduction.md) — Teaches automatic type deduction using auto for variables and return types in C++. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [Brace Initialization Patterns](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-class-creation/runtime-class-modifications/class-initialization-sequences/instance-initialization/brace-initialization-patterns.md) — Teaches C++ uniform member initialization with brace syntax and initializer lists. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [Thread-Local Contexts](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/thread-local-contexts.md) — Teaches thread-local storage for safe concurrent execution, a fundamental kernel and server programming pattern. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch07/))
- [Modern C++ Feature Adoption](https://awesome-repositories.com/f/programming-languages-runtimes/modern-c-feature-adoption.md) — Applies C++11/14/17 features like structured bindings and smart pointers for safer code. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [RAII Patterns](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/language-specific-resources/language-tutorials/c-c-tutorials/object-management/object-lifetime-management/raii-patterns.md) — Binds resource acquisition to object lifetime so resources are automatically released when the object goes out of scope. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [Move Semantics](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/language-runtimes/move-semantics.md) — Clarifies std::move, std::forward, universal references, and reference collapsing for efficient transfers. ([source](https://cppguide.cn/pages/cppinterviewmostaskedquestions01/))
- [Smart Pointer Allocations](https://awesome-repositories.com/f/programming-languages-runtimes/smart-pointer-allocations.md) — Teaches smart pointer usage for automated heap memory management in C++. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [Standard Template Library Integrations](https://awesome-repositories.com/f/programming-languages-runtimes/standard-template-library-integrations.md) — Teaches C++ Standard Template Library containers, algorithms, and iterators for efficient data manipulation. ([source](https://cppguide.cn/pages/cppinterviewmostaskedquestions01/))
- [Kernel Module Access Restrictions](https://awesome-repositories.com/f/programming-languages-runtimes/symbolic-identifiers/exported-symbols/kernel-module-access-restrictions.md) — Provides a guide on restricting kernel module access to only explicitly exported symbols. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch24/))
- [Structured Binding Decompositions](https://awesome-repositories.com/f/programming-languages-runtimes/variable-assignments/tuple-unpacking-swaps/structured-binding-decompositions.md) — Teaches C++17 structured bindings for unpacking tuples and structs into named variables. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [Const Correctness Enforcement](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-correctness-verification/const-correctness-enforcement.md) — Teaches const, constexpr, consteval, and constinit for compile-time evaluation and immutability. ([source](https://cppguide.cn/pages/cppinterviewmostaskedquestions01/))
- [Compile-Time Conditional Branching](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expressions/compile-time-conditional-branching.md) — Teaches using if constexpr for compile-time conditional branching in templates, replacing SFINAE. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Compile-Time Type Constraints](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-type-constraints.md) — Covers C++20 concepts for constraining template parameters with compile-time predicates. ([source](https://cppguide.cn/pages/cpp20completeguides/))
- [SoftIRQ Deferred Work](https://awesome-repositories.com/f/programming-languages-runtimes/deferred-execution/softirq-deferred-work.md) — Explains the softirq mechanism for registering static handlers that run atomically for deferred tasks. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch18/))
- [Tasklet Deferred Work](https://awesome-repositories.com/f/programming-languages-runtimes/deferred-execution/tasklet-deferred-work.md) — Describes the tasklet mechanism for running serialized, non-preemptible deferred work on a specific CPU. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch18/))
- [Workqueue Deferred Work](https://awesome-repositories.com/f/programming-languages-runtimes/deferred-execution/workqueue-deferred-work.md) — Explains the workqueue mechanism for running deferred tasks that require sleeping in kernel worker threads. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch18/))
- [Kernel Callback Registration](https://awesome-repositories.com/f/programming-languages-runtimes/function-pointer-callbacks/kernel-callback-registration.md) — Documents registering function pointers for decoupled coordination between kernel subsystems. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch23/))
- [Generic Types](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types.md) — Writes type-safe, reusable functions and data structures that work across multiple types. ([source](https://cppguide.cn/pages/gopracticeguides00/))
- [Scoped Condition Variables](https://awesome-repositories.com/f/programming-languages-runtimes/instance-initialization-hooks/instance-variable-initializers/scoped-condition-variables.md) — Teaches C++17 scoped variable initialization inside if and switch conditions for cleaner code. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Thread Local Storage](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/execution-models/multi-threaded-execution/thread-local-storage.md) — Shows how to store data private to each thread using thread-local storage to avoid shared-state conflicts. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch03/))
- [Work Queue Design](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/task-orchestration-frameworks/thread-pools/work-queue-design.md) — Guides the design of thread pools and work-queue systems for efficient task distribution. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch03/))
- [Class Template Argument Deductions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/generics-templates/variadic-template-arguments/class-template-argument-deductions.md) — Explains how C++17 class template argument deduction reduces boilerplate by inferring types from constructors. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Type-Safe Variants](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/language-extensions/union-types/type-safe-variants.md) — Holds one value from a fixed set of types, providing type-safe access and visitation without manual union management. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Header-Scoped Global Variables](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/header-scoped-global-variables.md) — Explains C++17 inline variables for defining shared global state in header files without linker errors. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Compile-Time Evaluable Lambdas](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/polymorphic-logic/generic-lambda-expressions/compile-time-evaluable-lambdas.md) — Shows how to create constexpr lambdas for use in compile-time constant expressions. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Lambda Capture and Invocation Patterns](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/polymorphic-logic/generic-lambda-expressions/lambda-capture-and-invocation-patterns.md) — Explains lambda syntax, capture modes, and immediately-invoked lambda patterns in C++. ([source](https://cppguide.cn/pages/cppinterviewmostaskedquestions01/))
- [Object-Copying Captures](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/foreign-function-interfaces/c-bindings/lambda-bindings/object-copying-captures.md) — Teaches C++17 *this capture to safely copy the current object into a lambda, preventing dangling references. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Read-Copy-Update Reclamation](https://awesome-repositories.com/f/programming-languages-runtimes/manual-memory-reclamation/read-copy-update-reclamation.md) — Covers the RCU callback mechanism for postponing memory freeing until concurrent readers finish. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch18/))
- [Module Organization Systems](https://awesome-repositories.com/f/programming-languages-runtimes/module-organization-systems.md) — Provides a guide on using C++20 modules to replace header files for faster compilation and better symbol control. ([source](https://cppguide.cn/pages/cpp20completeguides/))
- [Runtime Polymorphism](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-polymorphism.md) — Teaches virtual functions, inheritance, and the virtual table mechanism for runtime dispatch. ([source](https://cppguide.cn/pages/cppinterviewmostaskedquestions01/))
- [Standard Library Container Updates](https://awesome-repositories.com/f/programming-languages-runtimes/standard-library-container-updates.md) — Teaches new methods added to STL containers in C++11/14/17 for efficient data manipulation. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [Static Storage Pitfalls](https://awesome-repositories.com/f/programming-languages-runtimes/static-memory-allocations/static-initialization/static-storage-pitfalls.md) — Describes static storage behavior, including initialization order pitfalls and thread-safety concerns. ([source](https://cppguide.cn/pages/cppinterviewmostaskedquestions01/))
- [String-to-Numeric Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/string-type-conversions/string-to-numeric-conversions.md) — Demonstrates efficient string-to-number parsing using from_chars without exceptions or locale overhead. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Locale-Free Numeric Formatters](https://awesome-repositories.com/f/programming-languages-runtimes/string-type-conversions/string-to-numeric-conversions/locale-free-numeric-formatters.md) — Demonstrates efficient number-to-string conversion using to_chars without locale overhead. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Undefined Behavior Detection](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-detection.md) — Explains how to identify and avoid undefined, unspecified, and implementation-defined behavior in C++. ([source](https://cppguide.cn/pages/cppinterviewmostaskedquestions01/))

### Security & Cryptography

- [Kernel Task Execution Isolations](https://awesome-repositories.com/f/security-cryptography/execution-isolation/kernel-task-execution-isolations.md) — Explains kernel task execution isolation using virtual and mapped contexts. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch04/))
- [Special Member Function Guidances](https://awesome-repositories.com/f/security-cryptography/compliance-enforcement-tools/compliance-rule-enforcement/special-member-function-guidances.md) — Guides correct implementation of special member functions for safe resource management. ([source](https://cppguide.cn/pages/cppinterviewmostaskedquestions01/))
- [Shellcode](https://awesome-repositories.com/f/security-cryptography/data-encryption/encrypted-persistence/object-store-encryption/payload-encryptions/shellcode.md) — Demonstrates encrypting shellcode payloads to evade static analysis. ([source](https://cppguide.cn/pages/windows-shellcode-advanced-practice/))
- [In-Memory Payload Execution](https://awesome-repositories.com/f/security-cryptography/in-memory-payload-execution.md) — Teaches running shellcode entirely from memory to avoid disk forensics, a key exploitation technique. ([source](https://cppguide.cn/pages/windows-shellcode-advanced-practice/))

### Software Engineering & Architecture

- [Asynchronous Task Execution](https://awesome-repositories.com/f/software-engineering-architecture/concurrency-models/asynchronous-task-execution.md) — Teaches using thread pools for background jobs without blocking the main event loop, a core server architecture pattern. ([source](https://cppguide.cn/pages/writemyredisfromscratch01/))
- [Concurrency Synchronization Primitives](https://awesome-repositories.com/f/software-engineering-architecture/concurrency-synchronization-primitives.md) — Explains mutexes, condition variables, and synchronization objects to prevent race conditions in multithreaded code. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch03/))
- [Kernel Object Synchronization](https://awesome-repositories.com/f/software-engineering-architecture/concurrency-synchronization-primitives/kernel-object-synchronization.md) — Explains using locks, barriers, and atomic operations to synchronize access to shared kernel objects. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch22/))
- [Kernel Object Contract Enforcements](https://awesome-repositories.com/f/software-engineering-architecture/concurrent-object-access/kernel-object-contract-enforcements.md) — Uses object-defined contracts for access and concurrency in kernel paths. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch06/))
- [Privilege Level Enforcements](https://awesome-repositories.com/f/software-engineering-architecture/execution-control/execution-modes/privilege-level-enforcements.md) — Enforces privilege level checks for user-mode to kernel-mode transitions. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch13/))
- [Hardware Abstraction Layers](https://awesome-repositories.com/f/software-engineering-architecture/hardware-abstraction-layers.md) — Translates architecture-specific hardware behavior into a consistent kernel interface for portability. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch03/))
- [Kernel Synchronization Primitives](https://awesome-repositories.com/f/software-engineering-architecture/shared-memory-management/kernel-synchronization-primitives.md) — Covers spinlocks, atomic operations, and lock-free techniques for kernel data structure synchronization. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch23/))
- [Phased Boot Initialization](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/foundational-theory-and-guidance/software-architecture-principles/module-organization-patterns/kernel-subsystem-organization/phased-boot-initialization.md) — Explains the phased boot-time initialization of kernel subsystems in strict dependency order. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch14/))
- [Linux Kernel Design Principles](https://awesome-repositories.com/f/software-engineering-architecture/software-design-philosophies/linux-kernel-design-principles.md) — Explores the conceptual architecture and design principles of the Linux kernel. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-contents/))
- [Kernel Thread Spawning](https://awesome-repositories.com/f/software-engineering-architecture/task-scheduling/parallel-task-executors/parallel-task-spawning/os-thread-spawning/kernel-thread-spawning.md) — Describes how the kernel creates its first thread and initial user-space process during boot. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch14/))
- [Kernel Thread Context Isolations](https://awesome-repositories.com/f/software-engineering-architecture/thread-per-connection-models/kernel-thread-context-isolations.md) — Explains per-thread context execution for kernel-level isolation. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch03/))
- [Contiguous Memory Buffers](https://awesome-repositories.com/f/software-engineering-architecture/block-based-data-models/data-block-memory-management/contiguous-memory-buffers.md) — Covers allocation of virtually contiguous memory from scattered physical pages for large buffers. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch10/))
- [DMA Buffer Reservations](https://awesome-repositories.com/f/software-engineering-architecture/block-based-data-models/data-block-memory-management/contiguous-memory-buffers/dma-buffer-reservations.md) — Allocates physically contiguous memory accessible to hardware for direct memory access operations. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch10/))
- [Distributed Chat System Analyses](https://awesome-repositories.com/f/software-engineering-architecture/client-server-architecture/distributed-chat-system-analyses.md) — Analyzes the structure and interaction of distributed chat server components. ([source](https://cppguide.cn/pages/teamtalk-source-analysis/))
- [Compile-Time Code Generation](https://awesome-repositories.com/f/software-engineering-architecture/compile-time-code-generation.md) — Generates position-independent shellcode from C source files at compile time for in-memory execution.
- [Range-Based Loop Iteration](https://awesome-repositories.com/f/software-engineering-architecture/compile-time-code-generation/iterative-code-generation/iterative-loop-constructs/range-based-loop-iteration.md) — Teaches range-based for loops for concise iteration over containers and arrays. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [Domain Type Definitions](https://awesome-repositories.com/f/software-engineering-architecture/data-structures/domain-type-definitions.md) — Creates new types, structs, and interfaces to model domain data and enforce contracts. ([source](https://cppguide.cn/pages/gopracticeguides00/))
- [Network Error Code Handlings](https://awesome-repositories.com/f/software-engineering-architecture/edge-case-analysis/algorithmic-edge-cases/network-error-code-handlings.md) — Covers error codes, byte ordering, and buffer inspection for robust network servers. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch04/))
- [Build-Time Feature Toggles](https://awesome-repositories.com/f/software-engineering-architecture/feature-flags/build-time-feature-toggles.md) — Uses a configuration file to decide which components are compiled into the core image or loaded as modules. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch15/))
- [Spaceship Operator Implementations](https://awesome-repositories.com/f/software-engineering-architecture/logical-comparison-operators/decimal-comparison-operators/spaceship-operator-implementations.md) — Demonstrates the C++20 three-way comparison operator for simplifying custom type comparisons. ([source](https://cppguide.cn/pages/cpp20completeguides/))
- [C++17 Attribute Annotations](https://awesome-repositories.com/f/software-engineering-architecture/metadata-attachments/code-annotations/c-17-attribute-annotations.md) — Teaches using C++17 attributes to convey intent to the compiler and static analyzers. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))
- [Optional Value Types](https://awesome-repositories.com/f/software-engineering-architecture/optional-value-types.md) — Represents a value that may or may not be present, avoiding sentinel values and enabling safe optional semantics. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Resource Management Patterns](https://awesome-repositories.com/f/software-engineering-architecture/resource-management-patterns.md) — Teaches resource management patterns like object pooling and deduplication for efficient execution. ([source](https://cppguide.cn/pages/system-programming-essentials-with-go/))
- [Hardware-Software Domain Bridges](https://awesome-repositories.com/f/software-engineering-architecture/stream-component-bridging/hardware-software-domain-bridges.md) — Explains how the kernel translates between hardware and software subsystems for coherent interaction. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch25/))

### System Administration & Monitoring

- [Event-Driven I/O](https://awesome-repositories.com/f/system-administration-monitoring/administrative-operations/linux-system-administration/networking/connection-lifecycle-management/parallel-network-i-o/event-driven-i-o.md) — Explains non-blocking I/O and event loop patterns for managing concurrent client connections efficiently. ([source](https://cppguide.cn/pages/writemyredisfromscratch01/))
- [Socket Event Loops](https://awesome-repositories.com/f/system-administration-monitoring/administrative-operations/linux-system-administration/networking/connection-lifecycle-management/parallel-network-i-o/event-driven-i-o/asynchronous-event-loops/socket-event-loops.md) — Explains how event-driven libraries manage I/O readiness notifications and dispatch callbacks without blocking. ([source](https://cppguide.cn/pages/libevent-source-analysis/))
- [Kernel Execution Path Tracing](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/execution-tracers/kernel-tracing-frameworks/kernel-execution-path-tracing.md) — Traces kernel execution paths by identifying entry points, contexts, scheduling points, and data ownership. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-contents/))
- [Background Task Offloading](https://awesome-repositories.com/f/system-administration-monitoring/resource-scheduling/kernel-schedulers/background-task-offloading.md) — Teaches how to delegate work to kernel threads for background or asynchronous processing. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch23/))
- [IOCP-Based Server Listeners](https://awesome-repositories.com/f/system-administration-monitoring/administrative-operations/linux-system-administration/networking/connection-lifecycle-management/remote-server-connectivities/iocp-based-server-listeners.md) — Sets up a network server using Windows IOCP for high-concurrency client management. ([source](https://cppguide.cn/gh0st-code-analysis/))
- [Multi-Process Debugging](https://awesome-repositories.com/f/system-administration-monitoring/debugging-observers/process-debuggers/multi-process-debugging.md) — Attach to and trace multiple related processes at once to analyze inter-process communication and shared state. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch02/))
- [Device Grouping](https://awesome-repositories.com/f/system-administration-monitoring/device-grouping.md) — Groups devices by type and exposes a uniform interface for each class, hiding bus and hardware details. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch09/))
- [Application Logging](https://awesome-repositories.com/f/system-administration-monitoring/diagnostic-tools/diagnostics/telemetry-and-log-collectors/application-logging.md) — Records structured or plain-text log messages at configurable levels and outputs. ([source](https://cppguide.cn/pages/gopracticeguides00/))
- [Timed Softirq Callbacks](https://awesome-repositories.com/f/system-administration-monitoring/execution-callbacks/timed-softirq-callbacks.md) — Covers the mechanism for executing short, non-blocking callbacks in softirq context after a delay. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch18/))
- [Keep-Alive Signals](https://awesome-repositories.com/f/system-administration-monitoring/health-monitoring/connection-health-monitors/keep-alive-signals.md) — Sends periodic heartbeat messages to detect and maintain the liveness of a remote connection. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch09/))
- [Centralized Logging Architectures](https://awesome-repositories.com/f/system-administration-monitoring/logging/application-logging-configurations/centralized-logging-architectures.md) — Structures a centralized logging system that records events with configurable severity levels. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch09/))
- [Asynchronous Memory Reclamation](https://awesome-repositories.com/f/system-administration-monitoring/memory-management/memory-pressure-notifications/asynchronous-memory-reclamation.md) — Reclaims memory asynchronously by scanning LRU lists and releasing subsystem caches under pressure. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch11/))
- [Application Performance Profiling](https://awesome-repositories.com/f/system-administration-monitoring/performance-monitoring-tools/application-performance-profiling.md) — Covers profiling and optimization techniques for identifying performance bottlenecks in applications. ([source](https://cppguide.cn/pages/system-programming-essentials-with-go/))

### Testing & Quality Assurance

- [Special Member Function Controls](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/mocking-frameworks/protected-method-mocks/final-member-mocks/special-member-function-controls.md) — Teaches C++ special member function control using final, override, =default, and =delete. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch01/))

### User Interface & Experience

- [Per-Thread Context Executions](https://awesome-repositories.com/f/user-interface-experience/global-state-managers/per-thread-context-executions.md) — Runs the same function across multiple threads by resolving all data from per-thread context rather than shared globals. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch07/))

### Development Tools & Productivity

- [Kernel Context Rule Enforcements](https://awesome-repositories.com/f/development-tools-productivity/execution-context-management/execution-context-injectors/kernel-context-rule-enforcements.md) — Prevents actions that are invalid in a given context (e.g., blocking or allocating memory inside an interrupt) by tracking the execution context at runtime. ([source](https://cppguide.cn/pages/the-kernel-in-the-mind-ch13/))
- [Line-by-Line Execution Controls](https://awesome-repositories.com/f/development-tools-productivity/instruction-stepping-tools/line-by-line-execution-controls.md) — Advance a program line by line or instruction by instruction to observe how state changes over time. ([source](https://cppguide.cn/pages/essentialsofcppserverprogrammingch02/))
- [Kernel Module Loaders](https://awesome-repositories.com/f/development-tools-productivity/system-feature-managers/kernel-feature-managers/kernel-module-loaders.md) — Teaches loading kernel modules at runtime to add device drivers, file systems, or network stacks.
- [Compile-Time Template Selection](https://awesome-repositories.com/f/development-tools-productivity/template-extensions/template-functions/template-compilation/compile-time-template-selection.md) — Shows using if constexpr for compile-time template specialization selection, replacing SFINAE. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Non-Type Template Parameter Deduction](https://awesome-repositories.com/f/development-tools-productivity/type-safe-development-utilities/template-type-inference/non-type-template-parameter-deduction.md) — Demonstrates using auto to deduce non-type template parameters, simplifying template declarations. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))

### Game Development

- [Scalable Game Server Frameworks](https://awesome-repositories.com/f/game-development/client-server-architectures/scalable-game-server-frameworks.md) — Covers scalable game server frameworks and cluster architectures. ([source](https://balloonwj.github.io/cpp-guide-web/))

### Scientific & Mathematical Computing

- [Variadic Pack Reductions](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/mathematical-libraries-and-utilities/mathematical-libraries/expression-evaluators/expression-templates/variadic-pack-reductions.md) — Demonstrates fold expressions to apply operators over parameter packs, simplifying variadic template code. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))
- [Parallel Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/parallel-algorithms.md) — Provides tutorials on executing standard algorithms in parallel using C++ execution policies. ([source](https://cppguide.cn/pages/cpp17indetailcontents/))

### Web Development

- [Time-To-Live Expirations](https://awesome-repositories.com/f/web-development/data-fetching-caching/cache-invalidation-utilities/time-to-live-expirations.md) — Implements time-to-live (TTL) for keys using a heap data structure to automatically expire stale data. ([source](https://cppguide.cn/pages/writemyredisfromscratch01/))