Systems Programming

Data layout, linkage, and calling conventions.

1. Struct Padding and the Alignment Rule Behind sizeof
2. Integer Object Representation and Conversion at the Boundary
3. Function Call ABI: Register Assignment on x86-64
4. Linkage, Symbol Visibility, and the Weak Definition
5. Variadic Calls and the Default Argument Promotions
6. Bitfield Allocation and Packed Structures

Invariants the compiler cannot check.

1. What the Unsafe Keyword Actually Disables
2. Undefined Behaviour as a Compiler Permission
3. Pointer Provenance and the Cost of Integer Round-Trips
4. Strict Aliasing and the Cases Where Type Punning Is Legal
5. Aliasing Rules for References and the Role of UnsafeCell
6. Uninitialised Memory, Padding, and the Cost of Assuming Zero

Executables, sections, and parsing.

1. ELF Program Headers and the Mapping a Loader Performs Before _start
2. Section Headers, String Tables, and the Bookkeeping a Linker Needs
3. Relocation Entries and the Arithmetic a Linker Performs
4. The PLT and GOT Protocol That Defers Symbol Resolution
5. Mach-O Load Commands and the Segments a dyld Image Is Built From
6. PE/COFF Relative Virtual Addresses and the Import Directory

Files, sockets, and process control.

1. What a File Descriptor Is: An Index Into a Process Table
2. Readiness Notification: What select, poll, and epoll Actually Report
3. Short Counts: Why read and write Return Less Than Asked
4. fork and exec: Which Descriptors Survive and Why
5. Exit Status, Zombies, and What waitpid Can Tell a Parent
6. Signals: Delivery, Interruption, and the Async-Signal-Safe Set

Targets, sysroots, and emulation.

1. Reading a Target Triple as an ABI Contract
2. Build, Host, and Target: Three Machines in One Toolchain
3. What a Sysroot Actually Restricts in a Cross Build
4. Why a Cross Toolchain Bootstraps in a Fixed Order
5. User-Mode Emulation and binfmt_misc for Foreign Binaries
6. Floating-Point ABI Variants and the Linker Errors They Cause

Atomics, fences, and lock-free design.

1. Atomicity and Ordering Are Separate Guarantees in the C Memory Model
2. Compare-and-Swap and Why the Retry Loop Must Re-read
3. Acquire and Release: What Each Ordering Forbids
4. Cache Line Transfer, False Sharing, and the Cost of Contention
5. Spinlock Design from Test-and-Set to Ticket Locks
6. Seqlocks: Consistent Reads Without Reader-Side Writes

Ownership, leaks, and deterministic cleanup.

1. Release Order at Scope Exit and the LIFO Cleanup Rule
2. Failure Atomicity and Cleanup on the Error Path
3. Move Semantics and the State Left Behind in the Source
4. Atomic Reference Counts and the Cycle They Cannot Collect
5. Leak Detection by Reachability Rather Than Allocation Count
6. File Descriptor Lifetime, Inheritance, and Table Exhaustion

Core dumps, strace, and sanitizers.

1. What an ELF Core File Preserves of a Process
2. From Page Fault to Signal: How SIGSEGV and SIGBUS Differ
3. How strace Sees Every System Call Without Linking Into the Program
4. DWARF Line Tables and How an Address Becomes a Source Line
5. Stack Unwinding Without Frame Pointers: Call Frame Information
6. Build Identifiers and Separate Debug Information