Debugging with Breakpoints

Debugging with Breakpoints

About

• Breakpoints pause code execution for inspection.
• Supported in IDEs (VSCode, Android Studio) and DevTools.
• Allows examining variables, call stack, and control flow.
• Essential for diagnosing runtime issues.

Main Topics

1. Setting Breakpoints

   • Definition: How to add breakpoints in IDEs.
   • Example:

     void calculate() {
       int x = 5; // Set breakpoint on this line
       print(x * 2);
     }

2. Breakpoint Types

   • Definition: Line vs conditional vs exception breakpoints.
   • Example:

     // Conditional breakpoint (VSCode):
     // Right-click → Add Conditional Breakpoint
     // Condition: `x > 10`

3. Execution Control

   • Definition: Step Over/Into/Out commands.
   • Example:

     void main() {
       print('Start'); // Step Over
       calculate();    // Step Into
     }

4. Inspecting State

   • Definition: Viewing variables and call stack.
   • Example:

     // During breakpoint pause:
     // - Hover variables for values
     // - View Call Stack panel

5. Logging Breakpoints

   • Definition: Breakpoints that log without pausing.
   • Example:

     // In VSCode:
     // Right-click → Add Logpoint
     // Message: 'x value: {x}'

How to Use

• Set: Click gutter in IDE or use debugger() statement
• Manage: Enable/disable in “Breakpoints” view
• Navigate: F8 (Step Over), F7 (Step Into) in VSCode
• Inspect: Watch expressions for complex variables

How It Works

• Compilation: Debug info embedded in Dart bytecode
• Pausing: VM suspends at breakpoint locations
• State Capture: Snapshots variable values when paused
• Resume: VM continues execution on command

Example Debug Session:

void main() {
  debugger(); // Programmatic breakpoint
  for (var i = 0; i < 5; i++) {
    print(i); // Set line breakpoint here
  }
}

Conclusion

Breakpoint debugging in Dart offers precise control over code execution flow, enabling developers to inspect variables and program state at critical moments. This method is fundamental for identifying and resolving runtime issues efficiently in both simple and complex codebases.