Index¶

A - E¶

A¶

• a chapter with the same name in The Fuzzing Book — Mining Function Specifications
• A Python implementation of grammar-based input reduction — Reducing Failure-Inducing Inputs (Background)
• a similar chapter in "The Fuzzing Book" — Reducing Failure-Inducing Inputs
• abstract failure-inducing inputs — Generalizing Failure Circumstances (A Failing Program)
• abstract syntax tree — Tracing Executions (Exercise 2: Syntax-Based Instrumentation), Reducing Failure-Inducing Inputs (Reducing Syntax Trees)
• actual <assert.h> header file — Asserting Expectations (Assertion Diagnostics)
• Address Sanitizer](http://clang.llvm.org/docs/AddressSanitizer.html) discussed in this chapter was developed at Google; the [paper by Serebryany — Asserting Expectations (Background)
• add_call() — Mining Function Specifications (Tracing Calls)
• add_collector() — Statistical Debugging (A Base Class for Statistical Debugging)
• add_conditions() — Repairing Code Automatically (Collecting Conditions)
• add_definition() — Repairing Code Automatically ((Re)defining Functions)defining-Functions)
• add_dependencies() — Tracking Failure Origins (Setting Variables)
• add_hierarchy() — Tracking Failure Origins (Drawing Dependencies)
• add_items_to_ignore() — Statistical Debugging (Error Prevention)
• _add_new_data() — Learning from Failures (The Alhazen Class)
• add_statements() — Repairing Code Automatically (Picking Statements)
• add_to() — Tracking Failure Origins (Calls and Augmented Assign), Reducing Failure-Inducing Inputs (General Delta Debugging)
• advance() — Asserting Expectations (End of Excursion), Asserting Expectations (End of Excursion)
• after_collection() — Reducing Failure-Inducing Inputs (Collecting a Call), Reducing Failure-Inducing Inputs (Processing Multiple Arguments), Isolating Failure-Inducing Changes (A ChangeDebugger class)
• Alhazen class — Learning from Failures (The Alhazen Class), Learning from Failures (The Alhazen Class), Learning from Failures (The Alhazen Class), Learning from Failures (The Alhazen Class), Learning from Failures (The Alhazen Class), Learning from Failures (The Alhazen Class), Learning from Failures (The Alhazen Class), Learning from Failures (The Alhazen Class), Learning from Failures (The Alhazen Class), Learning from Failures (The Alhazen Class)
• allocate() — Asserting Expectations (Excursion: Dynamic Memory in C), Asserting Expectations (Excursion: Managed Memory)
• all_calls() — Mining Function Specifications (Tracing Calls)
• all_combinations() — Learning from Failures (Systematically Negating Paths)
• all_conditions() — Repairing Code Automatically (Collecting Conditions)
• all_events() — Statistical Debugging (A Base Class for Statistical Debugging)
• all_fail_events() — Statistical Debugging (Collecting Passing and Failing Runs)
• all_feature_names() — Learning from Failures (The Alhazen Class)
• all_functions() — Tracking Failure Origins (Drawing Dependencies)
• all_invariants() — Mining Function Specifications (Extracting Invariants)
• all_metrics() — Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Other Metrics)
• all_pass_events() — Statistical Debugging (Collecting Passing and Failing Runs)
• all_path() — Learning from Failures (Excursion: Tree helper functions)
• all_statements() — Repairing Code Automatically (Picking Statements)
• all_statements_and_functions() — Repairing Code Automatically (Picking Statements)
• all_trees() — Learning from Failures (The Alhazen Class)
• all_vars() — Tracking Failure Origins (Drawing Dependencies)
• AMBER — Asserting Expectations (Consider Leaving Some Assertions On)
• Angelix — Repairing Code Automatically (Background)
• annotate_arg() — Mining Function Specifications (Excursion: Annotating Functions with Given Types)
• annotate_function_ast_with_invariants() — Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• annotate_function_ast_with_types() — Mining Function Specifications (Excursion: Annotating Functions with Mined Types)
• annotate_function_with_invariants() — Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• annotate_function_with_types() — Mining Function Specifications (Excursion: Annotating Functions with Mined Types)
• annotate_invariants() — Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• annotate_types() — Mining Function Specifications (Excursion: Annotating Functions with Mined Types)
• arg() — Tracking Failure Origins (Excursion: Tracking Calls and Arguments), Tracking Failure Origins (Excursion: Function Arguments)
• args() — Reducing Failure-Inducing Inputs (Collecting a Call), Statistical Debugging (Collecting Events)
• argstring() — Statistical Debugging (Collecting Events)
• args_test() — Tracking Failure Origins (Excursion: Tracking Parameters)
• Ḥasan Ibn al-Haytham — Learning from Failures (The Alhazen Approach)
• assert_flow() — Tracking Failure Origins (Exercise 5: Flow Assertions)
• assign_command() — How Debuggers Work (Exercise 1: Changing State)
• assign_test() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• AST — Tracing Executions (Exercise 2: Syntax-Based Instrumentation), Reducing Failure-Inducing Inputs (Reducing Syntax Trees)
• asyncio — Repairing Code Automatically (Exercise 5: Parallel Repair)
• augment() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• AutoFix — Repairing Code Automatically (Background)
• Automata theory — Generalizing Failure Circumstances (Grammars)
• A_Class class — Class Diagrams (Getting a Class Hierarchy), Class Diagrams (Getting a Class Hierarchy)

B¶

• backward_slice() — Tracking Failure Origins (Slices)
• BAD_ATTR_INPUT — Generalizing Failure Circumstances (Testing for Generalization)
• BAD_INPUTS — Generalizing Failure Circumstances (A Failing Program)
• bad_input_tree_generalizer() — Generalizing Failure Circumstances (Testing for Generalization)
• bad_input_tree_mutator() — Generalizing Failure Circumstances (Referencing Subtrees)
• BAD_INPUT — Generalizing Failure Circumstances (A Failing Program), Generalizing Failure Circumstances (Parsing), Generalizing Failure Circumstances (Referencing Subtrees), Generalizing Failure Circumstances (Testing for Generalization), Generalizing Failure Circumstances (Generalizable Paths), Generalizing Failure Circumstances (Generalizing Arguments), Generalizing Failure Circumstances (Exercise 1: Generalization and Specialization)
• bar() — Class Diagrams (Getting a Class Hierarchy)
• bar class — Where the Bugs are (Mapping Elements to Locations)
• best_trees() — Learning from Failures (End of Excursion)
• BetterTime class — Asserting Expectations (End of Excursion)
• binary reduction of dependency graphs — Reducing Failure-Inducing Inputs (Background)
• bisecting — Isolating Failure-Inducing Changes (Manual Bisecting)
• BLACK — Asserting Expectations (Large Data Structures)
• BLOCK_LIST_START — Asserting Expectations (Excursion: Dynamic Memory in C)
• blog post — Reducing Failure-Inducing Inputs (Background)
• BODY — Repairing Code Automatically (Swapping Statements), Repairing Code Automatically (Swapping Statements), Repairing Code Automatically (Inserting Statements), Repairing Code Automatically (Deleting Statements)
• box() — Learning from Failures (Excursion: Tree helper functions)
• break_command() — How Debuggers Work (Setting Breakpoints)
• brightness() — Statistical Debugging (Continuous Spectrum)
• BROWSER — Tracking Bugs (Excursion: Remote Control with Selenium), Tracking Bugs (Excursion: Remote Control with Selenium)
• bug — Introduction to Debugging (From Defect to Failure), Introduction to Debugging (Lessons Learned)
• buggy_square_root_with_postcondition() — Mining Function Specifications (Annotating Functions with Pre- and Postconditions)
• Bugzilla bug database — Tracking Bugs (Background)
• BUG — Learning from Failures (Inputs and Grammars), Learning from Failures (Synopsis)
• B_Class class — Class Diagrams (Getting a Class Hierarchy)

C¶

• C-Reduce — Reducing Failure-Inducing Inputs (Background)
• CachingCallReducer class — Reducing Failure-Inducing Inputs (Testing, Logging, and Caching)
• CALC_GRAMMAR — Learning from Failures (Inputs and Grammars), Learning from Failures (Internal and "Friendly" Feature Names), Learning from Failures (Decision Trees)
• call stack — Inspecting Call Stacks (Inspecting Call Stacks)
• call() — Tracking Failure Origins (Excursion: Tracking Calls and Arguments), Tracking Failure Origins (Excursion: Calls and Returns), Reducing Failure-Inducing Inputs (Collecting a Call), Reducing Failure-Inducing Inputs (Repeating a Call)
• CallCollector class — Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation), Reducing Failure-Inducing Inputs (Collecting a Call), Reducing Failure-Inducing Inputs (Collecting a Call), Reducing Failure-Inducing Inputs (Repeating a Call), Reducing Failure-Inducing Inputs (Repeating a Call)
• callee() — Inspecting Call Stacks (Synopsis)
• caller() — Inspecting Call Stacks (Synopsis)
• callers() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• caller_frame() — Inspecting Call Stacks (Inspecting Call Stacks)
• caller_function() — Inspecting Call Stacks (Inspecting Call Stacks)
• caller_globals() — Inspecting Call Stacks (Inspecting Call Stacks)
• caller_locals() — Inspecting Call Stacks (Inspecting Call Stacks)
• caller_location() — Inspecting Call Stacks (Inspecting Call Stacks)
• CallReducer class — Reducing Failure-Inducing Inputs (Testing, Logging, and Caching), Reducing Failure-Inducing Inputs (Testing, Logging, and Caching)
• calls() — Mining Function Specifications (Tracing Calls)
• calls_in_our_with_block() — Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation)
• CallTracer class — Mining Function Specifications (Tracing Calls), Mining Function Specifications (Tracing Calls), Mining Function Specifications (Tracing Calls), Mining Function Specifications (Tracing Calls), Mining Function Specifications (Tracing Calls), Mining Function Specifications (Tracing Calls), Mining Function Specifications (Tracing Calls)
• call_generator() — Tracking Failure Origins (Excursion: Calls and Returns)
• call_test() — Tracking Failure Origins (Excursion: Function Arguments)
• cancel() — Timeout (Variant 1: Unix (using signals, efficient))), Timeout (Variant 2: Generic / Windows (using trace, not very efficient)))
• can_cross() — Repairing Code Automatically (Applying Crossover on Programs)
• can_generalize() — Generalizing Failure Circumstances (Testing for Generalization)
• cause-effect chain — Introduction to Debugging (From Defect to Failure)
• ChangeCounter class — Where the Bugs are (Counting Changes), Where the Bugs are (Counting Changes), Where the Bugs are (Counting Changes), Where the Bugs are (Counting Changes), Where the Bugs are (Counting Changes), Where the Bugs are (Counting Changes), Where the Bugs are (Counting Changes), Where the Bugs are (Visualizing Past Changes), Where the Bugs are (Visualizing Past Changes), Where the Bugs are (Visualizing Past Changes), Where the Bugs are (Visualizing Past Changes), Where the Bugs are (Visualizing Past Changes)
• ChangeDebugger class — Isolating Failure-Inducing Changes (A ChangeDebugger class), Isolating Failure-Inducing Changes (A ChangeDebugger class), Isolating Failure-Inducing Changes (A ChangeDebugger class), Isolating Failure-Inducing Changes (A ChangeDebugger class), Isolating Failure-Inducing Changes (A ChangeDebugger class), Isolating Failure-Inducing Changes (A ChangeDebugger class)
• changed_elems() — Where the Bugs are (Determining Changed Elements)
• changed_elems_by_mapping() — Where the Bugs are (Determining Changed Elements)
• changed_vars() — Tracing Executions (Tracing Variable Changes)
• chapter on delta debugging](DeltaDebugger.ipynb), the chapter on tracing, and excessively in the chapter on slicing. The official Python ast reference is complete, but a bit brief; the documentation ["Green Tree Snakes - the missing Python AST docs" — Repairing Code Automatically (Random Code Mutations)
• "Checking a Large Routine" — Asserting Expectations (Background)
• check_for_duplicates() — Learning from Failures (Excursion: Tree helper functions)
• check_location() — Tracking Failure Origins (Reading Variables), Tracking Failure Origins (Checking Locations)
• check_reproducibility() — Reducing Failure-Inducing Inputs (Processing Multiple Arguments)
• check_time() — Timeout (Variant 2: Generic / Windows (using trace, not very efficient)))
• choose_bool_op() — Repairing Code Automatically (Mutating Conditions)
• choose_condition() — Repairing Code Automatically (Mutating Conditions)
• choose_op() — Repairing Code Automatically (Choosing a Mutation Method)
• choose_statement() — Repairing Code Automatically (Swapping Statements)
• classifier() — Statistical Debugging (Training Classifiers)
• ClassifyingDebugger class — Statistical Debugging (Training Classifiers), Statistical Debugging (Training Classifiers), Statistical Debugging (Training Classifiers), Statistical Debugging (Training Classifiers), Statistical Debugging (Training Classifiers), Statistical Debugging (Training Classifiers), Statistical Debugging (Training Classifiers), Statistical Debugging (Training Classifiers)
• CLASS_COLOR — Class Diagrams (Drawing Class Hierarchy with Method Names), Class Diagrams (Drawing Class Hierarchy with Method Names)
• CLASS_FONT — Class Diagrams (Drawing Class Hierarchy with Method Names), Class Diagrams (Drawing Class Hierarchy with Method Names)
• class_hierarchy() — Class Diagrams (Getting a Class Hierarchy)
• class_items() — Class Diagrams (Getting Methods and Variables)
• _class_items() — Class Diagrams (Getting Methods and Variables)
• class_methods() — Class Diagrams (Getting Methods and Variables)
• class_methods_string() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• class_set() — Class Diagrams (Getting a Class Tree)
• class_tree() — Class Diagrams (Getting a Class Tree)
• class_vars() — Class Diagrams (Getting Methods and Variables)
• class_vars_string() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• clear_read() — Tracking Failure Origins (Checking Locations)
• clock() — Timer (Measuring Time)
• code snippet from StackOverflow — Mining Function Specifications (Annotating Functions with Pre- and Postconditions)
• code() — Tracking Failure Origins (Excursion: Listing Dependencies), Tracking Failure Origins (The Slicer Class), Statistical Debugging (Discrete Spectrum)
• _code() — Tracking Failure Origins (Excursion: Listing Dependencies)
• code_with_coverage() — Statistical Debugging (Collecting Coverage)
• collect() — Reducing Failure-Inducing Inputs (Traversing Syntax Trees), Statistical Debugging (Collecting Events), Statistical Debugging (Collecting Events), Statistical Debugging (Collecting Coverage), Statistical Debugging (A Base Class for Statistical Debugging), Statistical Debugging (Other Events besides Coverage), Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Other Metrics)
• collectors_without_event() — Statistical Debugging (Continuous Spectrum)
• collectors_with_event() — Statistical Debugging (Continuous Spectrum)
• Collector class — Statistical Debugging (Collecting Events), Statistical Debugging (Collecting Events), Statistical Debugging (Error Prevention), Statistical Debugging (Error Prevention)
• collect_fail() — Statistical Debugging (Collecting Passing and Failing Runs)
• collect_features() — Learning from Failures (Extracting Feature Values from Inputs)
• collect_pass() — Statistical Debugging (Collecting Passing and Failing Runs)
• color() — Statistical Debugging (Excursion: Printing an Event Table), Statistical Debugging (Discrete Spectrum), Statistical Debugging (Continuous Spectrum), Debugging Performance Issues (Visualizing Time Spent)
• commands() — How Debuggers Work (Excursion: Implementing execute()))
• command_method() — How Debuggers Work (Excursion: Implementing execute()))
• commit hash — Isolating Failure-Inducing Changes (Accessing Versions)
• compiler testing — Reducing Failure-Inducing Inputs (Background)
• compile_and_run() — Reducing Failure-Inducing Inputs (Reducing Program Code)
• compile_and_test_ast() — Reducing Failure-Inducing Inputs (Reducing Trees)
• compile_and_test_html_markup() — Reducing Failure-Inducing Inputs (Reducing Code Lines)
• compile_and_test_html_markup_simple() — Reducing Failure-Inducing Inputs (Reducing Program Code)
• compute_feature_values() — Learning from Failures (Extracting Feature Values from Inputs)
• condition() — Mining Function Specifications (Annotating Functions with Pre- and Postconditions)
• ConditionalTracer class — Tracing Executions (Conditional Tracing), Tracing Executions (Conditional Tracing), Tracing Executions (Conditional Tracing), Tracing Executions (Conditional Tracing), Tracing Executions (Conditional Tracing)
• ConditionMutator class — Repairing Code Automatically (Mutating Conditions), Repairing Code Automatically (Mutating Conditions)
• ConditionVisitor class — Repairing Code Automatically (Collecting Conditions)
• CONDITION — How Debuggers Work (Watchpoints ("watch")))
• context-free grammars — Generalizing Failure Circumstances (Grammars)
• continue_command() — How Debuggers Work (Debugger Interaction)
• ContinuousSpectrumDebugger class — Statistical Debugging (Continuous Spectrum), Statistical Debugging (Continuous Spectrum), Statistical Debugging (Continuous Spectrum), Statistical Debugging (Continuous Spectrum)
• contract — Mining Function Specifications (Beyond Generic Failures)
• copy_and_reduce() — Reducing Failure-Inducing Inputs (Deleting Nodes)
• count_leaves() — Learning from Failures (Excursion: Tree helper functions)
• count_nodes() — Learning from Failures (Excursion: Tree helper functions)
• coverage() — Statistical Debugging (Collecting Events), Statistical Debugging (Collecting Coverage), Statistical Debugging (Excursion: Printing an Event Table)
• CoverageCollector class — Statistical Debugging (Collecting Coverage), Statistical Debugging (Collecting Coverage), Statistical Debugging (Collecting Coverage)
• covered_functions() — Statistical Debugging (Collecting Events), Statistical Debugging (Collecting Coverage), Statistical Debugging (Excursion: Printing an Event Table)
• create_function() — Inspecting Call Stacks (Inspecting Call Stacks)
• create_new_input_specification() — Learning from Failures (Retrieving New input Specifications)
• crossover — Repairing Code Automatically (Crossover)
• crossover() — Repairing Code Automatically (Applying Crossover on Programs)
• CrossoverError class — Repairing Code Automatically (Applying Crossover on Programs)
• CrossoverOperator class — Repairing Code Automatically (Crossing Statement Lists), Repairing Code Automatically (Applying Crossover on Programs), Repairing Code Automatically (Applying Crossover on Programs), Repairing Code Automatically (Applying Crossover on Programs), Repairing Code Automatically (Applying Crossover on Programs)
• crossover_attr() — Repairing Code Automatically (Applying Crossover on Programs)
• crossover_branches() — Repairing Code Automatically (Applying Crossover on Programs)
• cross_bodies() — Repairing Code Automatically (Crossing Statement Lists)
• current_repo() — Where the Bugs are (Mining with PyDriller)
• C_Class class — Class Diagrams (Getting a Class Hierarchy)

D¶

• DAIKON dynamic invariant detector](https://plse.cs.washington.edu/daikon/) can be considered the mother of function specification miners. Continuously maintained and extended for more than 20 years, it mines likely invariants in the style of this chapter for a variety of languages, including C, C++, C#, Eiffel, F#, Java, Perl, and Visual Basic. On top of the functionality discussed above, it holds a rich catalog of patterns for likely invariants, supports data invariants, can eliminate invariants that are implied by others, and determines statistical confidence to disregard unlikely invariants. The corresponding paper [Unresolved citation: Ernst2001.] is one of the seminal and most-cited papers of Software Engineering. A multitude of works have been published based on DAIKON and detecting invariants; see this [curated list — Mining Function Specifications (Background)
• Daniel Lemire puts it — Asserting Expectations (Checking Memory Usage with Memory Sanitizer)
• data flow — Tracking Failure Origins (Data Dependencies)
• DataTrackerTester class — Tracking Failure Origins (Tracking Variable Accesses)
• DataTracker class — Tracking Failure Origins (A Data Tracker), Tracking Failure Origins (A Data Tracker), Tracking Failure Origins (A Data Tracker), Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Tracking Failure Origins (Excursion: Tracking Control), Tracking Failure Origins (Excursion: Tracking Control), Tracking Failure Origins (Excursion: Tracking Calls and Arguments), Tracking Failure Origins (Excursion: Tracking Calls and Arguments), Tracking Failure Origins (Excursion: Tracking Calls and Arguments), Tracking Failure Origins (Excursion: Tracking Parameters)
• DATA_TRACKER — Tracking Failure Origins (Tracking Variable Accesses)
• dd() — Reducing Failure-Inducing Inputs (General Delta Debugging)
• ddmin() — Reducing Failure-Inducing Inputs (Delta Debugging)
• DDSetDebugger class — Generalizing Failure Circumstances (Constructor), Generalizing Failure Circumstances (Generalizing Arguments), Generalizing Failure Circumstances (Generalizing Arguments), Generalizing Failure Circumstances (Fuzzing)
• Debugger API](https://developer.mozilla.org/en-US/docs/Tools/Debugger-API) and Google's [chrome.debugger API — Tracing Executions (High-Level Debugging Interfaces)
• debuggers — How Debuggers Work (Debuggers)
• Debugger class — How Debuggers Work (Debugger Interaction), How Debuggers Work (Debugger Interaction), How Debuggers Work (Debugger Interaction), How Debuggers Work (Debugger Interaction), How Debuggers Work (Debugger Interaction), How Debuggers Work (Debugger Interaction), How Debuggers Work (Debugger Interaction), How Debuggers Work (Excursion: Implementing execute())), How Debuggers Work (Excursion: Implementing execute())), How Debuggers Work (Excursion: Implementing execute())), How Debuggers Work (Excursion: Implementing execute())), How Debuggers Work (Printing Values), How Debuggers Work (Printing Values), How Debuggers Work (Listing Source Code), How Debuggers Work (Setting Breakpoints), How Debuggers Work (Deleting Breakpoints), How Debuggers Work (Listings with Benefits), How Debuggers Work (Quitting), How Debuggers Work (Exercise 1: Changing State)
• debugging information — Tracing Executions (Low-Level Debugging Interfaces)
• debuggingbook_change_counter() — Where the Bugs are (Counting Changes)
• DEBUGGINGBOOK_REMOTE_REPO — Where the Bugs are (Mining with PyDriller)
• DEBUGGINGBOOK_REPO — Where the Bugs are (Counting Changes)
• Decision trees — Statistical Debugging (Training Classifiers)
• decorator() — Mining Function Specifications (Annotating Functions with Pre- and Postconditions), Mining Function Specifications (Exercise 3: Verbose Invariant Checkers)
• default_functions() — Repairing Code Automatically (Helper Functions)
• default_items_to_instrument() — Tracking Failure Origins (An Instrumenter Base Class), Tracking Failure Origins (The Slicer Class), Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation)
• defined_in() — Class Diagrams (Getting Methods and Variables)
• DefinitionVisitor class — Repairing Code Automatically ((Re)defining Functions)defining-Functions)
• delete() — Asserting Expectations (Large Data Structures), Repairing Code Automatically (Deleting Statements)
• delete_command() — How Debuggers Work (Deleting Breakpoints)
• DELIMITERS — Where the Bugs are (Mapping Elements to Locations)
• DeltaDebugger class — Reducing Failure-Inducing Inputs (General Delta Debugging), Reducing Failure-Inducing Inputs (Processing Multiple Arguments), Reducing Failure-Inducing Inputs (Processing Multiple Arguments), Reducing Failure-Inducing Inputs (Processing Multiple Arguments), Reducing Failure-Inducing Inputs (Public API), Reducing Failure-Inducing Inputs (Public API), Reducing Failure-Inducing Inputs (Public API), Reducing Failure-Inducing Inputs (Public API)
• demo() — Tracking Failure Origins (Synopsis)
• demo4() — Tracking Failure Origins (Exercise 5: Flow Assertions)
• dependencies() — Tracking Failure Origins (Setting Variables), Tracking Failure Origins (The Slicer Class)
• Dependencies class — Tracking Failure Origins (A Class for Dependencies), Tracking Failure Origins (A Class for Dependencies), Tracking Failure Origins (A Class for Dependencies), Tracking Failure Origins (Drawing Dependencies), Tracking Failure Origins (Drawing Dependencies), Tracking Failure Origins (Drawing Dependencies), Tracking Failure Origins (Drawing Dependencies), Tracking Failure Origins (Drawing Dependencies), Tracking Failure Origins (Drawing Dependencies), Tracking Failure Origins (Drawing Dependencies), Tracking Failure Origins (Slices), Tracking Failure Origins (Excursion: Listing Dependencies), Tracking Failure Origins (Excursion: Listing Dependencies), Tracking Failure Origins (Excursion: Listing Dependencies), Tracking Failure Origins (Excursion: Listing Dependencies), Tracking Failure Origins (Excursion: Diagnostics)
• DependencyTrackerTester class — Tracking Failure Origins (Excursion: Function Arguments)
• DependencyTracker class — Tracking Failure Origins (Tracking Dependencies), Tracking Failure Origins (Reading Variables), Tracking Failure Origins (Checking Locations), Tracking Failure Origins (Checking Locations), Tracking Failure Origins (Setting Variables), Tracking Failure Origins (Excursion: Control Dependencies), Tracking Failure Origins (Excursion: Control Dependencies), Tracking Failure Origins (Excursion: Control Dependencies), Tracking Failure Origins (Excursion: Calls and Returns), Tracking Failure Origins (Excursion: Calls and Returns), Tracking Failure Origins (Excursion: Calls and Returns), Tracking Failure Origins (Excursion: Function Arguments), Tracking Failure Origins (Excursion: Function Arguments)
• derivation tree — Generalizing Failure Circumstances (Derivation Trees)
• description of red-black trees on Wikipedia — Asserting Expectations (Large Data Structures)
• diagnosis — Introduction to Debugging (Fixing the Bug)
• diff() — Isolating Failure-Inducing Changes (Computing and Applying Patches)
• diff-match-patch library — Isolating Failure-Inducing Changes (Synopsis), Isolating Failure-Inducing Changes (Computing and Applying Patches), Isolating Failure-Inducing Changes (Programmatic Interface)
• DifferenceDebugger class — Statistical Debugging (Collecting Passing and Failing Runs), Statistical Debugging (Collecting Passing and Failing Runs)
• DiscreteSpectrumDebugger class — Statistical Debugging (Discrete Spectrum)
• display_class_hierarchy() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• display_class_node() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• display_class_trees() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• display_legend() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• display_tree() — Generalizing Failure Circumstances (Derivation Trees)
• display_versions() — Isolating Failure-Inducing Changes (Leveraging Version Histories)
• docstring() — Class Diagrams (Getting Docs)
• doc_class_methods() — Class Diagrams (Getting Methods and Variables)
• DOC_INDENT — Class Diagrams (Getting Docs)
• Donald E. Knuth — Debugging Performance Issues (Improving Performance)
• do_report() — Tracing Executions (Conditional Tracing), Tracing Executions (Watching Events)
• draw_dependencies() — Tracking Failure Origins (Drawing Dependencies)
• draw_edge() — Tracking Failure Origins (Drawing Dependencies)
• drop_shadow() — Tracking Bugs (Excursion: Screenshots with Drop Shadows)
• dump_tree() — Tracking Failure Origins (Tracking Variable Accesses)
• DynamicMemory class — Asserting Expectations (Excursion: Dynamic Memory in C), Asserting Expectations (Excursion: Dynamic Memory in C)
• D_Class class — Class Diagrams (Getting a Class Hierarchy), Class Diagrams (Getting a Class Hierarchy)

E¶

• easyplotly — Where the Bugs are (Visualizing Past Changes), Where the Bugs are (Visualizing Past Changes), Where the Bugs are (Visualizing Past Changes)
• Efficient Grammar Fuzzing — Learning from Failures (End of Excursion)
• elapsed_time() — Timer (Measuring Time)
• elem_mapping() — Where the Bugs are (Mapping Elements to Locations)
• elem_size() — Where the Bugs are (Determining Changed Elements)
• Elitism — Repairing Code Automatically (Exercise 2: Elitism)
• EmbeddedInvariantAnnotator class — Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• EmbeddedInvariantTransformer class — Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions), Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• empty() — Reducing Failure-Inducing Inputs (General Delta Debugging)
• __enter__() — Tracing Executions (A Tracer Class), Asserting Expectations (Exercise 1 – Storage Assertions), Asserting Expectations (Task 2 – Global Consistency), Tracking Failure Origins (Tracking Variable Accesses), Tracking Failure Origins (Excursion: Tracking Control), Tracking Failure Origins (Excursion: Control Dependencies), Tracking Failure Origins (An Instrumenter Base Class), Reducing Failure-Inducing Inputs (Collecting a Call), Isolating Failure-Inducing Changes (A ChangeDebugger class), Statistical Debugging (Collecting Passing and Failing Runs), Debugging Performance Issues (Building a Profiler), Debugging Performance Issues (Collecting Time Spent), Error Handling (Catching Errors), Timer (Measuring Time), Timeout (Variant 1: Unix (using signals, efficient))), Timeout (Variant 2: Generic / Windows (using trace, not very efficient)))
• entire books about fuzzing — Reducing Failure-Inducing Inputs (Why Reducing?)
• equalNumberOfBlackNodesOnSubtrees() — Asserting Expectations (Large Data Structures)
• error — Introduction to Debugging (From Defect to Failure)
• escape() — Class Diagrams (Getting Docs)
• escape_doc() — Class Diagrams (Getting Docs)
• eval_in_context() — Tracing Executions (Conditional Tracing), Tracing Executions (Conditional Tracing)
• events() — Statistical Debugging (Collecting Events), Statistical Debugging (Collecting Coverage), Statistical Debugging (Other Events besides Coverage)
• events_changed() — Tracing Executions (Watching Events)
• EventTracer class — Tracing Executions (Watching Events), Tracing Executions (Watching Events), Tracing Executions (Watching Events)
• event_fraction() — Statistical Debugging (Continuous Spectrum)
• event_str() — Statistical Debugging (Excursion: Printing an Event Table)
• event_table() — Statistical Debugging (Excursion: Printing an Event Table)
• event_table_text() — Statistical Debugging (Excursion: Printing an Event Table)
• evolve() — Repairing Code Automatically (Evolving)
• evolve_middle() — Repairing Code Automatically (Evolution)
• exception() — Reducing Failure-Inducing Inputs (Collecting a Call), Statistical Debugging (Collecting Events)
• execute() — How Debuggers Work (Debugger Interaction), How Debuggers Work (Excursion: Implementing execute())), Tracking Failure Origins (The Slicer Class)
• execute_samples() — Learning from Failures (Inputs and Grammars), Learning from Failures (The Alhazen Class)
• execution log — Tracing Executions (Tracing Python Programs)
• execution_diagram() — Introduction to Debugging (From Defect to Failure)
• existence — Learning from Failures (Step 1: Extracting Features)
• ExistenceFeature class — Learning from Failures (Implementing Feature Classes)
• __exit__() — Tracing Executions (A Tracer Class), Asserting Expectations (Exercise 1 – Storage Assertions), Asserting Expectations (Task 2 – Global Consistency), Tracking Failure Origins (Tracking Variable Accesses), Tracking Failure Origins (Excursion: Tracking Control), Tracking Failure Origins (Excursion: Control Dependencies), Tracking Failure Origins (An Instrumenter Base Class), Reducing Failure-Inducing Inputs (Collecting a Call), Statistical Debugging (Error Prevention), Statistical Debugging (Collecting Passing and Failing Runs), Error Handling (Catching Errors), Error Handling (Catching Timeouts), Timer (Measuring Time), Timeout (Variant 1: Unix (using signals, efficient))), Timeout (Variant 2: Generic / Windows (using trace, not very efficient)))
• expand_criteria() — Tracking Failure Origins (Slices)
• ExpectError class — Error Handling (Catching Errors)
• ExpectTimeout class — Error Handling (Catching Timeouts)
• extend_grammar() — Learning from Failures (Excursion: Transforming Grammars)
• extracting_prediction_paths() — Learning from Failures (Systematically Negating Paths)
• extract_all_features() — Learning from Failures (Extracting Feature Sets from Grammars)
• extract_existence_features() — Learning from Failures (Extracting Feature Sets from Grammars)
• extract_numeric_features() — Learning from Failures (Extracting Feature Sets from Grammars)

F - J¶

F¶

• f() — Tracking Failure Origins (Excursion: Tracking Calls and Arguments), Where the Bugs are (Mapping Elements to Locations), Where the Bugs are (Determining Changed Elements)
• fail() — Tracing Executions (Exercise 1: Exception Handling)
• failed_fraction() — Statistical Debugging (Continuous Spectrum)
• failure — Introduction to Debugging (From Defect to Failure)
• FailureNotReproducedError class — Reducing Failure-Inducing Inputs (Processing Multiple Arguments), Repairing Code Automatically (Running Tests)
• fail_collectors() — Statistical Debugging (Collecting Passing and Failing Runs)
• FAIL_COLOR — Introduction to Debugging (Visualizing Code), Isolating Failure-Inducing Changes (Leveraging Version Histories)
• fail_source() — Isolating Failure-Inducing Changes (A ChangeDebugger class)
• fail_test() — Error Handling (Catching Errors)
• FAIL_VALUE — Statistical Debugging (Training Classifiers)
• FAIL — Introduction to Debugging (Visualizing Code), Reducing Failure-Inducing Inputs (Delta Debugging), Isolating Failure-Inducing Changes (Leveraging Version Histories), Statistical Debugging (Collecting Passing and Failing Runs)
• FALSE_TREE — Reducing Failure-Inducing Inputs (Transforming Nodes)
• fault — Introduction to Debugging (From Defect to Failure)
• feature() — Learning from Failures (Excursion: Converting Trees to Paths)
• features() — Statistical Debugging (Training Classifiers)
• feature_names() — Statistical Debugging (Training Classifiers)
• Feature class — Learning from Failures (Implementing Feature Classes)
• filter() — Where the Bugs are (Counting Changes), Where the Bugs are (Counting Changes)
• find_existence_index() — Learning from Failures (Excursion: Tree helper functions)
• find_paths() — Generalizing Failure Circumstances (Generalizable Paths)
• find_sample() — Learning from Failures (Excursion: Converting Trees to Paths)
• FineChangeCounter class — Where the Bugs are (Putting it all Together)
• FineFixCounter class — Where the Bugs are (Exercise 1: Fine-Grained Fixes)
• finite state machines — Generalizing Failure Circumstances (Grammars)
• First actual case of bug being found — Introduction to Debugging (Debugging Aftermath)
• fitness() — Repairing Code Automatically ((Re)defining Functions)defining-Functions)
• fitness_key() — Repairing Code Automatically (Evolving)
• FixCounter class — Where the Bugs are (Counting Past Fixes), Where the Bugs are (Counting Past Fixes)
• FONT_NAME — Introduction to Debugging (Visualizing Code), Tracking Failure Origins (Drawing Dependencies), Isolating Failure-Inducing Changes (Leveraging Version Histories)
• foo() — Tracing Executions (Exercise 2: Syntax-Based Instrumentation), Where the Bugs are (Mapping Elements to Locations), Where the Bugs are (Mapping Elements to Locations), Where the Bugs are (Determining Changed Elements), Class Diagrams (Getting a Class Hierarchy), Class Diagrams (Getting a Class Hierarchy), Class Diagrams (Getting a Class Hierarchy)
• formal languages — Generalizing Failure Circumstances (Grammars)
• format_call() — Reducing Failure-Inducing Inputs (Collecting a Call), Reducing Failure-Inducing Inputs (Repeating a Call)
• format_exception() — Reducing Failure-Inducing Inputs (Collecting a Call), Reducing Failure-Inducing Inputs (Repeating a Call)
• format_node() — Repairing Code Automatically (Choosing Suspicious Statements to Mutate), Repairing Code Automatically (Helpers)
• format_var() — Tracking Failure Origins (Excursion: Listing Dependencies)
• frame_module() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• free() — Asserting Expectations (Excursion: Dynamic Memory in C), Asserting Expectations (Excursion: Managed Memory)
• friendly() — Learning from Failures (Retrieving New input Specifications), Learning from Failures (Retrieving New input Specifications)
• friendly_decision_tree() — Learning from Failures (Decision Trees), Learning from Failures (The Alhazen Class)
• friendly_name() — Learning from Failures (Implementing Feature Classes)
• from_set() — Reducing Failure-Inducing Inputs (General Delta Debugging)
• full-fledged implementation of DDSET](https://rahul.gopinath.org/post/2020/07/15/ddset/) with plenty of details and experiments is available as a Jupyter Notebook. Our implementation follows the [simplified implementation of DDSET, as described by Gopinath — Generalizing Failure Circumstances (Background)
• fun() — Asserting Expectations (Assertion Diagnostics)
• funcs_in_our_with_block() — Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation)
• function() — Reducing Failure-Inducing Inputs (Collecting a Call), Statistical Debugging (Collecting Events), Statistical Debugging (Excursion: Printing an Event Table)
• functions_with_invariants() — Mining Function Specifications (Converting Mined Invariants to Annotations)
• function_with_invariants() — Mining Function Specifications (Converting Mined Invariants to Annotations), Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• function_with_invariants_ast() — Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• FUNCTION — How Debuggers Work (Named breakpoints ("break")))
• fun_1() — Tracking Failure Origins (End of Excursion)
• fun_2() — Tracking Failure Origins (End of Excursion)
• fuzz() — Reducing Failure-Inducing Inputs (Why Reducing?), Generalizing Failure Circumstances (Fuzzing)
• "Fuzzing with Grammars" — Learning from Failures (Inputs and Grammars)
• fuzzingbook — Generalizing Failure Circumstances (Grammars)
• fuzz_args() — Generalizing Failure Circumstances (Fuzzing)
• fuzz_tree() — Generalizing Failure Circumstances (Fuzzing with Patterns)

G¶

• GDB, the GNU debugger](https://www.gnu.org/software/gdb/), whose interface in turn goes back to earlier command-line debuggers such as [dbx — How Debuggers Work (Background)
• gen() — Tracking Failure Origins (Excursion: Function Arguments)
• generalizable_paths() — Generalizing Failure Circumstances (Generalizable Paths)
• generalize() — Generalizing Failure Circumstances (Generalizable Paths), Generalizing Failure Circumstances (Generalizing Arguments)
• generalize_path() — Generalizing Failure Circumstances (Generalizable Paths)
• generate_samples() — Learning from Failures (End of Excursion)
• generate_samples_advanced() — Learning from Failures (End of Excursion)
• generate_samples_random() — Learning from Failures (End of Excursion)
• GENERATOR_TIMEOUT — Learning from Failures (A Sample Run)
• GenericTimeout class — Timeout (Variant 2: Generic / Windows (using trace, not very efficient)))
• generic_feature_names() — Learning from Failures (Excursion: Tree helper functions)
• generic_test() — Reducing Failure-Inducing Inputs (Delta Debugging)
• generic_visit() — Reducing Failure-Inducing Inputs (Traversing Syntax Trees), Repairing Code Automatically (Picking Statements), Repairing Code Automatically (Collecting Conditions)
• GenProg — Repairing Code Automatically (Background)
• get() — Tracking Failure Origins (A Data Tracker), Tracking Failure Origins (Reading Variables), Learning from Failures (Excursion: Converting Trees to Paths)
• __getitem__() — Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Exercise 1 – Storage Assertions), Asserting Expectations (Task 2 – Global Consistency)
• getsource() — Repairing Code Automatically (Helper Functions)
• get_all_input_specifications() — Learning from Failures (Retrieving New input Specifications)
• get_all_subtrees() — Learning from Failures (Retrieving New input Specifications)
• get_arguments() — Mining Function Specifications (Tracing Calls)
• get_feature_value() — Learning from Failures (Implementing Feature Classes), Learning from Failures (Implementing Feature Classes), Learning from Failures (Implementing Feature Classes), Learning from Failures (Implementing Feature Classes), Learning from Failures (Implementing Feature Classes)
• get_key() — Learning from Failures (Excursion: Converting Trees to Paths)
• get_neg() — Learning from Failures (Excursion: Converting Trees to Paths)
• get_neg_ext() — Learning from Failures (Excursion: Converting Trees to Paths)
• get_output() — Isolating Failure-Inducing Changes (Accessing Versions)
• get_str() — Learning from Failures (Excursion: Converting Trees to Paths)
• get_str_ext() — Learning from Failures (Excursion: Converting Trees to Paths)
• get_subtree() — Generalizing Failure Circumstances (Referencing Subtrees)
• grammars — Generalizing Failure Circumstances (Grammars)
• graph() — Introduction to Debugging (Visualizing Code), Tracking Failure Origins (Drawing Dependencies), Tracking Failure Origins (The Slicer Class), Isolating Failure-Inducing Changes (Leveraging Version Histories)
• graph_attr() — Generalizing Failure Circumstances (Derivation Trees)
• GREEN — Asserting Expectations (Consider Leaving Some Assertions On)
• grouped_rules() — Learning from Failures (Excursion: Tree helper functions)

H¶

• hardware breakpoints — Tracing Executions (Tracing Binary Executables)
• hardware watchpoints — Tracing Executions (Tracing Binary Executables)
• HDD — Reducing Failure-Inducing Inputs (Background)
• HEADLESS — Tracking Bugs (Excursion: Remote Control with Selenium)
• hello() — Mining Function Specifications (Tracing Calls)
• help_command() — How Debuggers Work (Excursion: Implementing execute())), How Debuggers Work (Excursion: Implementing execute()))
• Hierarchical Delta Debugging — Reducing Failure-Inducing Inputs (Background)
• HitCollector class — Debugging Performance Issues (Other Metrics)
• hours() — Asserting Expectations (Times and Time Bombs), Asserting Expectations (Excursion: Checked Getters and Setters in Python), Asserting Expectations (Excursion: Checked Getters and Setters in Python)
• hue() — Statistical Debugging (Continuous Spectrum), Statistical Debugging (The Ochiai Metric)
• Hypothesis](https://hypothesis.works) fuzzer has a number of type-specific shrinking strategies; this [blog article — Reducing Failure-Inducing Inputs (Background)

I¶

• id() — Tracking Failure Origins (Drawing Dependencies), Statistical Debugging (Collecting Events)
• ignore_location_change() — Tracking Failure Origins (Checking Locations)
• ignore_next_location_change() — Tracking Failure Origins (Checking Locations)
• include() — Where the Bugs are (Counting Changes), Where the Bugs are (Counting Past Fixes)
• infection — Introduction to Debugging (From Defect to Failure), Introduction to Debugging (Lessons Learned)
• init() — Reducing Failure-Inducing Inputs (Collecting a Call), Reducing Failure-Inducing Inputs (Testing, Logging, and Caching)
• initial_population() — Repairing Code Automatically (Repairing)
• __init__() — Tracing Executions (A Tracer Class), Tracing Executions (Tracing Variable Changes), Tracing Executions (Conditional Tracing), Tracing Executions (Watching Events), How Debuggers Work (Debugger Interaction), Asserting Expectations (Times and Time Bombs), Asserting Expectations (Times and Time Bombs), Asserting Expectations (End of Excursion), Asserting Expectations (Large Data Structures), Asserting Expectations (Large Data Structures), Asserting Expectations (Large Data Structures), Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Excursion: Dynamic Memory in C), Asserting Expectations (Excursion: Managed Memory), Asserting Expectations (Exercise 1 – Storage Assertions), Asserting Expectations (Task 2 – Global Consistency), Tracking Failure Origins (A Class for Dependencies), Tracking Failure Origins (A Data Tracker), Tracking Failure Origins (Tracking Variable Accesses), Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Tracking Failure Origins (Excursion: Tracking Return Values), Tracking Failure Origins (Tracking Dependencies), Tracking Failure Origins (An Instrumenter Base Class), Tracking Failure Origins (The Slicer Class), Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation), Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation), Reducing Failure-Inducing Inputs (Collecting a Call), Reducing Failure-Inducing Inputs (Testing, Logging, and Caching), Reducing Failure-Inducing Inputs (Traversing Syntax Trees), Isolating Failure-Inducing Changes (A ChangeDebugger class), Statistical Debugging (Collecting Events), Statistical Debugging (Collecting Coverage), Statistical Debugging (A Base Class for Statistical Debugging), Statistical Debugging (Other Events besides Coverage), Mining Function Specifications (Tracing Calls), Mining Function Specifications (Excursion: Annotating Functions with Given Types), Mining Function Specifications (Extracting Invariants), Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions), Generalizing Failure Circumstances (Mutating the Tree), Generalizing Failure Circumstances (Generalizing Trees), Generalizing Failure Circumstances (Constructor), Learning from Failures (Implementing Feature Classes), Learning from Failures (Implementing Feature Classes), Learning from Failures (Implementing Feature Classes), Learning from Failures (Excursion: Converting Trees to Paths), Learning from Failures (Excursion: Converting Trees to Paths), Learning from Failures (Retrieving New input Specifications), Learning from Failures (Retrieving New input Specifications), Learning from Failures (The Alhazen Class), Debugging Performance Issues (Building a Profiler), Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Visualizing Time Spent), Debugging Performance Issues (Other Metrics), Repairing Code Automatically (Picking Statements), Repairing Code Automatically (Mutating Statements), Repairing Code Automatically (Crossing Statement Lists), Repairing Code Automatically (Excursion: Implementing Repairer), Repairing Code Automatically ((Re)defining Functions)defining-Functions), Repairing Code Automatically (Collecting Conditions), Repairing Code Automatically (Mutating Conditions), Where the Bugs are (Counting Changes), Error Handling (Catching Errors), Error Handling (Catching Timeouts), Timer (Measuring Time), Timeout (Variant 1: Unix (using signals, efficient))), Timeout (Variant 2: Generic / Windows (using trace, not very efficient)))
• InjectPass class — Tracing Executions (Exercise 2: Syntax-Based Instrumentation)
• input grammar in fuzzingbook format — Generalizing Failure Circumstances (Synopsis), Generalizing Failure Circumstances (Synopsis)
• InputSpecification class — Learning from Failures (Retrieving New input Specifications)
• insert() — Asserting Expectations (Large Data Structures), Repairing Code Automatically (Inserting Statements)
• insert_assertions() — Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions), Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• insert_tracer() — Tracing Executions (Efficient Tracing)
• instantiate_prop() — Mining Function Specifications (Instantiating Properties)
• instantiate_prop_ast() — Mining Function Specifications (Instantiating Properties)
• instrument() — Tracking Failure Origins (An Instrumenter Base Class), Tracking Failure Origins (The Slicer Class)
• Instrumenter class — Tracking Failure Origins (An Instrumenter Base Class), Tracking Failure Origins (An Instrumenter Base Class)
• instrument_call() — Tracking Failure Origins (Excursion: Tracking Calls and Arguments)
• interaction_loop() — How Debuggers Work (Debugger Interaction)
• InvariantAnnotator class — Mining Function Specifications (Converting Mined Invariants to Annotations), Mining Function Specifications (Converting Mined Invariants to Annotations), Mining Function Specifications (Converting Mined Invariants to Annotations), Mining Function Specifications (Converting Mined Invariants to Annotations)
• invariants — Mining Function Specifications (Mining Invariants)
• invariants() — Mining Function Specifications (Extracting Invariants)
• InvariantTracer class — Mining Function Specifications (Extracting Invariants), Mining Function Specifications (Extracting Invariants)
• INVARIANT_PROPERTIES — Mining Function Specifications (Defining Properties), Mining Function Specifications (Extracting Invariants)
• in_generator() — Tracking Failure Origins (Excursion: Calls and Returns)
• ISO 8601 format — Asserting Expectations (Times and Time Bombs)
• is_abstract() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• is_binary() — Learning from Failures (Excursion: Converting Trees to Paths)
• is_bug() — Learning from Failures (Excursion: Converting Trees to Paths)
• is_internal() — Tracking Failure Origins (Tracking Variable Accesses)
• is_internal_error() — Inspecting Call Stacks (Inspecting Call Stacks)
• is_leaf() — Learning from Failures (Excursion: Tree helper functions)
• is_local_class() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• is_overloaded() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• is_public() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• is_reducible() — Reducing Failure-Inducing Inputs (Processing Multiple Arguments)
• is_test() — Repairing Code Automatically (Helper Functions)
• is_var() — Class Diagrams (Getting Methods and Variables)
• _iterate() — Learning from Failures (The Alhazen Class)
• iterate_nodes() — Learning from Failures (Excursion: Tree helper functions)
• its documentation in the Python reference — Tracing Executions (Tracing Python Programs)

J¶

• J-Reduce — Reducing Failure-Inducing Inputs (Background)
• Java Debug Interface](https://docs.oracle.com/javase/8/docs/jdk/api/jpda/jdi/) (JDI) is a high-level interface for implementing a debugger (or tracer) on top of Java. [This introduction to JDI — Tracing Executions (High-Level Debugging Interfaces)
• JSON — Where the Bugs are (Mapping Elements to Locations)
• just_x() — Tracking Failure Origins (Excursion: Function Arguments)

L - P¶

L¶

• label() — Tracking Failure Origins (Drawing Dependencies)
• language specifications — Generalizing Failure Circumstances (Grammars)
• last_tree() — Learning from Failures (The Alhazen Class)
• leaf_label() — Learning from Failures (Excursion: Tree helper functions)
• LeftmostNameVisitor class — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• leftmost_name() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• __len__() — Learning from Failures (Excursion: Converting Trees to Paths)
• LINENO — Tracking Failure Origins (Excursion: Listing Dependencies)
• LINE — How Debuggers Work (Execute until line ("until"))), How Debuggers Work (Execute until line ("until")))
• list_command() — How Debuggers Work (Listing Source Code), How Debuggers Work (Listings with Benefits)
• list_error() — Reducing Failure-Inducing Inputs (Reducing other Collections)
• list_features() — Learning from Failures (Excursion: Tree helper functions)
• list_length() — Mining Function Specifications (A Recursive Function)
• LoadVisitor class — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• load_names() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• log() — Tracing Executions (A Tracer Class)
• log_tree() — Repairing Code Automatically (Helper Functions)
• long_running_test() — Error Handling (Catching Timeouts)
• lower_middle() — Learning from Failures (Excursion: Converting Trees to Paths)

M¶

• magic — Where the Bugs are (Mapping Elements to Locations)
• main() — Where the Bugs are (Mapping Elements to Locations), Where the Bugs are (Determining Changed Elements)
• make_call() — Tracking Failure Origins (Excursion: Tracking Calls and Arguments)
• make_data_tracker() — Tracking Failure Origins (Tracking Variable Accesses), Tracking Failure Origins (Excursion: Function Arguments)
• make_get_data() — Tracking Failure Origins (Tracking Variable Accesses)
• make_graph() — Tracking Failure Origins (Drawing Dependencies)
• make_set_data() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• make_test() — Tracking Failure Origins (Excursion: Tracking Control)
• make_with() — Tracking Failure Origins (Excursion: Tracking Control)
• malfunction — Introduction to Debugging (From Defect to Failure), Introduction to Debugging (Lessons Learned)
• ManagedMemory class — Asserting Expectations (Excursion: Managed Memory), Asserting Expectations (Excursion: Managed Memory), Asserting Expectations (Excursion: Managed Memory), Asserting Expectations (Excursion: Managed Memory)
• map() — Where the Bugs are (Visualizing Past Changes)
• map_colorscale() — Where the Bugs are (Visualizing Past Changes)
• map_hoverinfo() — Where the Bugs are (Visualizing Past Changes), Where the Bugs are (Counting Past Fixes)
• map_node_color() — Where the Bugs are (Visualizing Past Changes)
• map_node_sizes() — Where the Bugs are (Visualizing Past Changes)
• map_node_text() — Where the Bugs are (Visualizing Past Changes), Where the Bugs are (Counting Past Fixes)
• mark_tracker() — Tracking Bugs (Managing Issues)
• Martin Eberlein — Learning from Failures
• Master Mind Board Grame — Introduction to Debugging (Keep a Log)
• maxi() — Learning from Failures (Excursion: Converting Trees to Paths)
• maximum() — Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Visualizing Time Spent)
• max_args() — Reducing Failure-Inducing Inputs (Public API)
• max_digits() — Learning from Failures (Excursion: Converting Trees to Paths)
• MAX_ITERATIONS — Learning from Failures (A Sample Run)
• Memory class — Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Excursion: A C Memory Model Simulator)
• metavars() — Mining Function Specifications (Extracting Meta-Variables)
• METHOD_COLOR — Class Diagrams (Drawing Class Hierarchy with Method Names)
• METHOD_FONT — Class Diagrams (Drawing Class Hierarchy with Method Names)
• method_string() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• metric() — Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Visualizing Time Spent), Debugging Performance Issues (Other Metrics)
• MetricCollector class — Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Collecting Time Spent)
• MetricDebugger class — Debugging Performance Issues (Visualizing Time Spent)
• middle() — Tracking Failure Origins (Dependencies), Statistical Debugging (Continuous Spectrum)
• middle_checked() — Statistical Debugging (Exercise 1: A Postcondition for Middle)
• middle_deps() — Tracking Failure Origins (Drawing Dependencies)
• middle_failing_testcase() — Statistical Debugging (Using Large Test Suites)
• MIDDLE_FAILING_TESTCASES — Statistical Debugging (Using Large Test Suites)
• middle_fitness() — Repairing Code Automatically (Fitness)
• middle_fixed() — Statistical Debugging (Continuous Spectrum)
• middle_passing_testcase() — Statistical Debugging (Using Large Test Suites)
• MIDDLE_PASSING_TESTCASES — Statistical Debugging (Using Large Test Suites)
• MIDDLE_POPULATION — Repairing Code Automatically (Population), Repairing Code Automatically (Evolution)
• middle_sort_of_fixed() — Repairing Code Automatically (Validated Repairs)
• middle_test() — Statistical Debugging (Using Large Test Suites), Generalizing Failure Circumstances (Middle), Repairing Code Automatically (A Test Suite)
• middle_testcase() — Statistical Debugging (Using Large Test Suites)
• MIDDLE_TESTS — Statistical Debugging (Using Large Test Suites)
• middle_tree() — Repairing Code Automatically (Random Code Mutations)
• mine() — Where the Bugs are (Counting Changes)
• mine_commit() — Where the Bugs are (Counting Changes)
• mini() — Learning from Failures (Excursion: Converting Trees to Paths)
• minutes() — Asserting Expectations (Times and Time Bombs)
• min_args() — Reducing Failure-Inducing Inputs (Public API)
• min_arg_diff() — Reducing Failure-Inducing Inputs (Public API)
• min_digits() — Learning from Failures (Excursion: Converting Trees to Paths)
• min_patches() — Isolating Failure-Inducing Changes (A ChangeDebugger class)
• MonkeyType — Mining Function Specifications (Background)
• Mozilla Bugzilla issue tracker — Tracking Bugs (Reporting an Issue)
• mul_with() — Tracking Failure Origins (Calls and Augmented Assign)
• mutate() — Generalizing Failure Circumstances (Mutating the Tree), Repairing Code Automatically (All Together)
• mutation testing — Tracking Failure Origins (Assessing Test Quality)
• myeval() — Reducing Failure-Inducing Inputs (Synopsis)
• MyInt class — Tracking Failure Origins (Wrapping Data Objects)
• Mypy — Mining Function Specifications (Static Type Checking)
• mystery() — Reducing Failure-Inducing Inputs (Why Reducing?)
• MyTime class — Asserting Expectations (Excursion: Checked Getters and Setters in Python)
• my_own_assert() — Asserting Expectations (Assertions)
• my_square_root() — Asserting Expectations (Synopsis)

N¶

• name_rep() — Learning from Failures (Implementing Feature Classes), Learning from Failures (Implementing Feature Classes), Learning from Failures (Implementing Feature Classes)
• NAME — How Debuggers Work (Synopsis), How Debuggers Work (Printing Values), How Debuggers Work (Synopsis), Tracking Failure Origins (Excursion: Listing Dependencies)
• NDEBUG — Asserting Expectations (Assertion Diagnostics), Asserting Expectations (Assertion Diagnostics)
• Newton–Raphson method — Asserting Expectations (Checking Results)
• new_issue() — Tracking Bugs (Excursion: Adding Some More Issue Reports)
• new_tree() — Generalizing Failure Circumstances (Creating new Subtrees)
• __new__() — Tracking Failure Origins (Wrapping Data Objects)
• NoCallError class — Reducing Failure-Inducing Inputs (Collecting a Call)
• NodeCollector class — Reducing Failure-Inducing Inputs (Traversing Syntax Trees)
• NodeMarker class — Reducing Failure-Inducing Inputs (Deleting Nodes)
• NodeReducer class — Reducing Failure-Inducing Inputs (Deleting Nodes), Reducing Failure-Inducing Inputs (Transforming Nodes), Reducing Failure-Inducing Inputs (Transforming Nodes), Reducing Failure-Inducing Inputs (Transforming Nodes), Reducing Failure-Inducing Inputs (Transforming Nodes)
• node_attr() — Generalizing Failure Circumstances (Derivation Trees)
• NODE_COLOR — Tracking Failure Origins (Drawing Dependencies)
• NODE_MAX_LENGTH — Repairing Code Automatically (Helpers)
• node_suspiciousness() — Repairing Code Automatically (Choosing Suspicious Statements to Mutate)
• node_to_be_mutated() — Repairing Code Automatically (Choosing Suspicious Statements to Mutate)
• NODE — Repairing Code Automatically (Swapping Statements), Repairing Code Automatically (Inserting Statements), Repairing Code Automatically (Inserting Statements), Repairing Code Automatically (Inserting Statements), Repairing Code Automatically (Deleting Statements), Repairing Code Automatically (Deleting Statements)
• NotFailingError class — Reducing Failure-Inducing Inputs (General Delta Debugging)
• NotPassingError class — Reducing Failure-Inducing Inputs (General Delta Debugging), Isolating Failure-Inducing Changes (A ChangeDebugger class)
• NO_BUG — Learning from Failures (Inputs and Grammars), Learning from Failures (Synopsis)
• numeric interpretation — Learning from Failures (Step 1: Extracting Features)
• NumericInterpretation class — Learning from Failures (Implementing Feature Classes)
• NUM_WORKERS — Where the Bugs are (Counting Changes)

O¶

• OchiaiDebugger class — Statistical Debugging (The Ochiai Metric)
• official Python ast reference — Tracking Failure Origins (Tracking Variable Accesses), Repairing Code Automatically (Picking Statements), Repairing Code Automatically (Mutating Statements)
• official Python ast reference](http://docs.python.org/3/library/ast) for a list of nodes (and some ideas on what to replace them by). The documentation ["Green Tree Snakes - the missing Python AST docs" — Reducing Failure-Inducing Inputs (Exercise 1: Advanced Syntactic Code Reduction)
• official Python ast reference](http://docs.python.org/3/library/ast) is complete, but a bit brief; the documentation ["Green Tree Snakes - the missing Python AST docs" — Tracing Executions (Exercise 2: Syntax-Based Instrumentation), Tracking Failure Origins (Tracking Variable Accesses), Reducing Failure-Inducing Inputs (Traversing Syntax Trees)
• only_fail_events() — Statistical Debugging (Collecting Passing and Failing Runs)
• only_pass_events() — Statistical Debugging (Collecting Passing and Failing Runs)
• OracleResult class — Learning from Failures (Inputs and Grammars)
• oracles — Mining Function Specifications (Checking Specifications)
• our_frame() — Inspecting Call Stacks (Inspecting Call Stacks)
• our_with_block() — Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation)
• overloaded_class_methods() — Class Diagrams (Getting Methods and Variables)
• overview at Livable Software](https://livablesoftware.com/tools-mine-analyze-github-git-software-data/) gives a great overview of platforms and tools for mining development data. One of the most ambitious ones is [GrimoireLab — Where the Bugs are (Background)

P¶

• p1() — Repairing Code Automatically (Crossing Statement Lists), Repairing Code Automatically (Crossover in Action)
• p2() — Repairing Code Automatically (Crossing Statement Lists), Repairing Code Automatically (Crossover in Action)
• param() — Tracking Failure Origins (Excursion: Tracking Parameters), Tracking Failure Origins (Excursion: Function Arguments)
• params() — Mining Function Specifications (Converting Mined Invariants to Annotations)
• parentsAreConsistent() — Asserting Expectations (Large Data Structures)
• parse tree — Generalizing Failure Circumstances (Parsing)
• parse() — Tracking Failure Origins (The Slicer Class), Repairing Code Automatically (Helper Functions)
• parse_type() — Mining Function Specifications (Excursion: Annotating Functions with Given Types)
• passed_fraction() — Statistical Debugging (Continuous Spectrum)
• password_checker() — Tracking Failure Origins (Verifying Information Flows)
• pass_collectors() — Statistical Debugging (Collecting Passing and Failing Runs)
• PASS_COLOR — Introduction to Debugging (Visualizing Code), Isolating Failure-Inducing Changes (Leveraging Version Histories)
• pass_source() — Isolating Failure-Inducing Changes (A ChangeDebugger class)
• PASS_TREE — Reducing Failure-Inducing Inputs (Transforming Nodes)
• PASS_VALUE — Statistical Debugging (Training Classifiers)
• PASS — Introduction to Debugging (Visualizing Code), Reducing Failure-Inducing Inputs (Delta Debugging), Isolating Failure-Inducing Changes (Leveraging Version Histories), Statistical Debugging (Collecting Passing and Failing Runs)
• patch() — Isolating Failure-Inducing Changes (Computing and Applying Patches)
• patches() — Isolating Failure-Inducing Changes (A ChangeDebugger class)
• patch_string() — Isolating Failure-Inducing Changes (Computing and Applying Patches)
• path_samples() — Learning from Failures (Excursion: Tree helper functions)
• percentage() — Statistical Debugging (Discrete Spectrum)
• PerformanceDebugger class — Debugging Performance Issues (Visualizing Time Spent)
• PerformanceTracer class — Debugging Performance Issues (Building a Profiler), Debugging Performance Issues (Building a Profiler), Debugging Performance Issues (Building a Profiler)
• plastic surgery hypothesis — Repairing Code Automatically (Random Code Mutations)
• POPULATION_SIZE — Repairing Code Automatically (Population), Repairing Code Automatically (Exercise 1: Automated Repair Parameters)
• postcondition() — Mining Function Specifications (Annotating Functions with Pre- and Postconditions)
• postconditions() — Mining Function Specifications (Converting Mined Invariants to Annotations), Mining Function Specifications (Exercise 3: Verbose Invariant Checkers), Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• precondition() — Mining Function Specifications (Annotating Functions with Pre- and Postconditions)
• preconditions() — Mining Function Specifications (Converting Mined Invariants to Annotations), Mining Function Specifications (Exercise 3: Verbose Invariant Checkers), Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• PreconditionTransformer class — Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions)
• prediction_for_path() — Learning from Failures (Excursion: Tree helper functions)
• pretty_invariants() — Mining Function Specifications (Extracting Invariants)
• primes_generator() — Generalizing Failure Circumstances (Referencing Subtrees)
• print_command() — How Debuggers Work (Printing Values), How Debuggers Work (Printing Values)
• print_debugger_status() — Tracing Executions (Tracing Variable Changes), Tracing Executions (Exercise 1: Exception Handling)
• print_patch() — Isolating Failure-Inducing Changes (Computing and Applying Patches)
• print_sum() — Mining Function Specifications (Sum of two Numbers)
• process_args() — Reducing Failure-Inducing Inputs (Processing Multiple Arguments)
• profile or cProfile — Debugging Performance Issues (Measuring Performance)
• profiling — Debugging Performance Issues (Measuring Performance)
• profiling](https://en.wikipedia.org/wiki/Profiling_(computer_programming)) and [performance analysis tools — Debugging Performance Issues (Background)
• program-repair.org — Repairing Code Automatically (Background)
• PROJECT — Isolating Failure-Inducing Changes (Create a Working Directory)
• prop_function() — Mining Function Specifications (Evaluating Properties)
• prop_function_text() — Mining Function Specifications (Evaluating Properties)
• ptrace() — Tracing Executions (Low-Level Debugging Interfaces)
• public_class_methods() — Class Diagrams (Getting Methods and Variables)
• PyAnnotate — Mining Function Specifications (Background)
• PyDriller — Debugging Performance Issues (Tracing Execution Profiles), Where the Bugs are (Synopsis), Where the Bugs are (Mining with PyDriller), Where the Bugs are (Synopsis)
• Python abstract syntax tree — Repairing Code Automatically (Synopsis), Repairing Code Automatically (Synopsis)
• Python tutorial — Introduction to Debugging (Understanding Python Programs)

Q - U¶

Q¶

• quit_command() — How Debuggers Work (Quitting)
• quux() — Class Diagrams (Getting a Class Hierarchy)
• qux() — Class Diagrams (Getting a Class Hierarchy)
• qux class — Where the Bugs are (Determining Changed Elements)

R¶

• random_html() — Repairing Code Automatically (Excursion: Creating HTML Test Cases)
• random_id() — Repairing Code Automatically (Excursion: Creating HTML Test Cases)
• random_plain() — Repairing Code Automatically (Excursion: Creating HTML Test Cases)
• random_string() — Repairing Code Automatically (Excursion: Creating HTML Test Cases)
• random_string_noquotes() — Repairing Code Automatically (Excursion: Creating HTML Test Cases)
• rank() — Statistical Debugging (Ranking Lines by Suspiciousness)
• RankingDebugger class — Statistical Debugging (Ranking Lines by Suspiciousness)
• read() — Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Excursion: Managed Memory)
• record+replay "rr" debugger — How Debuggers Work (Background)
• rectangles() — Learning from Failures (Excursion: Tree helper functions)
• red-black search tree — Asserting Expectations (Large Data Structures)
• Red-Black Tree — Asserting Expectations (Large Data Structures)
• RedBlackNode class — Asserting Expectations (Large Data Structures)
• RedBlackTree class — Asserting Expectations (Large Data Structures), Asserting Expectations (Large Data Structures), Asserting Expectations (Large Data Structures), Asserting Expectations (Large Data Structures), Asserting Expectations (Large Data Structures), Asserting Expectations (Large Data Structures)
• redNodesHaveOnlyBlackChildren() — Asserting Expectations (Large Data Structures)
• reduce() — Repairing Code Automatically (Simplifying)
• reduce_arg() — Reducing Failure-Inducing Inputs (Testing, Logging, and Caching)
• RED — Asserting Expectations (Large Data Structures), Asserting Expectations (Consider Leaving Some Assertions On)
• Regular expressions — Generalizing Failure Circumstances (Grammars)
• remove_first_char() — Mining Function Specifications (Exercise 3: Verbose Invariant Checkers), Mining Function Specifications (Exercise 3: Verbose Invariant Checkers)
• REMOVE_HTML_FAILING_TESTCASES — Repairing Code Automatically (Removing HTML Markup), Repairing Code Automatically (Excursion: Creating HTML Test Cases)
• remove_html_markup() — Introduction to Debugging (Your Task: Remove HTML Markup), Introduction to Debugging (A First Fix), Introduction to Debugging (Fixing the Code), Introduction to Debugging (Add Assertions), How Debuggers Work (Debugger Interaction), Asserting Expectations (Partial Checks), Asserting Expectations (Partial Checks), Isolating Failure-Inducing Changes (Initialize Git), Isolating Failure-Inducing Changes (Initialize Git), Isolating Failure-Inducing Changes (Excursion: Adding More Revisions), Isolating Failure-Inducing Changes (Excursion: Adding More Revisions), Isolating Failure-Inducing Changes (Excursion: Adding More Revisions), Isolating Failure-Inducing Changes (Excursion: Adding More Revisions), Isolating Failure-Inducing Changes (Excursion: Adding More Revisions), Isolating Failure-Inducing Changes (End of Excursion), Statistical Debugging (Collecting Events), Generalizing Failure Circumstances (A Failing Program), Repairing Code Automatically (Removing HTML Markup)
• remove_html_markup_ampersand() — Debugging Performance Issues (Integrating with Delta Debugging)
• remove_html_markup_deps() — Tracking Failure Origins (Slices)
• remove_html_markup_fixed() — Introduction to Debugging (Use the Most Obvious Fix)
• remove_html_markup_test() — Repairing Code Automatically (Removing HTML Markup)
• remove_html_markup_traced() — Tracing Executions (Tracing Python Programs)
• remove_html_markup_tree() — Repairing Code Automatically (Removing HTML Markup)
• remove_html_markup_without_quotes() — Introduction to Debugging (Debugging into Existence)
• remove_html_markup_with_print() — Introduction to Debugging (Printf Debugging)
• remove_html_markup_with_proper_quotes() — Introduction to Debugging (Part 3: Fix the Problem)
• remove_html_markup_with_quote_assert() — Introduction to Debugging (Refuting a Hypothesis)
• remove_html_markup_with_tag_assert() — Introduction to Debugging (Refining a Hypothesis)
• REMOVE_HTML_PASSING_TESTCASES — Repairing Code Automatically (Removing HTML Markup), Repairing Code Automatically (Excursion: Creating HTML Test Cases)
• remove_html_test() — Debugging Performance Issues (Integrating with Delta Debugging)
• remove_html_testcase() — Repairing Code Automatically (Excursion: Creating HTML Test Cases)
• REMOVE_HTML_TESTS — Repairing Code Automatically (Excursion: Creating HTML Test Cases)
• remove_infeasible() — Learning from Failures (Excursion: Tree helper functions)
• remove_unequal_decisions() — Learning from Failures (Excursion: Tree helper functions)
• repair() — Repairing Code Automatically (Repairing)
• Repairer class — Repairing Code Automatically (Excursion: Implementing Repairer), Repairing Code Automatically (Helper Functions), Repairing Code Automatically (Helper Functions), Repairing Code Automatically (Helper Functions), Repairing Code Automatically (Helper Functions), Repairing Code Automatically (Running Tests), Repairing Code Automatically (Running Tests), Repairing Code Automatically (Running Tests), Repairing Code Automatically ((Re)defining Functions)defining-Functions), Repairing Code Automatically ((Re)defining Functions)defining-Functions), Repairing Code Automatically (Repairing), Repairing Code Automatically (Evolving), Repairing Code Automatically (Evolving), Repairing Code Automatically (Simplifying), Repairing Code Automatically (Simplifying)
• replace() — Learning from Failures (Implementing Feature Classes)
• repOK() — Asserting Expectations (End of Excursion), Asserting Expectations (End of Excursion), Asserting Expectations (Large Data Structures), Asserting Expectations (Large Data Structures), Asserting Expectations (Task 2 – Global Consistency)
• repr_dependencies() — Tracking Failure Origins (Excursion: Listing Dependencies)
• repr_deps() — Tracking Failure Origins (Excursion: Listing Dependencies)
• _repr_html_() — Statistical Debugging (Discrete Spectrum)
• _repr_markdown_() — Asserting Expectations (Excursion: A C Memory Model Simulator), Statistical Debugging (Excursion: Printing an Event Table)
• _repr_mimebundle_() — Tracking Failure Origins (Drawing Dependencies), Tracking Failure Origins (The Slicer Class)
• repr_var() — Tracking Failure Origins (Excursion: Listing Dependencies)
• __repr__() — Asserting Expectations (Times and Time Bombs), Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Excursion: A C Memory Model Simulator), Tracking Failure Origins (Excursion: Listing Dependencies), Tracking Failure Origins (Wrapping Data Objects), Reducing Failure-Inducing Inputs (Public API), Isolating Failure-Inducing Changes (A ChangeDebugger class), Statistical Debugging (Collecting Events), Statistical Debugging (Excursion: Printing an Event Table), Statistical Debugging (Discrete Spectrum), Statistical Debugging (Ranking Lines by Suspiciousness), Mining Function Specifications (Excursion: A Type Annotator Class), Mining Function Specifications (Converting Mined Invariants to Annotations), Generalizing Failure Circumstances (Generalizing Arguments), Learning from Failures (Implementing Feature Classes), Learning from Failures (Retrieving New input Specifications), Learning from Failures (Retrieving New input Specifications)
• reset() — Reducing Failure-Inducing Inputs (Testing, Logging, and Caching), Mining Function Specifications (Tracing Calls)
• reset_timer() — Debugging Performance Issues (Building a Profiler), Debugging Performance Issues (Collecting Time Spent)
• restore() — Tracking Failure Origins (An Instrumenter Base Class), Tracking Failure Origins (The Slicer Class)
• ret() — Tracking Failure Origins (Excursion: Tracking Calls and Arguments), Tracking Failure Origins (Excursion: Calls and Returns), Reducing Failure-Inducing Inputs (General Delta Debugging)
• return_value() — Tracking Failure Origins (Excursion: Tracking Return Values)
• RETURN_VALUE — Mining Function Specifications (Extracting Invariants)
• ret_generator() — Tracking Failure Origins (Excursion: Calls and Returns)
• RE_NONTERMINAL — Learning from Failures (Extracting Feature Sets from Grammars)
• RE_SPACE — Repairing Code Automatically (Choosing a Mutation Method)
• rootHasNoParent() — Asserting Expectations (Large Data Structures)
• rootIsBlack() — Asserting Expectations (Large Data Structures)
• ROOT_INDEX — Learning from Failures (Decision Trees)
• rubber duck debugging — Introduction to Debugging (Rubberducking)
• Rubber duck debugging — Introduction to Debugging (Rubberducking)
• rubberducking — Introduction to Debugging (Rubberducking)
• rule() — Learning from Failures (Excursion: Tree helper functions)
• rules() — Learning from Failures (Excursion: Tree helper functions)
• run() — Reducing Failure-Inducing Inputs (Testing, Logging, and Caching), Learning from Failures (The Alhazen Class)
• run_redmine() — Tracking Bugs (Excursion: Starting Redmine)
• run_tests() — Repairing Code Automatically (Running Tests)
• run_test_set() — Repairing Code Automatically (Running Tests)
• rxdelim() — Where the Bugs are (Mapping Elements to Locations)

S¶

• samples() — Statistical Debugging (Training Classifiers)
• sample_runner() — Learning from Failures (Inputs and Grammars)
• scalene — Debugging Performance Issues (Measuring Performance)
• Scalene — Debugging Performance Issues (Sampling Execution Profiles), Debugging Performance Issues (Background)
• scientific method — Introduction to Debugging (The Scientific Method)
• screenshot() — Tracking Bugs (Excursion: Screenshots with Drop Shadows)
• search_frame() — Inspecting Call Stacks (Inspecting Call Stacks)
• search_func() — Inspecting Call Stacks (Inspecting Call Stacks)
• search_superclasses() — Class Diagrams (Getting Methods and Variables)
• second() — Class Diagrams (Getting a Class Hierarchy)
• seconds() — Asserting Expectations (Times and Time Bombs)
• seconds_since_midnight() — Asserting Expectations (End of Excursion)
• SECRET_HASH_DIGEST — Tracking Failure Origins (Verifying Information Flows)
• select() — Learning from Failures (Excursion: Converting Trees to Paths)
• Selenium](https://www.seleniumhq.org) is a framework for testing Web applications by automating interaction in the browser. Selenium provides an API that allows one to launch a Web browser, query the state of the user interface, and interact with individual user interface elements. The Selenium API is available in a number of languages; we use the [Selenium API for Python — Tracking Bugs (Excursion: Remote Control with Selenium)
• SemFix — Repairing Code Automatically (Background)
• set() — Tracking Failure Origins (A Data Tracker), Tracking Failure Origins (Setting Variables)
• __setitem__() — Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Exercise 1 – Storage Assertions), Asserting Expectations (Task 1 – Local Consistency), Asserting Expectations (Task 2 – Global Consistency)
• _setup() — Learning from Failures (The Alhazen Class)
• set_hours() — Asserting Expectations (Invariant Checkers), Asserting Expectations (End of Excursion)
• SGML — Where the Bugs are (Mapping Elements to Locations)
• ShadowStorage class — Asserting Expectations (Task 2 – Global Consistency)
• shape() — Statistical Debugging (Training Classifiers)
• shelve — Asserting Expectations (Exercise 1 – Storage Assertions)
• showast — Mining Function Specifications (Excursion: Accessing Function Structure)
• show_allocated() — Asserting Expectations (Excursion: Managed Memory)
• show_classifier() — Statistical Debugging (Training Classifiers)
• show_contents() — Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Excursion: Managed Memory)
• show_decision_tree() — Learning from Failures (Decision Trees), Learning from Failures (The Alhazen Class)
• show_header() — Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Excursion: Dynamic Memory in C)
• show_initialized() — Asserting Expectations (Excursion: Managed Memory)
• show_sep() — Asserting Expectations (Excursion: A C Memory Model Simulator)
• sibling book on test generation — Isolating Failure-Inducing Changes (Changes and Bugs)
• SIGALRM — Timeout (Synopsis), Timeout (Synopsis)
• SIGALRM signals](https://docs.python.org/3.10/library/signal.html) (interrupts) to implement timeouts; this has no effect on performance of the tracked code. On other systems (notably Windows), Timeout uses the [sys.settrace() — Timeout (Synopsis), Timeout (Synopsis)
• SignalTimeout class — Timeout (Variant 1: Unix (using signals, efficient)))
• simple_call_string() — Mining Function Specifications (Tracing Calls)
• SIMPLE_HTML_GRAMMAR — Generalizing Failure Circumstances (Parsing)
• SKIP_LIST — Repairing Code Automatically (Applying Crossover on Programs)
• Slicer class — Tracking Failure Origins (The Slicer Class), Tracking Failure Origins (The Slicer Class), Tracking Failure Origins (The Slicer Class), Tracking Failure Origins (The Slicer Class), Tracking Failure Origins (The Slicer Class), Tracking Failure Origins (The Slicer Class), Tracking Failure Origins (The Slicer Class), Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation), Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation), Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation), Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation)
• slicing criteria — Tracking Failure Origins (Slices)
• slider() — How Debuggers Work (Part 3: Graphical User Interface)
• some_extreme_function() — Tracing Executions (Efficient Tracing)
• some_long_running_function() — Timer (Measuring Time), Timeout (Variant 1: Unix (using signals, efficient)))
• some_obscure_function() — Asserting Expectations (Assertions and Documentation)
• _source() — Tracking Failure Origins (A Class for Dependencies)
• source() — Tracking Failure Origins (A Class for Dependencies)
• SpecRequirement class — Learning from Failures (Retrieving New input Specifications)
• SpectrumDebugger class — Statistical Debugging (Discrete Spectrum), Statistical Debugging (Discrete Spectrum), Statistical Debugging (Discrete Spectrum), Statistical Debugging (Discrete Spectrum)
• split() — Reducing Failure-Inducing Inputs (General Delta Debugging)
• sq() — Tracking Failure Origins (Excursion: Function Arguments)
• square_root() — Asserting Expectations (Checking Preconditions), Asserting Expectations (Checking Preconditions), Asserting Expectations (Checking Results), Asserting Expectations (Checking Results), Asserting Expectations (Checking Results), Asserting Expectations (Checking Results), Mining Function Specifications (Specifications and Assertions), Mining Function Specifications (Beyond Generic Failures)
• square_root_annotated() — Mining Function Specifications (Getting Types)
• square_root_fixed() — Repairing Code Automatically (Exercise 3: Evolving Values)
• square_root_test() — Generalizing Failure Circumstances (Square Root)
• square_root_unchecked() — Tracking Failure Origins (Assessing Test Quality)
• square_root_with_invariants() — Mining Function Specifications (Annotating Functions with Pre- and Postconditions)
• square_root_with_local_types() — Mining Function Specifications (Exercise 2: Types for Local Variables)
• square_root_with_postcondition() — Mining Function Specifications (Annotating Functions with Pre- and Postconditions)
• square_root_with_precondition() — Mining Function Specifications (Annotating Functions with Pre- and Postconditions)
• square_root_with_type_annotations() — Mining Function Specifications (Mining Data Types)
• square_root_with_union_type() — Mining Function Specifications (Exercise 1: Union Types)
• StackInspectorDemo class — Inspecting Call Stacks (Synopsis)
• StackInspector class — Inspecting Call Stacks (Inspecting Call Stacks), Inspecting Call Stacks (Inspecting Call Stacks), Inspecting Call Stacks (Inspecting Call Stacks), Inspecting Call Stacks (Inspecting Call Stacks), Inspecting Call Stacks (Inspecting Call Stacks), Inspecting Call Stacks (Inspecting Call Stacks), Inspecting Call Stacks (Inspecting Call Stacks)
• start_redmine() — Tracking Bugs (Excursion: Starting Redmine)
• start_webdriver() — Tracking Bugs (Excursion: Remote Control with Selenium)
• StatementMutator class — Repairing Code Automatically (Mutating Statements), Repairing Code Automatically (Choosing Suspicious Statements to Mutate), Repairing Code Automatically (Choosing Suspicious Statements to Mutate), Repairing Code Automatically (Choosing a Mutation Method), Repairing Code Automatically (Swapping Statements), Repairing Code Automatically (Swapping Statements), Repairing Code Automatically (Inserting Statements), Repairing Code Automatically (Deleting Statements), Repairing Code Automatically (Helpers), Repairing Code Automatically (All Together)
• StatementVisitor class — Repairing Code Automatically (Picking Statements)
• StatisticalDebugger class — Statistical Debugging (A Base Class for Statistical Debugging), Statistical Debugging (A Base Class for Statistical Debugging), Statistical Debugging (A Base Class for Statistical Debugging), Statistical Debugging (Excursion: Printing an Event Table)
• STEP_COLOR — Introduction to Debugging (Visualizing Code), Isolating Failure-Inducing Changes (Leveraging Version Histories)
• step_command() — How Debuggers Work (Debugger Interaction)
• stop_here() — How Debuggers Work (Debugger Interaction)
• Storage class — Asserting Expectations (Exercise 1 – Storage Assertions), Asserting Expectations (Task 1 – Local Consistency)
• StoreVisitor class — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• store_names() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• string_error() — Reducing Failure-Inducing Inputs (Reducing Multiple Arguments)
• __str__() — Tracking Failure Origins (Excursion: Listing Dependencies), Statistical Debugging (Discrete Spectrum), Learning from Failures (Inputs and Grammars), Learning from Failures (Retrieving New input Specifications), Learning from Failures (Retrieving New input Specifications)
• SUBJECT — Learning from Failures (Inputs and Grammars)
• sum2() — Mining Function Specifications (Avoiding Overspecialization), Mining Function Specifications (Synopsis)
• sum3() — Mining Function Specifications (Excursion: Handling Multiple Types)
• susp() — Statistical Debugging (Ranking Lines by Suspiciousness)
• suspiciousness() — Statistical Debugging (Discrete Spectrum), Statistical Debugging (Discrete Spectrum), Statistical Debugging (Continuous Spectrum), Statistical Debugging (The Ochiai Metric), Debugging Performance Issues (Visualizing Time Spent)
• suspiciousness_func() — Repairing Code Automatically (Mutating Statements)
• swap() — Repairing Code Automatically (Swapping Statements), Repairing Code Automatically (Mutating Conditions)
• syntactical structure — Generalizing Failure Circumstances (Grammars)
• syntax tree — Generalizing Failure Circumstances (Derivation Trees)

T¶

• T1 — Statistical Debugging (Collecting Passing and Failing Runs)
• T2 — Statistical Debugging (Collecting Passing and Failing Runs)
• T3 — Statistical Debugging (Continuous Spectrum)
• TarantulaDebugger class — Statistical Debugging (The Tarantula Metric)
• task_cos() — Learning from Failures (Inputs and Grammars)
• task_sin() — Learning from Failures (Inputs and Grammars)
• task_sqrt() — Learning from Failures (Inputs and Grammars)
• task_tan() — Learning from Failures (Inputs and Grammars)
• test — Introduction to Debugging (Running a Function)
• test() — Tracking Failure Origins (Excursion: Tracking Control), Tracking Failure Origins (Excursion: Control Dependencies), Reducing Failure-Inducing Inputs (Testing, Logging, and Caching), Reducing Failure-Inducing Inputs (Testing, Logging, and Caching), Reducing Failure-Inducing Inputs (General Delta Debugging), Isolating Failure-Inducing Changes (High-Level Interface), Generalizing Failure Circumstances (Generalizing Arguments), Inspecting Call Stacks (Synopsis)
• test_call() — Tracking Failure Origins (Excursion: Tracking Calls and Arguments)
• test_debugger_html() — Statistical Debugging (Collecting Passing and Failing Runs)
• test_debugger_html_simple() — Statistical Debugging (Collecting Passing and Failing Runs)
• test_debugger_middle() — Statistical Debugging (Continuous Spectrum)
• test_math() — Tracking Failure Origins (Calls and Augmented Assign)
• test_middle_lines() — Repairing Code Automatically (Simplifying)
• test_patches() — Isolating Failure-Inducing Changes (A ChangeDebugger class)
• test_reduce() — Repairing Code Automatically (Simplifying)
• test_remove_html_markup() — Isolating Failure-Inducing Changes (A ChangeDebugger class)
• test_remove_html_markup_patches() — Isolating Failure-Inducing Changes (Delta Debugging on Patches)
• test_square_root() — Asserting Expectations (Assertions)
• test_tree() — Generalizing Failure Circumstances (Generalizing Trees)
• TEST — Tracking Failure Origins (Setting Variables)
• the etymology of the word "bug"](http://www.catb.org/~esr/jargon/html/B/bug.html) in The Jargon File. Also check out the [Wikipedia entry on debugging — Introduction to Debugging (Debugging Aftermath)
• The Fuzzing Book — Mining Function Specifications (Avoiding Overspecialization), Learning from Failures (Inputs and Grammars)
• the fuzzing book — Generalizing Failure Circumstances (Grammars), Generalizing Failure Circumstances (Parsing)
• the GNU command-line debugger (GDB) — How Debuggers Work (Exercise 2: More Commands)
• "The state of type hints in Python" — Mining Function Specifications (Background)
• the Whyline — Tracking Failure Origins (Background)
• theory — Introduction to Debugging (The Scientific Method), Introduction to Debugging (Fixing the Bug)
• this blog post — How Debuggers Work (Exercise 1: Changing State)
• this discussion in StackOverflow — Reducing Failure-Inducing Inputs (General Delta Debugging)
• TimeCollector class — Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Collecting Time Spent)
• timeout_handler() — Timeout (Variant 1: Unix (using signals, efficient)))
• Timer class — Timer (Measuring Time)
• Time class — Asserting Expectations (Times and Time Bombs), Asserting Expectations (Times and Time Bombs), Asserting Expectations (Times and Time Bombs), Asserting Expectations (Times and Time Bombs), Asserting Expectations (Invariant Checkers), Asserting Expectations (End of Excursion), Asserting Expectations (End of Excursion), Asserting Expectations (End of Excursion), Asserting Expectations (End of Excursion)
• tooltip() — Tracking Failure Origins (Drawing Dependencies), Statistical Debugging (Excursion: Printing an Event Table), Statistical Debugging (Discrete Spectrum), Statistical Debugging (Discrete Spectrum), Statistical Debugging (Continuous Spectrum), Debugging Performance Issues (Visualizing Time Spent)
• toplevel_defs() — Repairing Code Automatically ((Re)defining Functions)defining-Functions)
• total() — Debugging Performance Issues (Collecting Time Spent), Debugging Performance Issues (Visualizing Time Spent)
• to_set() — Reducing Failure-Inducing Inputs (General Delta Debugging)
• trace — Tracing Executions (Tracing Python Programs)
• traceit() — Tracing Executions (Tracing Python Programs), Tracing Executions (Tracing Python Programs), Tracing Executions (Tracing Python Programs), Tracing Executions (Tracing Python Programs), Tracing Executions (A Tracer Class), Tracing Executions (Accessing Source Code), Tracing Executions (Tracing Calls and Returns), Tracing Executions (Tracing Variable Changes), Tracing Executions (Conditional Tracing), How Debuggers Work (Debugger Interaction), Reducing Failure-Inducing Inputs (Collecting a Call), Statistical Debugging (Collecting Events), Statistical Debugging (Collecting Events), Mining Function Specifications (Tracing Calls), Debugging Performance Issues (Building a Profiler)
• _traceit() — Tracing Executions (A Tracer Class)
• tracemalloc module — Debugging Performance Issues (Exercise 1: Profiling Memory Usage)
• TRACER_CODE — Tracing Executions (Efficient Tracing)
• TRACER — Tracing Executions (Efficient Tracing), Tracing Executions (Efficient Tracing)
• Tracer class — Tracing Executions (A Tracer Class), Tracing Executions (Accessing Source Code), Tracing Executions (Tracing Calls and Returns), Tracing Executions (Tracing Variable Changes), Tracing Executions (Tracing Variable Changes), Tracing Executions (Exercise 1: Exception Handling)
• trace_call() — Mining Function Specifications (Tracing Calls)
• trace_return() — Mining Function Specifications (Tracing Calls)
• tracing function — Tracing Executions (Tracing Python Programs)
• TrackCallTransformer class — Tracking Failure Origins (Excursion: Tracking Calls and Arguments)
• TrackControlTransformer class — Tracking Failure Origins (Excursion: Tracking Control), Tracking Failure Origins (Excursion: Tracking Control), Tracking Failure Origins (Excursion: Tracking Control), Tracking Failure Origins (Excursion: Tracking Control), Tracking Failure Origins (Excursion: Tracking Control)
• TrackGetTransformer class — Tracking Failure Origins (Tracking Variable Accesses)
• TrackParamsTransformer class — Tracking Failure Origins (Excursion: Tracking Parameters)
• TrackReturnTransformer class — Tracking Failure Origins (Excursion: Tracking Return Values)
• TrackSetTransformer class — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• train_tree() — Learning from Failures (Learning a Decision Tree)
• transform() — Tracking Failure Origins (The Slicer Class)
• transformers() — Tracking Failure Origins (The Slicer Class)
• transform_grammar() — Learning from Failures (Excursion: Transforming Grammars)
• traverse_tree() — Class Diagrams (Getting a Class Tree)
• _tree() — Learning from Failures (Decision Trees)
• TreeGeneralizer class — Generalizing Failure Circumstances (Generalizing Trees), Generalizing Failure Circumstances (Generalizing Trees), Generalizing Failure Circumstances (Testing for Generalization), Generalizing Failure Circumstances (Generalizable Paths), Generalizing Failure Circumstances (Generalizable Paths), Generalizing Failure Circumstances (Generalizable Paths), Generalizing Failure Circumstances (Fuzzing with Patterns)
• treeIsAcyclic() — Asserting Expectations (Large Data Structures)
• TreeMutator class — Generalizing Failure Circumstances (Mutating the Tree), Generalizing Failure Circumstances (Referencing Subtrees), Generalizing Failure Circumstances (Creating new Subtrees), Generalizing Failure Circumstances (Mutating the Tree)
• TreePath class — Learning from Failures (Excursion: Converting Trees to Paths)
• TreeRequirement class — Learning from Failures (Excursion: Converting Trees to Paths)
• tree_to_paths() — Learning from Failures (Excursion: Converting Trees to Paths)
• true_property_instantiations() — Mining Function Specifications (Checking Invariants)
• Turing machines — Generalizing Failure Circumstances (Grammars)
• TypeAnnotator class — Mining Function Specifications (Excursion: A Type Annotator Class)
• typed_function() — Mining Function Specifications (Excursion: A Type Annotator Class)
• typed_functions() — Mining Function Specifications (Excursion: A Type Annotator Class)
• typed_functions_ast() — Mining Function Specifications (Excursion: A Type Annotator Class)
• typed_function_ast() — Mining Function Specifications (Excursion: A Type Annotator Class)
• types — Mining Function Specifications (Mining Data Types)
• TypeTracer class — Mining Function Specifications (Excursion: A Type Annotator Class)
• TypeTransformer class — Mining Function Specifications (Excursion: Annotating Functions with Given Types), Mining Function Specifications (Excursion: Annotating Functions with Given Types), Mining Function Specifications (Excursion: Annotating Functions with Given Types)
• type_string() — Mining Function Specifications (Excursion: Annotating Functions with Mined Types)

U¶

• UNDEF — Learning from Failures (Inputs and Grammars)
• universal grammars — Generalizing Failure Circumstances (Grammars)
• unknown() — Class Diagrams (Getting Docs), Inspecting Call Stacks (Inspecting Call Stacks)
• UNRESOLVED — Reducing Failure-Inducing Inputs (Delta Debugging), Reducing Failure-Inducing Inputs (Reducing Code Lines), Isolating Failure-Inducing Changes (Leveraging Version Histories)
• update_changes() — Where the Bugs are (Counting Changes)
• update_elems() — Where the Bugs are (Counting Changes), Where the Bugs are (Putting it all Together)
• update_size() — Where the Bugs are (Counting Changes)
• update_stats() — Where the Bugs are (Counting Changes)
• upper_middle() — Learning from Failures (Excursion: Converting Trees to Paths)

V - Y¶

V¶

• Valgrind — Asserting Expectations (Checking Memory Usage with Valgrind)
• Valgrind](https://valgrind.org) originated as an academic tool which has seen lots of industrial usage. A [list of papers — Asserting Expectations (Background)
• validate() — Tracking Failure Origins (A Class for Dependencies), Tracking Failure Origins (Excursion: Diagnostics), Repairing Code Automatically (Running Tests)
• value() — Learning from Failures (Retrieving New input Specifications)
• ValueCollector class — Statistical Debugging (Other Events besides Coverage)
• VALUE — How Debuggers Work (Exercise 1: Changing State)
• var_string() — Class Diagrams (Drawing Class Hierarchy with Method Names)
• VAR — How Debuggers Work (Exercise 1: Changing State), Class Diagrams (Getting a Class Hierarchy)
• VerboseInvariantAnnotator class — Mining Function Specifications (Exercise 3: Verbose Invariant Checkers), Mining Function Specifications (Exercise 3: Verbose Invariant Checkers)
• verbose_condition() — Mining Function Specifications (Exercise 3: Verbose Invariant Checkers)
• verbose_postcondition() — Mining Function Specifications (Exercise 3: Verbose Invariant Checkers)
• verbose_precondition() — Mining Function Specifications (Exercise 3: Verbose Invariant Checkers)
• VERSIONS — Isolating Failure-Inducing Changes (Leveraging Version Histories)
• visit() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Reducing Failure-Inducing Inputs (Deleting Nodes), Reducing Failure-Inducing Inputs (Deleting Nodes), Repairing Code Automatically (Choosing a Mutation Method)
• visit_AnnAssign() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• visit_Assert() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• visit_Assign() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Reducing Failure-Inducing Inputs (Transforming Nodes)
• visit_AsyncFor() — Tracking Failure Origins (Excursion: Tracking Control)
• visit_AsyncFunctionDef() — Tracking Failure Origins (Excursion: Tracking Return Values), Repairing Code Automatically (Picking Statements), Repairing Code Automatically ((Re)defining Functions)defining-Functions)
• visit_AugAssign() — Tracking Failure Origins (Excursion: Tracking Assignments and Assertions)
• visit_BoolOp() — Reducing Failure-Inducing Inputs (Transforming Nodes), Repairing Code Automatically (Collecting Conditions)
• visit_Call() — Tracking Failure Origins (Excursion: Tracking Calls and Arguments), Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation)
• visit_ClassDef() — Repairing Code Automatically (Picking Statements), Repairing Code Automatically ((Re)defining Functions)defining-Functions)
• visit_Compare() — Reducing Failure-Inducing Inputs (Transforming Nodes)
• visit_comprehension() — Tracking Failure Origins (Excursion: Tracking Control)
• visit_Expr() — Mining Function Specifications (Excursion: Annotating Functions with Given Types)
• visit_For() — Tracking Failure Origins (Excursion: Tracking Control)
• visit_FunctionDef() — Tracing Executions (Exercise 2: Syntax-Based Instrumentation), Tracking Failure Origins (Excursion: Tracking Return Values), Tracking Failure Origins (Excursion: Tracking Parameters), Mining Function Specifications (Excursion: Annotating Functions with Given Types), Mining Function Specifications (Exercise 7: Embedding Invariants as Assertions), Repairing Code Automatically (Picking Statements), Repairing Code Automatically ((Re)defining Functions)defining-Functions)
• visit_If() — Tracking Failure Origins (Excursion: Tracking Control), Reducing Failure-Inducing Inputs (Transforming Nodes)
• visit_Module() — Reducing Failure-Inducing Inputs (Deleting Nodes), Repairing Code Automatically (Picking Statements)
• visit_Name() — Tracking Failure Origins (Tracking Variable Accesses), Tracking Failure Origins (Excursion: Tracking Assignments and Assertions), Mining Function Specifications (Extracting Meta-Variables), Mining Function Specifications (Instantiating Properties)
• visit_Node() — Reducing Failure-Inducing Inputs (Deleting Nodes)
• visit_node() — Repairing Code Automatically (Picking Statements)
• visit_Return() — Tracking Failure Origins (Excursion: Tracking Return Values)
• visit_return_or_yield() — Tracking Failure Origins (Excursion: Tracking Return Values)
• visit_UnaryOp() — Repairing Code Automatically (Collecting Conditions)
• visit_While() — Tracking Failure Origins (Excursion: Tracking Control)
• visit_With() — Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation)
• visit_Yield() — Tracking Failure Origins (Excursion: Tracking Return Values)
• visit_YieldFrom() — Tracking Failure Origins (Excursion: Tracking Return Values)

W¶

• watchpoints — Tracing Executions (Watching Events)
• web driver — Tracking Bugs (Excursion: Remote Control with Selenium)
• weight() — Repairing Code Automatically (Running Tests)
• WEIGHT_FAILING — Repairing Code Automatically (Fitness), Repairing Code Automatically (Fitness), Repairing Code Automatically (Exercise 1: Automated Repair Parameters)
• WEIGHT_PASSING — Repairing Code Automatically (Fitness), Repairing Code Automatically (Fitness), Repairing Code Automatically (Fitness), Repairing Code Automatically (Exercise 1: Automated Repair Parameters)
• WithVisitor class — Tracking Failure Origins (Excursion: Implementing Dynamic Instrumentation)
• with_mysql() — Tracking Bugs (Excursion: Setting up Redmine)
• with_ruby() — Tracking Bugs (Excursion: Setting up Redmine)
• wrapper() — Tracking Failure Origins (Excursion: Calls and Returns), Mining Function Specifications (Annotating Functions with Pre- and Postconditions), Mining Function Specifications (Exercise 3: Verbose Invariant Checkers)
• write() — Asserting Expectations (Excursion: A C Memory Model Simulator), Asserting Expectations (Excursion: Managed Memory)
• write_source() — Isolating Failure-Inducing Changes (Initialize Git)

X¶

• X() — Statistical Debugging (Training Classifiers)

Y¶

• Y() — Statistical Debugging (Training Classifiers)