Building a Mental Model of the Problem

Before changing the code, the engineer needs to understand what the software is expected to do, what it is actually doing, and under which conditions the failure occurs.

• Characterizing the problem
• Visualizing the problem
• Localizing the problem
• Making an action plan
• Using AI assistance to formalize and review the action plan
• Logging investigation actions
• Using AI assistance to structure investigation records
• Discussing the problem with colleagues

Debugging C++ by Browsing the Code

Careful code browsing helps establish how control and data move through an unfamiliar codebase. It is particularly useful when the defect cannot yet be reproduced reliably or when the relevant component is not immediately known.

Code Inspection with Vim, cscope and ctags on Linux

• Installing Vim
• Installing cscope
• Installing ctags
• Generating the cscope database
• Collecting source and header files
• Building the cscope database file
• Generating the ctags database
• Integrating cscope databases with Vim
• Setting the cscope environment variable
• Creating a recommended persistent Vim configuration
• Conducting a structured code walkthrough in Vim

Browsing C++ Projects in Visual Studio Code

• Setting up the project for inspection
• Configuring the project for accurate code navigation
• Launching the editor
• Using essential code-navigation shortcuts

Debugging C++ by Searching

Targeted searches can reveal where identifiers, messages, configuration values, return codes, and suspicious data patterns enter or leave a system.

Targeted Recursive Search

• Searching recursively through a source tree
• Combining multiple string patterns in a single search
• Excluding directories from recursive searches
• Targeting specific subsets of a project
• Excluding binary files from searches

Searching Compiled Binaries

• Inspecting binaries with the strings command
• Combining different search utilities
• Restricting searches by file type

Debugging C++ through Log Inspection

Logs provide a chronological account of program activity. Reading them as a temporal narrative can help reconstruct the sequence of events that led to a failure.

• Using log viewers
• Using AI assistance to summarize large log excerpts
• Reading logs as a temporal narrative
• Debugging through trace instrumentation
• Building and running a trace-instrumentation example

Debugging through Historical Comparison

When a feature worked in an earlier release, comparing software history can be more efficient than examining the current version in isolation.

• Performing a binary search over releases
• Using git bisect to identify the first bad commit

Debugging C++ through Version Control

Git history can show when a suspicious line was introduced, why a change was made, and which surrounding changes may have contributed to a regression.

• Using git log to inspect repository history
• Using git show to examine a commit
• Inspecting a suspect commit
• Using git blame to trace individual lines

Debugging through Visual Diff Tools

Visual diff tools make it easier to compare source files, configuration files, generated output, and different software versions. They are particularly valuable when a defect may have resulted from a subtle change that is difficult to identify in a conventional textual diff.