THE BOOK OF DEBUGGING A Systematic Workflow for Finding and Fixing Bugs (Johannes Kuhlmann)（Z-Library）

【One-Line Pitch】 A practical field manual for developers who are tired of guessing at bugs: it turns debugging from intuition and luck into a repeatable, staged workflow. Best for working programmers, especially those facing intermittent, multithreaded, or hard-to-reproduce defects. 【Book Arc】 - **Opening (~0%–10%)**: Frames debugging as a discipline rather than a talent, defines what a bug is, and warns that stress, time pressure, and unrealistic expectations are part of the job. Introduces the book's four-part workflow (understand, reproduce, examine, fix). - **Early (~10%–32%)**: Covers the groundwork — writing and reading bug reports, separating mandatory from optional information, reproducing reliably, and optimizing build/deploy/load times so iteration is fast enough to investigate. Also begins cataloguing bug classes such as wrong timing/order, unclear requirements, and shared low-level dependencies. - **Middle (~32%–48%)**: Moves into examination techniques: using debuggers, breakpoints, exception handling, assertions, and logging. Emphasizes that any code change made to observe a bug can alter it, and that assumptions must be questioned. - **Late (~48%–70%)**: (Excerpts do not cover this range in detail.) Based on the stated structure, this stage corresponds to deeper examination strategies — minimal reproductions, external tools, code analysis, and bisecting changes across versions and commits. - **Ending (~70%–100%)**: (Excerpts do not cover this range.) The book's Part IV addresses fixing: deciding between urgent patches and sustainable fixes, and choosing among clean solutions, hacky workarounds, reimplementation, disabling functionality, or living with the bug. 【Key Takeaways】 - **Debugging is a workflow, not a talent** (Opening): The author's core argument is that systematic steps and strategies beat intuition when bugs resist obvious approaches. This reframing is the book's foundation. - **Manage expectations before you manage the bug** (Opening): Debugging has high cognitive load and unpredictable timelines; under-promise, protect focus time, and step away when stuck rather than grinding. - **Reproduction is the pivot point** (Early): Confirming a bug exists, is not intentional behavior, and can be triggered on demand separates real defects from misunderstandings and user error. - **Fast iteration is a debugging prerequisite** (Early): Build times, deployment, shader compilation, and data loading all directly limit how many experiments you can run; optimizing them is debugging work, not a distraction. - **Bug classes have recognizable signatures** (Early): Timing/order errors, unclear requirements, shared foundational dependencies (schedulers, RNGs, file access), and input-handling paradigms each point to specific places to look. - **Observation changes the system** (Middle): Adding logging, assertions, or breakpoints can make a bug vanish or mutate it — a real hazard, illustrated by a team that shipped with log statements that accidentally masked a timing bug. - **Know when to abandon a shortcut** (Early/Middle): The author suggests a rough ceiling of about an hour on guesswork before switching to slower but more reliable strategies. - **Bisection beats brute force** (Middle): Narrowing a bug to a commit using binary builds, then source builds, then isolating a single file or asset, is presented as a high-leverage technique. 【Reading Tips】 - Read the workflow chapters (Parts I–II) closely and treat them as a checklist; skim the tool-specific passages if you already know your debugger well. - Pay attention to the "In Practice" sidebars — they carry the most concrete, memorable lessons, including cautionary tales. - The build/deploy/load optimization material is easy to skip but valuable if your iteration cycle is slow; read it when that pain is real. - Keep the bug-class taxonomy handy as a diagnostic index: when stuck, match your symptom to a category and follow the suggested places to look. - Treat the fix chapter as decision guidance rather than code recipes — the value is in choosing the right response under time pressure. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book; the later examination strategies and the entire fixing stage are described only from the book's stated structure, not from detailed excerpt content. Specific examples, code snippets, and chapter titles beyond those referenced are not covered.