The Art of Debugging with GDB, DDD, and Eclipse (Norman Matloff, Peter Jay Salzman)（Z-Library）

【One-Line Pitch】 A practical, tool-focused guide to debugging C and C-family programs with GDB, DDD, and Eclipse—teaching you to stop sprinkling print statements and start using breakpoints, watchpoints, core dumps, and thread-aware inspection. Best for students, hobbyists, and working programmers who know how to code but were never formally taught how to debug. 【Book Arc】 - **Opening (~0%–15%)**: Frames debugging as a discipline built on the "Principle of Confirmation," compares text-based vs. GUI debuggers, and walks a first hands-on session in all three tools. - **Early (~15%–35%)**: The workhorse chapters—breakpoints in every flavor (setting, listing, disabling, conditional, command lists, watchpoints) and inspecting/setting variables, including dynamic arrays and linked structures. - **Middle (~35%–55%)**: Moves into harder territory: reading core dumps and segmentation faults with just enough OS/memory background, then debugging threaded and parallel code (pthread, MPI, OpenMP) and client/server programs. - **Late (~55%–80%)**: Special topics and the wider toolbox—compiler error messages, missing libraries, Curses/GUI debugging, editors, compiler warnings, errno, strace/ltrace, static checkers, and dynamically allocated memory problems. - **Ending (~80%–100%)**: Extends the same debugger skills to other languages (Java, Perl, Python, SWIG, assembly), showing how GDB/DDD/Eclipse adapt beyond C. 【Key Takeaways】 - **Debugging is confirmation, not guesswork** (Opening): the book's core principle is that you form a hypothesis and use the tool to confirm or refute it, rather than randomly editing code. - **Breakpoints are the central skill** (Early): the text treats setting, deleting, disabling, persisting, and conditioning breakpoints as the foundation everything else builds on. - **Watchpoints catch silent state changes** (Early): when a variable is mysteriously overwritten, watching it is often faster than stepping through logic. - **Variable inspection deserves real depth** (Early): displaying structs, dynamic arrays, and tree nodes at a pause is where GDB's flexibility pays off, with DDD offering graphical views of linked data. - **Core dumps turn crashes into evidence** (Middle): understanding how core files are created—and that your shell may suppress them—lets you post-mortem a segfault instead of reproducing it. - **Concurrency changes the debugging game** (Middle): threaded and parallel programs (pthread, MPI, OpenMP) require thread-aware commands and a mental model of processes vs. threads. - **The debugger is only one tool** (Late): compiler warnings, strace/ltrace, static checkers, and memory-debugging tools complement GDB for whole classes of bugs. - **The same skills transfer across languages** (Ending): GDB, DDD, and Eclipse can be pressed into service for Java, Perl, Python, and even assembly, so the investment generalizes. 【Reading Tips】 - Beginners should read Chapter 1 and the compiler-error section (6.1) first; experienced programmers can skim Chapter 1 but should not skip its general guidelines. - Deep-read the breakpoint and variable-inspection chapters—they are the daily-use core—and practice each command in all three interfaces rather than just reading. - Treat the OS/memory background in the crash chapter as optional if you already have systems knowledge; skim it, but slow down for core-file mechanics. - If you work on threaded or parallel code, prioritize Chapter 5; otherwise it can be read later as reference. - Use the later chapters as a menu: jump to the tool or language section relevant to your current bug rather than reading linearly. 【Coverage Limits】 This guide is synthesized from stratified excerpts and the book's front matter, table of contents, and preface; it does not cover the detailed command syntax, worked examples, or code listings inside each chapter.