Practice debugging tools vocabulary: attaching debuggers, breakpoints, step into/over/out, watch expressions, and memory inspection.
0 / 5 completed
1 / 5
A developer says 'The debugger is attached to the process.' What does attaching a debugger allow?
Attaching a debugger to a running process lets you inspect its internal state in real time without restarting it. You can view current variable values, see the call stack, set breakpoints, and step through code — all while the process is running (or paused at a breakpoint).
2 / 5
A code review comment says 'Set a breakpoint at line 45.' What does a breakpoint do?
A breakpoint tells the debugger to pause execution when a specific line is reached. Once paused, you can inspect variable values, evaluate expressions, and step through subsequent lines one at a time. Conditional breakpoints pause only when a condition is true (e.g., when i === 5).
3 / 5
During a debugging session, you choose 'step into' instead of 'step over.' What is the difference?
Step into drills into a function call — useful when you want to debug inside a called function. Step over executes the called function in its entirety and stops at the next line of the current function — useful when you trust the called function and only want to observe its effect.
4 / 5
A developer adds 'a watch expression that evaluates user.isAuthenticated every step.' What is a watch expression?
Watch expressions are evaluated and displayed automatically as you step through code. Instead of manually expanding the variables panel each time, you set `user.isAuthenticated` as a watch and see its current value update at every step — ideal for tracking a specific variable across many execution points.
5 / 5
A senior developer says 'Use the memory inspector to check heap allocations.' When is the memory inspector useful?
The memory inspector is used for diagnosing memory-related issues: leaks (objects not being garbage collected), excessive allocation (too many large objects), or memory corruption. It shows heap snapshots, allocation timelines, and object references — essential for resolving memory issues that are invisible in the code itself.