What to Learn Next & Final Checklist

Where to go after this course, and a checklist to confirm you have mastered every topic.

Glossary

Application binary interface: calling convention, type layout, symbol rules shared by binaries

A CAS succeeds because a value changed and changed back The range of virtual addresses a process can use AddressSanitizer (ASan)

Compiler instrumentation detecting out-of-bounds, use-after-free, double free and leaks

Required or preferred address multiple for a type Array of structures / structure of arrays

Allocator that frees all of its allocations at once Address-space layout randomization

Indivisible operation with defined concurrent semantics Big-endian / little-endian

Most / least significant byte stored first Code that starts (and updates) the main firmware or OS

Section for zero-initialised static data Unit of cache transfer, 64 bytes on most CPUs

Capability hardware with bounded, unforgeable pointers Hardware keeping copies of a line consistent across caches

Saving one thread's CPU state and restoring another's Sharing pages until one side writes, then copying

Saved memory and registers of a crashed process Section for initialised static data

Unsynchronised conflicting accesses; UB in C/C++ Mapping pages only when first touched

Direct memory access by a device without the CPU Program that maps shared libraries and binds symbols at run time ELF / PE / Mach-O

Executable formats of Linux, Windows and Apple systems Byte order of multi-byte values

Freeing retired objects once all threads passed an epoch Independent data in one cache line causing coherence traffic Non-volatile, block-erasable memory

Wasted memory inside blocks (internal) or between them (external) Page-sized block of physical memory Per-call record on the stack

Automatic reclamation of unreachable objects Address table / call stubs for external symbols

Inaccessible page that turns overruns into faults Ordering relation that makes one thread's writes visible to another

Published pointer that prevents reclamation of an object in use

Memory managed by an allocator for dynamically allocated objects Peak usage observed

Large (2 MiB/1 GiB) page reducing TLB pressure Asynchronous event that diverts the CPU to a handler

Intermediate representation used by compilers Instruction set architecture Interrupt service routine Compile while running / before running KiB / MiB / GiB 2¹⁰ / 2²⁰ / 2³⁰ bytes

Allocated memory that is no longer reachable and never freed

Whether a name refers to the same entity across translation units

File describing how sections are placed in memory Load address / run address of a section

Linker report of every section and symbol Memory barrier / fence

Instruction enforcing ordering of memory operations Cache-coherence protocol: Modified, Exclusive, Shared, Invalid Memory-mapped I/O

Memory management unit (translation) / memory protection unit (regions)

Main / process stack pointer on Cortex-M Arm memory tagging / pointer authentication Non-uniform memory access

No-execute bit / never writable and executable together Region of storage holding a value

Linux mechanism that kills a process when memory is exhausted

Promising more virtual memory than can be backed Responsibility for freeing a resource Bytes inserted to satisfy alignment Page / page table / PTE

Virtual memory block / mapping structure / one entry Exception when a translation is missing or not permitted Position-independent code / executable

Allocator of fixed-size blocks from a pre-allocated region Process / thread

Running program with an address space / execution path within it

Register holding the next instruction's address The object a pointer was derived from

Resource lifetime bound to object lifetime Read-copy-update reclamation scheme

Safe to enter again before a previous call finished Freeing objects when their reference count reaches zero

Patching an address once the final layout is known Making relocated data read-only after start-up Section for read-only data RSS / VSZ / PSS

Resident / virtual / proportional set size Run-time checking instrumentation (ASan, UBSan, TSan, MSan, LSan)

Library mapped at run time and shared between processes Asynchronous notification to a POSIX process

Cache of same-sized objects carved from pages Run-time name of a shared library, including its major version Per-thread memory for call frames

Random value checked before return to detect stack smashing Lifetime class: automatic, static, allocated, thread

Rule restricting the types through which an object may be accessed

Named function or variable in an object file Controlled entry into the kernel Section for machine code One instance of a variable per thread

Cache of virtual-to-physical translations Time-of-check to time-of-use race Two's complement

Signed integer representation with a negative-weight top bit

Undefined behavior: no requirements imposed by the language Variable-length Unicode encoding (1–4 bytes per code point)

Address used by instructions, translated by the MMU C/C++ qualifier: every access is performed (not a thread-safety tool)

Pages actively used during a time window

Resources and Further Reading

Randal Bryant & David O'Hallaron, *Computer Systems: A Programmer's Perspective*, 3rd ed.

Remzi & Andrea Arpaci-Dusseau, *Operating Systems: Three Easy Pieces* (free online).

David Patterson & John Hennessy, *Computer Organization and Design* (RISC-V edition); *Computer Architecture: A Quantitative Approach*.

Michael Kerrisk, *The Linux Programming Interface*.

John R. Levine, *Linkers and Loaders*.

Anthony Williams, *C++ Concurrency in Action*.

Richard Jones et al., *The Garbage Collection Handbook*.

Joseph Yiu, *The Definitive Guide to Arm Cortex-M3 and Cortex-M4 Processors*.

Papers and articles Ulrich Drepper, "What Every Programmer Should Know About Memory" and "How To Write Shared Libraries".

David Goldberg, "What Every Computer Scientist Should Know About Floating-Point Arithmetic".

Hans Boehm, "Threads Cannot Be Implemented as a Library".

Paul Wilson et al., "Dynamic Storage Allocation: A Survey and Critical Review".

Standards and references ISO/IEC 9899 (C) and 14882 (C++) — cppreference.com as a practical reference.

System V ABI (AMD64, AArch64, RISC-V psABI); Microsoft x64 ABI documentation.

SEI CERT C Coding Standard; MISRA C guidelines (overview).

Arm Architecture Reference Manuals; Intel and AMD software developer manuals; the RISC-V specifications.

Compiler Explorer (godbolt.org); Google Sanitizers; Valgrind; GDB/LLDB; perf; heaptrack; Tracealyzer/SystemView for RTOS trace.

Final Checklist

Use this list to confirm you have mastered the course. You should be able to:

[ ] Convert between binary, decimal and hexadecimal and explain endianness, two's complement and IEEE 754.

[ ] Follow a C file through preprocessing, compilation, assembly, linking and loading, and inspect every stage.

[ ] Draw a process address space and place any variable in it.

[ ] State the scope, linkage and storage duration of any declaration.

[ ] Trace stack frames through calls, returns, recursion and exceptions.

[ ] Use malloc/realloc/free safely, design an ownership scheme and write a pool allocator.

[ ] Reason precisely about pointers, arrays, struct layout and aliasing.

[ ] Build and parse buffers safely and serialise data portably.

[ ] Recognise every major memory-bug class and catch it with the right tool.

[ ] Explain processes, system calls, fork/exec, signals and IPC.

[ ] Read compiler-generated assembly for x86-64, AArch64 and RISC-V.

[ ] Translate virtual addresses and explain page faults, demand paging and overcommit.

[ ] Predict cache behavior of access patterns and fix false sharing.

[ ] Write correct multithreaded code with mutexes, condition variables and atomics.

[ ] Explain the memory model of C, C++, Java, C#, JavaScript, Python and Rust.

[ ] Write start-up code and a linker script for a microcontroller and budget its memory.

[ ] Build static and shared libraries and keep an ABI stable.

[ ] Debug and profile with debuggers, sanitizers, analysers and profilers, and write a regression test for every fix.

[ ] Discuss NUMA, coherence, GC algorithms, safe reclamation and hardware memory safety.

[ ] Complete at least one capstone project assessed against the rubric.