Tours through the Book

While the chapters of this book can be read one after the other, there are many possible paths through the book. In this graph, an arrow AB means that chapter A is a prerequisite for chapter B. You can pick arbitrary paths in this graph to get to the topics that interest you most:

In [1]:
# ignore
from bookutils import rich_output
In [2]:
# ignore
if rich_output():
    from IPython.display import SVG
    sitemap = SVG(filename='PICS/Sitemap.svg')
else:
    sitemap = None
sitemap
Out[2]:
Tracer Tracing Executions Debugger How Debuggers Work Tracer->Debugger Assertions Asserting Expectations Tracer->Assertions DeltaDebugger Reducing Failure- Inducing Inputs Tracer->DeltaDebugger StatisticalDebugger Statistical Debugging Tracer->StatisticalDebugger DynamicInvariants Mining Function Specifications Tracer->DynamicInvariants ChangeDebugger Isolating Failure- Inducing Changes DeltaDebugger->ChangeDebugger DDSetDebugger Generalizing Failure Circumstances DeltaDebugger->DDSetDebugger PerformanceDebugger Debugging Performance Issues DeltaDebugger->PerformanceDebugger Repairer Repairing Code Automatically DeltaDebugger->Repairer StatisticalDebugger->PerformanceDebugger StatisticalDebugger->Repairer Intro_Debugging Introduction to Debugging Intro_Debugging->Tracer Slicer Tracking Failure Origins Intro_Debugging->Slicer Tracking Tracking Bugs Intro_Debugging->Tracking ChangeCounter Where the Bugs are Tracking->ChangeCounter

But since even this map can be overwhelming, here are a few tours to get you started. Each of these tours allows you to focus on a particular view, depending on whether you are a programmer, student, or researcher.

The Pragmatic Programmer Tour

You have a program to debug. You want to learn about techniques that help you for debugging. You want to get to the point.

  1. Start with Introduction to Debugging to get the basic concepts. (You would know most of these anyway, but it can't hurt to get quick reminders).

  2. Experiment with interactive debuggers to observe executions interactively.

  3. Use assertions to have the computer systematically run checks during execution.

  4. Explore delta debugging for your program and see how it simplifies failure-inducing inputs and changes.

  5. Visualize dependencies in your program and track the flow of data and control in the execution.

  6. Check out statistical debugging for a simple way to determine code locations associated with failures.

  7. See automatic repairs in action.

In each of these chapters, start with the "Synopsis" parts; these will give you quick introductions on how to use things, as well as point you to relevant usage examples. With this, enough said. Get back to work and enjoy!

The Young Researcher Tour

Your school wants you to publish a great paper every few months. You are looking for infrastructures that you can toy with, helping you to build and evaluate cool ideas.

  1. Toy with tracer to collect data on program executions - features you can then correlate with program failures.

  2. Extract dependencies from your program and use them for runtime verification, fault localization, and better repair.

  3. Use automatic repairs as a starting point to build your own, better repairs. The Python implementation is well documented and extremely easy to expand.

  4. Bring in test generation and structured inputs to collect input features that relate to failures.

  5. Mine version and bug repositories to explore how bugs and all these features evolve over time.

For each of these chapters, experiment with the techniques, and then build your own on top. Read the relevant papers to learn more about their motivation and background. And now go and improve the world of automated debugging!

Lessons Learned

  • You can go through the book from beginning to end...
  • ...but it may be preferable to follow a specific tour, based on your needs and resources.
  • Now go and explore automated debugging!