Book description

The rules of battle for tracking down -- and eliminating -- hardware and software bugs.

When the pressure is on to root out an elusive software or hardware glitch, what's needed is a cool head courtesy of a set of rules guaranteed to work on any system, in any circumstance. Written in a frank but engaging style, Debugging provides simple, foolproof principles guaranteed to help find any bug quickly. This book makes those shelves of application-specific debugging books (on C++, Perl, Java, etc.) obsolete. It changes the way readers think about debugging, making those pesky problems suddenly much easier to find and fix.

Illustrating the rules with real-life bug-detection war stories, the book shows readers how to:

* Understand the system: how perceiving the ""roadmap"" can hasten your journey

* Quit thinking and look: when hands-on investigation can't be avoided

* Isolate critical factors: why changing one element at a time can be an essential tool

* Keep an audit trail: how keeping a record of the debugging process can win the day

Table of contents

  1. Cover
  2. Title
  3. Copyright
  4. Contents
  5. Acknowledgments
  6. Chapter 1: Introduction
    1. How Can That Work?
    2. Isn’t It Obvious?
    3. Anyone Can Use It
    4. It’ll Debug Anything
    5. But It Won’t Prevent, Certify, or Triage Anything
    6. More Than Just Troubleshooting
    7. A Word About War Stories
    8. Stay Tuned
  7. Chapter 2: The Rules—Suitable for Framing
  8. Chapter 3: Understand the System
    1. Read the Manual
    2. Read Everything, Cover to Cover
    3. Know What’s Reasonable
    4. Know the Road Map
    5. Know Your Tools
    6. Look It Up
    7. Remember
      1. Understand the System
  9. Chapter 4: Make It Fail
    1. Do It Again
    2. Start at the Beginning
    3. Stimulate the Failure
    4. Don’t Simulate the Failure
    5. What If It’s Intermittent?
    6. What if I’ve Tried Everything and It’s Still Intermittent?
      1. A Hard Look at Bad Luck
      2. Lies, Damn Lies, and Statistics
      3. Did You Fix It, or Did You Get Lucky?
    7. “But That Can’t Happen”
    8. Never Throw Away a Debugging Tool
    9. Remember
      1. Make It Fail
  10. Chapter 5: Quit Thinking and Look
    1. See the Failure
    2. See the Details
    3. Now You See It, Now You Don’t
    4. Instrument the System
      1. Design Instrumentation In
      2. Build Instrumentation In Later
      3. Don’t Be Afraid to Dive In
      4. Add Instrumentation On
      5. Instrumentation in Daily Life
    5. The Heisenberg Uncertainty Principle
    6. Guess Only to Focus the Search
    7. Remember
      1. Quit Thinking and Look
  11. Chapter 6: Divide and Conquer
    1. Narrow the Search
      1. In the Ballpark
      2. Which Side Are You On?
    2. Inject Easy-to-Spot Patterns
    3. Start with the Bad
    4. Fix the Bugs You Know About
    5. Fix the Noise First
    6. Remember
      1. Divide and Conquer
  12. Chapter 7: Change One Thing at a Time
    1. Use a Rifle, Not a Shotgun
    2. Grab the Brass Bar with Both Hands
    3. Change One Test at a Time
    4. Compare with a Good One
    5. What Did You Change Since the Last Time It Worked?
    6. Remember
      1. Change One Thing at a Time
  13. Chapter 8: Keep an Audit Trail
    1. Write Down What You Did, in What Order, and What Happened 99
    2. The Devil Is in the Details
    3. Correlate
    4. Audit Trails for Design Are Also Good for Testing
    5. The Shortest Pencil Is Longer Than the Longest Memory
    6. Remember
      1. Keep an Audit Trail
  14. Chapter 9: Check the Plug
    1. Question Your Assumptions
    2. Don’t Start at Square Three
    3. Test the Tool
    4. Remember
      1. Check the Plug
  15. Chapter 10: Get a Fresh View
    1. Ask for Help
      1. A Breath of Fresh Insight
      2. Ask an Expert
      3. The Voice of Experience
    2. Where to Get Help
    3. Don’t Be Proud
    4. Report Symptoms, Not Theories
      1. You Don’t Have to Be Sure
    5. Remember
      1. Get a Fresh View
  16. Chapter 11: If You Didn’t Fix It, It Ain’t Fixed
    1. Check That It’s Really Fixed
    2. Check That It’s Really Your Fix That Fixed It
    3. It Never Just Goes Away by Itself
    4. Fix the Cause
    5. Fix the Process
    6. Remember
      1. If You Didn’t Fix It, It Ain’t Fixed
  17. Chapter 12: All the Rules in One Story
  18. Chapter 13: Easy Exercises for the Reader
    1. A Light Vacuuming Job
    2. A Flock of Bugs
    3. A Loose Restriction
    4. The Jig Is Up
  19. Chapter 14: The View from the Help Desk
    1. Help Desk Constraints
    2. The Rules, Help Desk Style
      1. Understand the System
      2. Make It Fail
      3. Quit Thinking and Look
      4. Divide and Conquer
      5. Change One Thing at a Time
      6. Keep an Audit Trail
      7. Check the Plug
      8. Get a Fresh View
      9. If You Didn’t Fix It, It Ain’t Fixed
    3. Remember
      1. The View from the Help Desk Is Murky
  20. Chapter 15: The Bottom Line
    1. The Debugging Rules Web Site
    2. If You’re an Engineer
    3. If You’re a Manager
    4. If You’re a Teacher
    5. Remember
  21. Index
  22. Author

Product information

  • Title: Debugging
  • Author(s): David J. Agans
  • Release date: September 2002
  • Publisher(s): AMACOM
  • ISBN: 9780814426784