Front Cover -- Title Page -- Copyright Page -- Table of Contents -- Foreword -- Preface -- Chapter 1. How Failures Come to Be -- 1.1 My Program Does Not Work! -- 1.2 From Defects to Failures -- 1.3 Lost in Time and Space -- 1.4 From Failures to Fixes -- 1.4.1 Track the Problem -- 1.4.2 Reproduce the Failure -- 1.4.3 Automate and Simplify the Test Case -- 1.4.4 Find Possible Infection Origins -- 1.4.5 Focus on the Most Likely Origins -- 1.4.6 Isolate the Origin of the Infection -- 1.4.7 Correct the Defect -- 1.5 Automated Debugging Techniques -- 1.6 Bugs, Faults, or Defects? -- 1.7 Concepts -- How to debug a program -- 1.8 Tools -- 1.9 Further Reading -- Exercises -- Chapter 2. Tracking Problems -- 2.1 Oh! All These Problems -- 2.2 Reporting Problems -- 2.2.1 Problem Facts -- 2.2.2 Product Facts -- 2.2.3 Querying Facts Automatically -- 2.3 Managing Problems -- 2.4 Classifying Problems -- 2.4.1 Severity -- 2.4.2 Priority -- 2.4.3 Identifier -- 2.4.4 Comments -- 2.4.5 Notification -- 2.5 Processing Problems -- 2.6 Managing Problem Tracking -- 2.7 Requirements as Problems -- 2.8 Managing Duplicates -- 2.9 Relating Problems and Fixes -- 2.10 Relating Problems and Tests -- 2.11 Concepts -- How to obtain the relevant problem information -- How to write an effective problem report -- How to organize the debugging process -- How to track requirements -- How to keep problem tracking simple -- How to restore released versions -- How to separate fixes and features -- How to relate problems and fixes -- How to relate problems and tests, make a problem report obsolete -- 2.12 Tools -- 2.13 Further Reading -- Exercises -- Chapter 3. Making Programs Fail -- 3.1 Testing for Debugging -- 3.2 Controlling the Program -- 3.3 Testing at the Presentation Layer -- 3.3.1 Low-Level Interaction -- 3.3.2 System-Level Interaction -- 3.3.3 Higher-Level Interaction.

3.3.4 Assessing Test Results -- 3.4 Testing at the Functionality Layer -- 3.5 Testing at the Unit Layer -- 3.6 Isolating Units -- 3.7 Designing for Debugging -- 3.8 Preventing Unknown Problems -- 3.9 Concepts -- How to test for debugging -- How to automate program execution -- How to test at the presentation layer -- How to test at the functionality layer -- How to test at the unit layer -- How to isolate a unit -- How to design for debugging -- How to prevent unknown problems -- 3.10 Tools -- 3.11 Further Reading -- Exercises -- Chapter 4. Reproducing Problems -- 4.1 The First Task in Debugging -- 4.2 Reproducing the Problem Environment -- 4.3 Reproducing Program Execution -- 4.3.1 Reproducing Data -- 4.3.2 Reproducing User Interaction -- 4.3.3 Reproducing Communications -- 4.3.4 Reproducing Time -- 4.3.5 Reproducing Randomness -- 4.3.6 Reproducing Operating Environments -- 4.3.7 Reproducing Schedules -- 4.3.8 Physical Influences -- 4.3.9 Effects of Debugging Tools -- 4.4 Reproducing System Interaction -- 4.5 Focusing on Units -- 4.5.1 Setting Up a Control Layer -- 4.5.2 A Control Example -- 4.5.3 Mock Objects -- 4.5.4 Controlling More Unit Interaction -- 4.6 Reproducing Crashes -- 4.7 Concepts -- How to reproduce the problem -- How to reproduce the problem environment -- How to reproduce the problem execution -- How to reproduce unit behavior -- How to Mock objects -- How to reproduce a crash -- 4.8 Tools -- 4.9 Further Reading -- Exercises -- Chapter 5. Simplifying Problems -- 5.1 Simplifying the Problem -- 5.2 The Gecko BugAThon -- 5.3 Manual Simplification -- 5.4 Automatic Simplification -- 5.5 A Simplification Algorithm -- 5.6 Simplifying User Interaction -- 5.7 Random Input Simplified -- 5.8 Simplifying Faster -- 5.8.1 Caching -- 5.8.2 Stop Early -- 5.8.3 Syntactic Simplification -- 5.8.4 Isolate Differences, Not Circumstances -- 5.9 Concepts.

How to simplify a test case -- How to automate simplification -- How to speed up automatic simplification -- 5.10 Tools -- 5.11 Further Reading -- Exercises -- Chapter 6. Scientific Debugging -- 6.1 How to Become a Debugging Guru -- 6.2 The Scientific Method -- 6.3 Applying the Scientific Method -- 6.3.1 Debugging sample-Preparation -- 6.3.2 Debugging sample-Hypothesis 1 -- 6.3.3 Debugging sample-Hypothesis 2 -- 6.3.4 Debugging sample-Hypothesis 3 -- 6.3.5 Debugging sample-Hypothesis 4 -- 6.4 Explicit Debugging -- 6.5 Keeping a Logbook -- 6.6 Debugging Quick-and-Dirty -- 6.7 Algorithmic Debugging -- 6.8 Deriving a Hypothesis -- 6.8.1 The Description of the Problem -- 6.8.2 The Program Code -- 6.8.3 The Failing Run -- 6.8.4 Alternate Runs -- 6.8.5 Earlier Hypotheses -- 6.9 Reasoning about Programs -- 6.10 Concepts -- How to isolate a failure cause -- How to understand the problem at hand -- How to avoid endless debugging sessions -- How to locate an error in a functional or logical program -- How to debug quick-and-dirty -- How to derive a hypothesis -- How to reason about programs -- 6.11 Further Reading -- Exercises -- Chapter 7. Deducing Errors -- 7.1 Isolating Value Origins -- 7.2 Understanding Control Flow -- 7.3 Tracking Dependences -- 7.3.1 Effects of Statements -- 7.3.2 Affected Statements -- 7.3.3 Statement Dependences -- 7.3.4 Following Dependences -- 7.3.5 Leveraging Dependences -- 7.4 Slicing Programs -- 7.4.1 Forward Slices -- 7.4.2 Backward Slices -- 7.4.3 Slice Operations -- 7.4.4 Leveraging Slices -- 7.4.5 Executable Slices -- 7.5 Deducing Code Smells -- 7.5.1 Reading Uninitialized Variables -- 7.5.2 Unused Values -- 7.5.3 Unreachable Code -- 7.6 Limits of Static Analysis -- 7.7 Concepts -- How to isolate value origins -- How to slice a program -- 7.8 Tools -- 7.9 Further Reading -- Exercises -- Chapter 8. Observing Facts.

8.1 Observing State -- 8.2 Logging Execution -- 8.2.1 Logging Functions -- 8.2.2 Logging Frameworks -- 8.2.3 Logging with Aspects -- 8.2.4 Logging at the Binary Level -- 8.3 Using Debuggers -- 8.3.1 A Debugging Session -- 8.3.2 Controlling Execution -- 8.3.3 Postmortem Debugging -- 8.3.4 Logging Data -- 8.3.5 Invoking Functions -- 8.3.6 Fix and Continue -- 8.3.7 Embedded Debuggers -- 8.3.8 Debugger Caveats -- 8.4 Querying Events -- 8.4.1 Watchpoints -- 8.4.2 Uniform Event Queries -- 8.5 Hooking into the Interpreter -- 8.6 Visualizing State -- 8.7 Concepts -- How to observe state -- How to encapsulate and reuse debugging code -- How to observe the final state of a crashing program -- How to automate observation -- 8.8 Tools -- 8.9 Further Reading -- Exercises -- Chapter 9. Tracking Origins -- 9.1 Reasoning Backward -- 9.2 Exploring Execution History -- 9.3 Dynamic Slicing -- 9.4 Leveraging Origins -- 9.5 Tracking Down Infections -- 9.6 Concepts -- How to explore execution history -- How to isolate value origins for a specific run -- How to track down an infection -- 9.7 Tools -- 9.8 Further Reading -- Exercises -- Chapter 10. Asserting Expectations -- 10.1 Automating Observation -- 10.2 Basic Assertions -- 10.3 Asserting Invariants -- 10.4 Asserting Correctness -- 10.5 Assertions as Specifications -- 10.6 From Assertions to Verification -- 10.7 Reference Runs -- 10.8 System Assertions -- 10.8.1 Validating the Heap with MALLOC_CHECK_ -- 10.8.2 Avoiding Buffer Overflows with ELECTRICFENCE -- 10.8.3 Detecting Memory Errors with VALGRIND -- 10.8.4 Language Extensions -- 10.9 Checking Production Code -- 10.10 Concepts -- How to automate observation -- How to use assertions -- How to check a program against a reference program -- How to check memory integrity -- How to prevent memory errors in a low-level language -- 10.11 Tools -- 10.12 Further Reading.

Exercises -- Chapter 11. Detecting Anomalies -- 11.1 Capturing Normal Behavior -- 11.2 Comparing Coverage -- 11.3 Statistical Debugging -- 11.4 Collecting Data in the Field -- 11.5 Dynamic Invariants -- 11.6 Invariants On-the-Fly -- 11.7 From Anomalies to Defects -- 11.8 Concepts -- How to determine abnormal behavior -- How to summarize behavior -- How to detect anomalies -- How to compare coverage -- How to sample return values -- How to collect data from the field -- How to determine invariants -- 11.9 Tools -- 11.10 Further Reading -- Exercises -- Chapter 12. Causes and Effects -- 12.1 Causes and Alternate Worlds -- 12.2 Verifying Causes -- 12.3 Causality in Practice -- 12.4 Finding Actual Causes -- 12.5 Narrowing Down Causes -- 12.6 A Narrowing Example -- 12.7 The Common Context -- 12.8 Causes in Debugging -- 12.9 Concepts -- How to show causality -- How to find a cause -- How to find an actual cause -- 12.10 Further Reading -- Exercises -- Chapter 13. Isolating Failure Causes -- 13.1 Isolating Causes Automatically -- 13.2 Isolating versus Simplifying -- 13.3 An Isolation Algorithm -- 13.4 Implementing Isolation -- 13.5 Isolating Failure-Inducing Input -- 13.6 Isolating Failure-Inducing Schedules -- 13.7 Isolating Failure-Inducing Changes -- 13.8 Problems and Limitations -- 13.9 Concepts -- How to isolate a failure cause in the input -- How to isolate a failure cause in the thread schedule -- How to isolate a failure-inducing code change -- 13.10 Tools -- 13.11 Further Reading -- Exercises -- Chapter 14. Isolating Cause-Effect Chains -- 14.1 Useless Causes -- 14.2 Capturing Program States -- 14.3 Comparing Program States -- 14.4 Isolating Relevant Program States -- 14.5 Isolating Cause-Effect Chains -- 14.6 Isolating Failure-Inducing Code -- 14.7 Issues and Risks -- 14.8 Concepts.

How to understand how a failure cause propagates through the program run.

This book is proof that debugging has graduated from a black art to a systematic discipline. It demystifies one of the toughest aspects of software programming, showing clearly how to discover what caused software failures, and fix them with minimal muss and fuss. The fully updated second edition includes 100+ pages of new material, including new chapters on Verifying Code, Predicting Erors, and Preventing Errors. Cutting-edge tools such as FindBUGS and AGITAR are explained, techniques from integrated environments like Jazz.net are highlighted, and all-new demos with ESC/Java and Spec#, Eclipse and Mozilla are included. This complete and pragmatic overview of debugging is authored by Andreas Zeller, the talented researcher who developed the GNU Data Display Debugger(DDD), a tool that over 250,000 professionals use to visualize the data structures of programs while they are running. Unlike other books on debugging, Zeller's text is product agnostic, appropriate for all programming languages and skill levels. The book explains best practices ranging from systematically tracking error reports, to observing symptoms, reproducing errors, and correcting defects. It covers a wide range of tools and techniques from hands-on observation to fully automated diagnoses, and also explores the author's innovative techniques for isolating minimal input to reproduce an error and for tracking cause and effect through a program. It even includes instructions on how to create automated debugging tools. The text includes exercises and extensive references for further study, and a companion website with source code for all examples and additional debugging resources is available. *The new edition of this award-winning productivity-booster is for any developer who has ever been frustrated by elusive bugs *Brand new chapters demonstrate cutting-edge debugging techniques

and tools, enabling readers to put the latest time-saving developments to work for them *Learn by doing. New exercises and detailed examples focus on emerging tools, languages and environments, including AGITAR, FindBUGS, Python and Eclipse.

Description based on publisher supplied metadata and other sources.

Electronic reproduction. Ann Arbor, Michigan : ProQuest Ebook Central, 2021. Available via World Wide Web. Access may be limited to ProQuest Ebook Central affiliated libraries.