Debug Adapter Protocol (DAP) Vocabulary
Practise DAP vocabulary: debug adapters, breakpoints, stack frames, variable inspection, and stepping operations.
0 / 25 completed
1 / 25
The Debug Adapter Protocol standardises communication between editors and ___, which handle the language-specific debugging logic.
A debug adapter translates generic DAP messages (set breakpoint, step over) into language-specific debugger commands (GDB, LLDB, Node.js inspector). One editor (VS Code) can debug any language through DAP-compatible adapters.
2 / 25
A ___ breakpoint pauses execution at a specific source code location when reached during program execution.
A source breakpoint (line breakpoint) halts execution when the program reaches a specific line in the source file. The debug adapter maps the source location to the actual binary/runtime position to set the breakpoint.
3 / 25
In DAP, the ___ frame shows the sequence of active function calls at the point where execution is paused — from the innermost function to the program entry.
The call stack (stack frames) shows the active function call hierarchy at the breakpoint. Each frame shows: function name, source file, line number, and local variables. Navigating frames lets users inspect state at different levels of the call stack.
4 / 25
'___ Over' in a debugger executes the current line without entering any function calls on that line.
Step Over (next) executes one statement without descending into function calls on that line. If the line calls a function, the debugger runs the entire function and stops at the next line. Use it when you don't need to inspect the called function.
5 / 25
Variable ___ in a DAP session allows users to view and modify the values of variables in the current scope while execution is paused.
Variable inspection (via scopes/variables requests in DAP) displays variable names and values in the current scope. The Variables panel shows locals, parameters, and closures. Some adapters also allow modifying variable values mid-session for 'hot patching'.
6 / 25
Sarah's comment indicates a discrepancy between her expected behavior and what's actually happening in the debugger. The key here is that she's observing 'stepping over,' which implies the DAP isn't correctly pausing at those specific `if` statements. This most likely points to an issue with the breakpoint configuration within the DAP, rather than a fundamental problem with the code itself or the protocol's core functionality. Option 1 is too extreme; option 3 accurately describes the core issue – the debugger not recognizing the breakpoints as intended.
7 / 25
Liam sent a Slack message to the team: 'I'm struggling to get the DAP debugger to reliably step into my `calculate_discount` function. It always steps over it! I've checked my launch configuration and everything seems correct.' Considering Liam's frustration, what is he *most likely* referring to when describing the debugger's behavior related to the Debug Adapter Protocol?Liam's frustration stems from the Debug Adapter Protocol's (DAP) optimization strategy. DAP often 'steps over' simple code blocks like `if` statements or short functions during debugging to speed up the process and avoid unnecessary function call stack building. This is a deliberate design choice, not an error; however, it can be confusing for developers unfamiliar with this behavior, leading them to believe something is wrong with the configuration when the protocol itself is functioning as intended. The key misunderstanding here is that 'stepping over' isn't a failure of the DAP, but rather its core functionality.
8 / 25
Mark sent a PR with the following description: 'The debugger isn't stopping at the expected breakpoints in my unit tests. I've verified the test configuration and think it might be related to how the Debug Adapter Protocol handles asynchronous calls.' Considering Mark's statement, what is he *most likely* concerned about regarding the DAP setup?
Mark's comment strongly suggests a problem with how DAP handles asynchronous operations. The Debug Adapter Protocol isn't always designed to seamlessly manage the complexities of non-blocking code, such as callbacks or promises. It's common for issues to arise when breakpoints are set within these types of scenarios, and Mark is accurately identifying this potential root cause.
9 / 25
David is reviewing a colleague's PR that uses the Debug Adapter Protocol (DAP) for debugging. He sees a comment from the developer: 'I'm getting inconsistent stepping behavior with DAP – sometimes it pauses where I expect, and sometimes it just steps over functions without stopping. It's really frustrating!' Considering this feedback, what is David *most likely* referring to when discussing potential issues related to the DAP configuration?
David's comment points to inconsistent stepping behavior, which is a common symptom of problems with the Debug Adapter Protocol. Specifically, option B is the most likely cause – the debugger might be misinterpreting function calls or breakpoints due to incorrect settings or errors in the code itself. Options A and D are less directly related; while a newer launch.json *could* help, it's unlikely to fix fundamentally broken stepping behavior. Option C accurately describes the core issue: DAP configuration problems can lead to unpredictable pausing/stepping.10 / 25
During a standup update, Alex mentioned he's having trouble debugging a complex function using the Debug Adapter Protocol. He says, 'I keep hitting this wall where the debugger just steps over entire blocks of code without stopping. It's like it doesn't even *see* them!' Considering Alex's description, what aspect of the DAP protocol is he most likely struggling with?
Alex's statement points to the core functionality of the DAP – it's designed to optimize execution by intelligently skipping over code sections that aren't currently being executed. This 'stepping over' behavior is a normal part of the protocol, focusing on the relevant parts of the program for faster debugging. The other options represent different aspects of debugging or compilation, but don't directly address the observed issue of the debugger bypassing entire blocks of code.
11 / 25
Sarah's comment indicates a discrepancy between her expected behavior and what's actually happening in the debugger. The key here is that she's observing 'stepping over,' which implies the DAP isn't correctly pausing at those specific `if` statements. This most likely points to an issue with the breakpoint configuration within the DAP, rather than a fundamental problem with the code itself or the protocol's core functionality. Option 1 is too extreme; option 3 accurately describes the core issue – the debugger not recognizing the breakpoints as intended.
12 / 25
Liam sent a Slack message to the team: 'I'm struggling to get the DAP debugger to reliably step into my `calculate_discount` function. It always steps over it! I've checked my launch configuration and everything seems correct.' Considering Liam's frustration, what is he *most likely* referring to when describing the debugger's behavior related to the Debug Adapter Protocol?Liam's frustration stems from the Debug Adapter Protocol's (DAP) optimization strategy. DAP often 'steps over' simple code blocks like `if` statements or short functions during debugging to speed up the process and avoid unnecessary function call stack building. This is a deliberate design choice, not an error; however, it can be confusing for developers unfamiliar with this behavior, leading them to believe something is wrong with the configuration when the protocol itself is functioning as intended. The key misunderstanding here is that 'stepping over' isn't a failure of the DAP, but rather its core functionality.
13 / 25
Mark sent a PR with the following description: 'The debugger isn't stopping at the expected breakpoints in my unit tests. I've verified the test configuration and think it might be related to how the Debug Adapter Protocol handles asynchronous calls.' Considering Mark's statement, what is he *most likely* concerned about regarding the DAP setup?
Mark's comment strongly suggests a problem with how DAP handles asynchronous operations. The Debug Adapter Protocol isn't always designed to seamlessly manage the complexities of non-blocking code, such as callbacks or promises. It's common for issues to arise when breakpoints are set within these types of scenarios, and Mark is accurately identifying this potential root cause.
14 / 25
David is reviewing a colleague's PR that uses the Debug Adapter Protocol (DAP) for debugging. He sees a comment from the developer: 'I'm getting inconsistent stepping behavior with DAP – sometimes it pauses where I expect, and sometimes it just steps over functions without stopping. It's really frustrating!' Considering this feedback, what is David *most likely* referring to when discussing potential issues related to the DAP configuration?
David's comment points to inconsistent stepping behavior, which is a common symptom of problems with the Debug Adapter Protocol. Specifically, option B is the most likely cause – the debugger might be misinterpreting function calls or breakpoints due to incorrect settings or errors in the code itself. Options A and D are less directly related; while a newer launch.json *could* help, it's unlikely to fix fundamentally broken stepping behavior. Option C accurately describes the core issue: DAP configuration problems can lead to unpredictable pausing/stepping.15 / 25
During a standup update, Alex mentioned he's having trouble debugging a complex function using the Debug Adapter Protocol. He says, 'I keep hitting this wall where the debugger just steps over entire blocks of code without stopping. It's like it doesn't even *see* them!' Considering Alex's description, what aspect of the DAP protocol is he most likely struggling with?
Alex's statement points to the core functionality of the DAP – it's designed to optimize execution by intelligently skipping over code sections that aren't currently being executed. This 'stepping over' behavior is a normal part of the protocol, focusing on the relevant parts of the program for faster debugging. The other options represent different aspects of debugging or compilation, but don't directly address the observed issue of the debugger bypassing entire blocks of code.
16 / 25
Sarah's comment indicates a discrepancy between her expected behavior and what's actually happening in the debugger. The key here is that she's observing 'stepping over,' which implies the DAP isn't correctly pausing at those specific `if` statements. This most likely points to an issue with the breakpoint configuration within the DAP, rather than a fundamental problem with the code itself or the protocol's core functionality. Option 1 is too extreme; option 3 accurately describes the core issue – the debugger not recognizing the breakpoints as intended.
17 / 25
Liam sent a Slack message to the team: 'I'm struggling to get the DAP debugger to reliably step into my `calculate_discount` function. It always steps over it! I've checked my launch configuration and everything seems correct.' Considering Liam's frustration, what is he *most likely* referring to when describing the debugger's behavior related to the Debug Adapter Protocol?Liam's frustration stems from the Debug Adapter Protocol's (DAP) optimization strategy. DAP often 'steps over' simple code blocks like `if` statements or short functions during debugging to speed up the process and avoid unnecessary function call stack building. This is a deliberate design choice, not an error; however, it can be confusing for developers unfamiliar with this behavior, leading them to believe something is wrong with the configuration when the protocol itself is functioning as intended. The key misunderstanding here is that 'stepping over' isn't a failure of the DAP, but rather its core functionality.
18 / 25
Mark sent a PR with the following description: 'The debugger isn't stopping at the expected breakpoints in my unit tests. I've verified the test configuration and think it might be related to how the Debug Adapter Protocol handles asynchronous calls.' Considering Mark's statement, what is he *most likely* concerned about regarding the DAP setup?
Mark's comment strongly suggests a problem with how DAP handles asynchronous operations. The Debug Adapter Protocol isn't always designed to seamlessly manage the complexities of non-blocking code, such as callbacks or promises. It's common for issues to arise when breakpoints are set within these types of scenarios, and Mark is accurately identifying this potential root cause.
19 / 25
David is reviewing a colleague's PR that uses the Debug Adapter Protocol (DAP) for debugging. He sees a comment from the developer: 'I'm getting inconsistent stepping behavior with DAP – sometimes it pauses where I expect, and sometimes it just steps over functions without stopping. It's really frustrating!' Considering this feedback, what is David *most likely* referring to when discussing potential issues related to the DAP configuration?
David's comment points to inconsistent stepping behavior, which is a common symptom of problems with the Debug Adapter Protocol. Specifically, option B is the most likely cause – the debugger might be misinterpreting function calls or breakpoints due to incorrect settings or errors in the code itself. Options A and D are less directly related; while a newer launch.json *could* help, it's unlikely to fix fundamentally broken stepping behavior. Option C accurately describes the core issue: DAP configuration problems can lead to unpredictable pausing/stepping.20 / 25
During a standup update, Alex mentioned he's having trouble debugging a complex function using the Debug Adapter Protocol. He says, 'I keep hitting this wall where the debugger just steps over entire blocks of code without stopping. It's like it doesn't even *see* them!' Considering Alex's description, what aspect of the DAP protocol is he most likely struggling with?
Alex's statement points to the core functionality of the DAP – it's designed to optimize execution by intelligently skipping over code sections that aren't currently being executed. This 'stepping over' behavior is a normal part of the protocol, focusing on the relevant parts of the program for faster debugging. The other options represent different aspects of debugging or compilation, but don't directly address the observed issue of the debugger bypassing entire blocks of code.
21 / 25
Sarah's comment indicates a discrepancy between her expected behavior and what's actually happening in the debugger. The key here is that she's observing 'stepping over,' which implies the DAP isn't correctly pausing at those specific `if` statements. This most likely points to an issue with the breakpoint configuration within the DAP, rather than a fundamental problem with the code itself or the protocol's core functionality. Option 1 is too extreme; option 3 accurately describes the core issue – the debugger not recognizing the breakpoints as intended.
22 / 25
Liam sent a Slack message to the team: 'I'm struggling to get the DAP debugger to reliably step into my `calculate_discount` function. It always steps over it! I've checked my launch configuration and everything seems correct.' Considering Liam's frustration, what is he *most likely* referring to when describing the debugger's behavior related to the Debug Adapter Protocol?Liam's frustration stems from the Debug Adapter Protocol's (DAP) optimization strategy. DAP often 'steps over' simple code blocks like `if` statements or short functions during debugging to speed up the process and avoid unnecessary function call stack building. This is a deliberate design choice, not an error; however, it can be confusing for developers unfamiliar with this behavior, leading them to believe something is wrong with the configuration when the protocol itself is functioning as intended. The key misunderstanding here is that 'stepping over' isn't a failure of the DAP, but rather its core functionality.
23 / 25
Mark sent a PR with the following description: 'The debugger isn't stopping at the expected breakpoints in my unit tests. I've verified the test configuration and think it might be related to how the Debug Adapter Protocol handles asynchronous calls.' Considering Mark's statement, what is he *most likely* concerned about regarding the DAP setup?
Mark's comment strongly suggests a problem with how DAP handles asynchronous operations. The Debug Adapter Protocol isn't always designed to seamlessly manage the complexities of non-blocking code, such as callbacks or promises. It's common for issues to arise when breakpoints are set within these types of scenarios, and Mark is accurately identifying this potential root cause.
24 / 25
David is reviewing a colleague's PR that uses the Debug Adapter Protocol (DAP) for debugging. He sees a comment from the developer: 'I'm getting inconsistent stepping behavior with DAP – sometimes it pauses where I expect, and sometimes it just steps over functions without stopping. It's really frustrating!' Considering this feedback, what is David *most likely* referring to when discussing potential issues related to the DAP configuration?
David's comment points to inconsistent stepping behavior, which is a common symptom of problems with the Debug Adapter Protocol. Specifically, option B is the most likely cause – the debugger might be misinterpreting function calls or breakpoints due to incorrect settings or errors in the code itself. Options A and D are less directly related; while a newer launch.json *could* help, it's unlikely to fix fundamentally broken stepping behavior. Option C accurately describes the core issue: DAP configuration problems can lead to unpredictable pausing/stepping.25 / 25
During a standup update, Alex mentioned he's having trouble debugging a complex function using the Debug Adapter Protocol. He says, 'I keep hitting this wall where the debugger just steps over entire blocks of code without stopping. It's like it doesn't even *see* them!' Considering Alex's description, what aspect of the DAP protocol is he most likely struggling with?
Alex's statement points to the core functionality of the DAP – it's designed to optimize execution by intelligently skipping over code sections that aren't currently being executed. This 'stepping over' behavior is a normal part of the protocol, focusing on the relevant parts of the program for faster debugging. The other options represent different aspects of debugging or compilation, but don't directly address the observed issue of the debugger bypassing entire blocks of code.
Frequently Asked Questions
What does the "Debug Adapter Protocol (DAP) Vocabulary" exercise cover?
Practise DAP vocabulary: debug adapters, breakpoints, stack frames, variable inspection, and stepping operations.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to use with no account, sign-up, or paywall.
How many questions are in "Debug Adapter Protocol (DAP) Vocabulary"?
This exercise has 25 questions. Each one gives instant feedback with an explanation, so you can see exactly why an answer is right or wrong.
Do I need to create an account to save my progress?
No account is required. The progress bar and score are tracked in your browser for the current session -- the exercise is designed to be a quick, repeatable drill rather than something you resume later.
What happens if I get an answer wrong?
You'll see the correct answer highlighted immediately, along with a short explanation of why it's correct. Wrong answers aren't penalized beyond your score, and you can keep going through every question.
How is this exercise different from reading an article?
Articles explain vocabulary and concepts through prose, while exercises like this one are interactive drills -- multiple-choice questions -- that test and reinforce your recall of specific terms and phrasing.
Can I retry this exercise?
Yes -- use the "Try again" button on the results screen to reset your score and go through all the questions again from the start.
Where can I find more Developer Tools Engineering exercises?
Browse the full Developer Tools Engineering hub for related drills, or check the site-wide exercises index for other IT English topics.
Is this exercise suitable for beginners?
This exercise assumes basic familiarity with IT terminology. If a term feels unfamiliar, check the site Glossary for a plain-English definition before attempting the questions.
How often is new content like this published?
New exercises are added regularly across all categories, alongside new vocabulary sets and articles. Check back on the exercises hub to see what's new.