The map of the book

The same map as a list

1. 01 From Python to C: What Python Was Hiding Tutor Memory
   • Calls signed overflow wraparound guaranteed "because of two's complement"
   • Leaves a stale printf or scanf specifier after changing a variable's type
   • Silences a warning with a cast instead of fixing the types
2. 02 The Working Loop Tutor Memory
   • Calls a degenerate result "a safe default" (a mean of no valid readings "returns 0.0")
   • Predicts output without checking integer division or a < boundary
   • Calls a read one past the end of an array harmless because the output looks right
3. 03 Control Flow, Functions, Recursion, and Counting Operations Tutor Memory Cost
   • A close but inexact operation count read from the loop header
   • A base case that tests one value, so negative input never reaches it
   • Returning the address of a local, or "fixing" it with static
4. 04 Pointers Tutor Memory
   • Reading *p++ as incrementing the value
   • Computing an array's length with sizeof on a pointer parameter
   • Dereferencing a result documented to be NULL on failure
5. 05 Arrays, Strings, and Matrices: n, n², n³ Tutor Memory Cost
   • Pre-2011 string code: strcpy, strcat, sprintf, bare %s, strncpy as "safe"
   • Buffers sized without the terminator; <= loops; > where >= belongs
   • Matrix loops whose inner index walks down a column of a row-major array
   • Happy-path numerics: no iteration cap, overflow "detected" after it happens, no check of n
6. 06 The Stack and the Heap: Dynamic Memory and Ownership Tutor Memory Ownership
   • Freeing on the main path and not on early error returns
   • Returning a pointer to a local buffer
   • p = realloc(p, n) straight back into the only pointer
7. 07 Structs, Headers, and Multi-File Programs Tutor Memory Ownership Interfaces
   • Makefile pattern rule %.o: %.c with no header dependencies
   • Definitions in headers, or the static "fix" that gives each file a private copy
   • Saving a struct with fwrite(&rec, sizeof rec, 1, f)
8. 08 Growable Arrays and Linked Lists: The Cost of Growth Tutor Ownership Cost
   • Growth by +1 or by a constant chunk, "because realloc grows in place"
   • A grow step that never frees the old buffer
   • Losing the list head on delete (head passed by value)
9. 09 Files, Bits, and Function Pointers: ADTs Behind a Header Tutor Memory Interfaces
   • Unchecked fopen, fread, fclose; while (!feof(f))
   • Shifting a promoted byte past the width of int
   • Exposing the representation through an accessor that returns the internal array
10. 10 Complexity and Sorting: Your First Delegation Pair Cost
    • First-element pivot, with "O(n log n)" naming no case
    • Merge temporary leaked on an early return after the malloc
    • A complexity claim with no measurement; "use a random pivot" as a full guarantee
    • An unstable sort where the spec said stable
11. 11 Specify First: Abstract Data Types Pair Ownership Interfaces
    • Invented ownership ("the container takes ownership")
    • Silent behavior on error, or an assert on a normal run-time event
    • Tests that run the code without constraining it
12. 12 Moving to C++: Is It Really C++? Pair Memory Cost
    • Mixed C and C++ idioms: printf on a std::string, strcpy from c_str()
    • malloc for a type with C++ members
    • Exponential recursion where dynamic programming belongs; a memo table passed by value
13. 13 Classes, Invariants, and Operator Overloading Pair Interfaces
    • Public data, or private data behind setters and a non-const reference getter
    • Operators with surprising meaning: an operator+ that changes its left operand, an == that ignores pixels
    • Missing const observers; a constructor that skips the size check; unchecked w * h
14. 14 Resource Ownership: RAII, the Rules of Zero, Three, and Five, and Smart Pointers Pair Ownership
    • The rule of three without moves, or a move constructor without noexcept
    • Raw delete on memory a unique_ptr owns
    • shared_ptr everywhere, "the safest choice"
15. 15 Inheritance, Polymorphism, and Composition: Reviewing an Agent's Design Pair Ownership Interfaces
    • A polymorphic base without a virtual destructor
    • Slicing in containers, parameters and range-for variables
    • Inheritance for reuse where composition fits
16. 16 Templates and the Standard Library Team Cost Interfaces
    • Using an iterator, reference or pointer after the container changed
    • A string_view that outlives its owner
    • A container chosen by habit, with no reason or measurement
17. 17 Binary Search Trees Team Ownership Cost
    • A plain BST called "O(log n)" with no condition, tested only on random insert orders
    • A raw-pointer erase whose splice paths unlink a node without freeing it
    • Recursion that follows the tree, including the implicit destructor chain of unique_ptr children
18. 18 Hash Tables, Exceptions, and the Search Study Team Cost
    • A weak hash function on structured keys
    • Resizing bugs: chains kept at old indexes, references or pointers used across a resize or chain growth
    • Timing claims with no data; a harness edited by the agent; results the optimizer can delete
19. 19 Directing a Team of Agents Team Interfaces
    • A Reviewer agreeing with the Writer in the Writer's own words
    • A review of style with nothing about memory
    • A plan that counts only generation time
20. 20 A First Look at Concurrency Team Memory Ownership
    • Writes locked, reads not ("reads are harmless")
    • A lock held across slow I/O
    • wait with no predicate, or if instead of while around it
    • "It passed ten runs, so there is no race"

Which instrument catches what

Traps come from Appendix B of the book, where each row also has a column for the date and result of re-testing it against the agent you use.