A Guide to Systematic Debugging
E-Book, Englisch, 425 Seiten, Format (B × H): 191 mm x 235 mm
ISBN: 978-0-08-092300-0
Verlag: Morgan Kaufmann
Format: EPUB
Kopierschutz: 6 - ePub Watermark
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.
Zielgruppe
Computer programmers, software developers, analysts and testers
Autoren/Hrsg.
Fachgebiete
Weitere Infos & Material
Amended Table of Contents
The * denotes additions/changes for the proposed second edition. For brevity, second-level sections are omitted from the list. Please note that there are also recurring end-of-chapter sections: Concepts, Tools, Further Reading, and Exercises.
Table of Contents
* Include a list of "How To's" as indicated in appropriate chapters
About the Author
Preface
* What's new in the second edition
1 How Failures Come to Be
1.1 My Program Does Not Work!
* New section "Facts on Bugs" - highlighting recent empirical findings
1.2 From Defects to Failures
1.3 Lost in Time and Space
1.4 From Failures to Fixes
1.5 Automated Debugging Techniques
1.6 Bugs, Faults, or Defects?
* New section "Learning From Mistakes" - pointing to the later chapter
2 Tracking Problems
2.1 Oh! All These Problems
2.2 Reporting Problems
2.3 Managing Problems
2.4 Classifying Problems
2.5 Processing Problems
2.6 Managing Problem Tracking
2.7 Requirements as Problems
2.8 Managing Duplicates
* New section "Collecting Problem Data" - laying the foundation for later investigation
2.9 Relating Problems and Fixes
2.10 Relating Problems and Tests
* 2.9 and 2.10 will be merged into a new section "A Concert of Activities", focusing on integrated environments like Jazz.net
3 Making Programs Fail
3.1 Testing for Debugging
3.2 Controlling the Program
3.3 Testing at the Presentation Layer
3.4 Testing at the Functionality Layer
3.5 Testing at the Unit Layer
3.6 Isolating Units
3.7 Designing for Debugging
* Expand on "design for diagnosability", esp. for embedded systems
3.8 Preventing Unknown Problems
* This section will be deleted and replaced with a whole new chapter 18
4 Reproducing Problems
4.1 The First Task in Debugging
4.2 Reproducing the Problem Environment
4.3 Reproducing Program Execution
4.4 Reproducing System Interaction
4.5 Focusing on Units
* Expand reflecting latest research results
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
6 Scientific Debugging
6.1 How to Become a Debugging Guru
6.2 The Scientific Method
6.3 Applying the Scientific Method
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.9 Reasoning About Programs
7 Deducing Errors
* This chapter will be renamed to "Tracking Dependences"
7.1 Isolating Value Origins
7.2 Understanding Control Flow
7.3 Tracking Dependences
7.4 Slicing Programs
7.5 Deducing Code Smells
* Move to new chapter 11 "Verifying Code"
7.6 Limits of Static Analysis
* Move to new chapter 11 "Verifying Code"
8 Observing Facts
8.1 Observing State
8.2 Logging Execution
8.3 Using Debuggers
8.4 Querying Events
8.5 Visualizing State
9 Tracking Origins
9.1 Reasoning Backwards
* Update with recent commercial tools
9.2 Exploring Execution History
9.3 Dynamic Slicing
9.4 Leveraging Origins
* Expand to use latest tools by Ko et al. as well as Gupta et al.
9.5 Tracking Down Infections
10 Asserting Expectations
10.1 Automating Observation
10.2 Basic Assertions
* Explain "design by contract" and its principles
10.3 Asserting Invariants
* Expand on integrating contracts with inheritance
10.4 Asserting Correctness
10.5 Assertions as Specifications
10.6 From Assertions to Verification
* Move to its own chapter "Verifying Code"
10.7 Reference Runs
* Move to "Verifying Code"
10.8 System Assertions
10.9 Checking Production Code
* Expand discussion; consider checking preconditions only
* New Chapter 11 Verifying Code, Why does my Code smell?
* Highlight tools like FindBUGS
* Defects as Abnormal Behavior
* Discuss work by Engler et al.
Ass
