Practice rubber duck debugging and explanation vocabulary: step-by-step walkthroughs, finding bugs through explanation, revealing false assumptions, and talking through problems.
0 / 29 completed
1 / 29
A developer says 'I found the bug while explaining it to you.' Why does explaining code often reveal bugs?
Rubber duck debugging works because explanation forces explicit, linear articulation of logic. When you read code you wrote, your brain fills in gaps with assumptions. When you explain it step by step to someone (or a rubber duck), those assumptions must be stated — and false ones become obvious.
2 / 29
A colleague says 'Explain your code to me from the beginning.' What is the 'from the beginning' instruction trying to achieve?
'From the beginning' forces you to walk through setup, preconditions, and initial state — areas where bugs often hide but are skipped when you assume they work. Many bugs are found not in the complex logic but in the initial state or a condition set up earlier.
3 / 29
You say to a colleague 'Walk me through the logic step by step.' Why is the step-by-step constraint important?
Bugs often hide in transitions between steps — 'then it does X... and then Y happens.' The 'step by step' constraint forces you to specify every transition explicitly, exposing implicit assumptions about what happens between visible operations.
4 / 29
After explaining your code, you say 'The explanation revealed the false assumption.' What is a false assumption in this context?
False assumptions are beliefs about how the code behaves that are not true — 'this function always returns a positive number', 'this variable is always initialized before use', 'this API call always succeeds.' Rubber duck debugging surfaces these by forcing you to state assumptions explicitly.
5 / 29
A team retrospective recommends 'use talking through the problem as a first debugging step.' What is the benefit of this approach?
Talking through a problem as a first debugging step is cost-effective — it often resolves the issue without needing to involve anyone. When it does involve a colleague, it creates shared context efficiently. It also builds the habit of articulating technical problems clearly, a valuable engineering communication skill.
6 / 29
PR Description
During a code review, Alice submitted a PR with the following description: 'Fixed a null pointer exception in the user authentication service. I've added a check for null before accessing the user object.' Bob comments: 'Could you explain your reasoning behind this approach? Why did you choose to explicitly check for null instead of using optional chaining?'
This scenario highlights the importance of articulating your debugging process beyond just stating the solution. Bob's question isn't criticizing Alice's *solution*, but rather her explanation of *why* she chose that specific approach. A good developer's communication should demonstrate a thought process that includes considering alternatives and justifying decisions, not simply presenting the final fix. The key vocabulary here is 'reasoning,' which refers to the justification behind a technical choice.
7 / 29
PR Description
During a code review, Alice submitted a PR with the following description: 'Fixed a null pointer exception in the user authentication service. I've added a check for null before accessing the user object.' Bob comments: 'Could you explain your reasoning behind this approach? Why did you choose to explicitly check for null instead of using optional chaining?'
This scenario highlights the importance of articulating your debugging process beyond just stating the solution. Bob's question isn't criticizing Alice's *solution*, but rather her explanation of *why* she chose that specific approach. A good developer's communication should demonstrate a thought process that includes considering alternatives and justifying decisions, not simply presenting the final fix. The key vocabulary here is 'reasoning,' which refers to the justification behind a technical choice.
8 / 29
PR Description
During a code review, Alice submitted a PR with the following description: 'Fixed a null pointer exception in the user authentication service. I've added a check for null before accessing the user object.' Bob comments: 'Could you explain your reasoning behind this approach? Why did you choose to explicitly check for null instead of using optional chaining?'
This scenario highlights the importance of articulating your debugging process beyond just stating the solution. Bob's question isn't criticizing Alice's *solution*, but rather her explanation of *why* she chose that specific approach. A good developer's communication should demonstrate a thought process that includes considering alternatives and justifying decisions, not simply presenting the final fix. The key vocabulary here is 'reasoning,' which refers to the justification behind a technical choice.
9 / 29
PR Description
During a code review, Alice submitted a PR with the following description: 'Fixed a null pointer exception in the user authentication service. I've added a check for null before accessing the user object.' Bob comments: 'Could you explain your reasoning behind this approach? Why did you choose to explicitly check for null instead of using optional chaining?'
This scenario highlights the importance of articulating your debugging process beyond just stating the solution. Bob's question isn't criticizing Alice's *solution*, but rather her explanation of *why* she chose that specific approach. A good developer's communication should demonstrate a thought process that includes considering alternatives and justifying decisions, not simply presenting the final fix. The key vocabulary here is 'reasoning,' which refers to the justification behind a technical choice.
10 / 29
You're reviewing a pull request where a developer says, "I just talked to the rubber ducky and it helped me find the bug!" What does this most likely represent?
The 'rubber ducky' effect describes verbalizing your code to yourself – often by explaining it to an inanimate object. This forces you to think through each step of the logic, which can reveal misunderstandings or overlooked details. It's not about formal testing or automated tools; it's a simple cognitive technique.
11 / 29
In a Slack message, a developer writes: "I was wrestling with this logic for an hour. I explained it to the rubber duck and suddenly it clicked!" What is the primary value of this approach?
The key benefit of using the 'rubber ducky' is its ability to surface logical gaps. By forcing yourself to articulate the code's flow, you often uncover flaws in your thinking or assumptions that were previously unexamined. It doesn't guarantee a solution but acts as a catalyst for understanding.
12 / 29
A senior developer tells you: 'Let's walk through this function with the rubber ducky.' What is he suggesting?
This is a classic 'rubber ducky' instruction. It's not about debugging with a debugger or creating documentation. Instead, it's about explaining the code's logic step-by-step to yourself – as if you were talking to an inanimate object – which helps clarify your understanding and identify potential problems.
13 / 29
During a code review, a developer adds the following comment to their PR: 'Added null checks throughout the service. The rubber duck helped me realize I was assuming the user object always existed.' What does this comment primarily highlight?
This comment indicates a crucial realization – that the developer was making an assumption about the `user` object's existence. Null checks are a defensive programming technique designed to handle situations where data might be missing or invalid. It's not about unit tests or performance optimization.
14 / 29
Your team discusses incorporating 'explaining the code aloud as a first step in debugging'. What is the most likely reason for this recommendation?
This approach aims to improve understanding *before* any code changes. By verbalizing your thinking, you are more likely to identify misunderstandings about the code's purpose or intended behavior – which is often where bugs originate. It's a preventative measure focusing on conceptual clarity.
15 / 29
You're reviewing a pull request where a developer says, "I just talked to the rubber ducky and it helped me find the bug!" What does this most likely represent?
The 'rubber ducky' effect describes verbalizing your code to yourself – often by explaining it to an inanimate object. This forces you to think through each step of the logic, which can reveal misunderstandings or overlooked details. It's not about formal testing or automated tools; it's a simple cognitive technique.
16 / 29
In a Slack message, a developer writes: "I was wrestling with this logic for an hour. I explained it to the rubber duck and suddenly it clicked!" What is the primary value of this approach?
The key benefit of using the 'rubber ducky' is its ability to surface logical gaps. By forcing yourself to articulate the code's flow, you often uncover flaws in your thinking or assumptions that were previously unexamined. It doesn't guarantee a solution but acts as a catalyst for understanding.
17 / 29
A senior developer tells you: 'Let's walk through this function with the rubber ducky.' What is he suggesting?
This is a classic 'rubber ducky' instruction. It's not about debugging with a debugger or creating documentation. Instead, it's about explaining the code's logic step-by-step to yourself – as if you were talking to an inanimate object – which helps clarify your understanding and identify potential problems.
18 / 29
During a code review, a developer adds the following comment to their PR: 'Added null checks throughout the service. The rubber duck helped me realize I was assuming the user object always existed.' What does this comment primarily highlight?
This comment indicates a crucial realization – that the developer was making an assumption about the `user` object's existence. Null checks are a defensive programming technique designed to handle situations where data might be missing or invalid. It's not about unit tests or performance optimization.
19 / 29
Your team discusses incorporating 'explaining the code aloud as a first step in debugging'. What is the most likely reason for this recommendation?
This approach aims to improve understanding *before* any code changes. By verbalizing your thinking, you are more likely to identify misunderstandings about the code's purpose or intended behavior – which is often where bugs originate. It's a preventative measure focusing on conceptual clarity.
20 / 29
You're reviewing a pull request where a developer says, "I just talked to the rubber ducky and it helped me find the bug!" What does this most likely represent?
The 'rubber ducky' effect describes verbalizing your code to yourself – often by explaining it to an inanimate object. This forces you to think through each step of the logic, which can reveal misunderstandings or overlooked details. It's not about formal testing or automated tools; it's a simple cognitive technique.
21 / 29
In a Slack message, a developer writes: "I was wrestling with this logic for an hour. I explained it to the rubber duck and suddenly it clicked!" What is the primary value of this approach?
The key benefit of using the 'rubber ducky' is its ability to surface logical gaps. By forcing yourself to articulate the code's flow, you often uncover flaws in your thinking or assumptions that were previously unexamined. It doesn't guarantee a solution but acts as a catalyst for understanding.
22 / 29
A senior developer tells you: 'Let's walk through this function with the rubber ducky.' What is he suggesting?
This is a classic 'rubber ducky' instruction. It's not about debugging with a debugger or creating documentation. Instead, it's about explaining the code's logic step-by-step to yourself – as if you were talking to an inanimate object – which helps clarify your understanding and identify potential problems.
23 / 29
During a code review, a developer adds the following comment to their PR: 'Added null checks throughout the service. The rubber duck helped me realize I was assuming the user object always existed.' What does this comment primarily highlight?
This comment indicates a crucial realization – that the developer was making an assumption about the `user` object's existence. Null checks are a defensive programming technique designed to handle situations where data might be missing or invalid. It's not about unit tests or performance optimization.
24 / 29
Your team discusses incorporating 'explaining the code aloud as a first step in debugging'. What is the most likely reason for this recommendation?
This approach aims to improve understanding *before* any code changes. By verbalizing your thinking, you are more likely to identify misunderstandings about the code's purpose or intended behavior – which is often where bugs originate. It's a preventative measure focusing on conceptual clarity.
25 / 29
You're reviewing a pull request where a developer says, "I just talked to the rubber ducky and it helped me find the bug!" What does this most likely represent?
The 'rubber ducky' effect describes verbalizing your code to yourself – often by explaining it to an inanimate object. This forces you to think through each step of the logic, which can reveal misunderstandings or overlooked details. It's not about formal testing or automated tools; it's a simple cognitive technique.
26 / 29
In a Slack message, a developer writes: "I was wrestling with this logic for an hour. I explained it to the rubber duck and suddenly it clicked!" What is the primary value of this approach?
The key benefit of using the 'rubber ducky' is its ability to surface logical gaps. By forcing yourself to articulate the code's flow, you often uncover flaws in your thinking or assumptions that were previously unexamined. It doesn't guarantee a solution but acts as a catalyst for understanding.
27 / 29
A senior developer tells you: 'Let's walk through this function with the rubber ducky.' What is he suggesting?
This is a classic 'rubber ducky' instruction. It's not about debugging with a debugger or creating documentation. Instead, it's about explaining the code's logic step-by-step to yourself – as if you were talking to an inanimate object – which helps clarify your understanding and identify potential problems.
28 / 29
During a code review, a developer adds the following comment to their PR: 'Added null checks throughout the service. The rubber duck helped me realize I was assuming the user object always existed.' What does this comment primarily highlight?
This comment indicates a crucial realization – that the developer was making an assumption about the `user` object's existence. Null checks are a defensive programming technique designed to handle situations where data might be missing or invalid. It's not about unit tests or performance optimization.
29 / 29
Your team discusses incorporating 'explaining the code aloud as a first step in debugging'. What is the most likely reason for this recommendation?
This approach aims to improve understanding *before* any code changes. By verbalizing your thinking, you are more likely to identify misunderstandings about the code's purpose or intended behavior – which is often where bugs originate. It's a preventative measure focusing on conceptual clarity.
What does the "Rubber Duck Debugging Vocabulary" exercise practise?
Practice rubber duck debugging and explanation vocabulary: step-by-step walkthroughs, finding bugs through explanation, revealing false assumptions, and talking through problems.
How many questions are in this exercise?
This exercise has 29 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Intermediate. If the vocabulary feels difficult, browse the Debugging Language category page for an easier module to start with.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free with no account, sign-up, or paywall.
Do I get feedback if I answer incorrectly?
Yes — whichever option you choose, right or wrong, you'll immediately see an explanation clarifying the correct term and why the other options don't fit.
Can I retry this exercise?
Yes — once you finish all the questions, a "Try again" button on the results screen resets the exercise so you can practise as many times as you like.
Do I need an account to track my progress?
No account is required. Your progress bar and score for this session are tracked in the browser as you go, but nothing is saved once you leave the page.
Is "Rubber Duck Debugging Vocabulary" part of a larger series?
Yes — it's one exercise in the Debugging Language category on CoderSlingo. See the category page for the full list of related exercises on similar terminology.
Can I link directly to this exercise?
Yes — this exercise has its own permanent URL, so you can bookmark it or share the link directly with a colleague or study partner.
Where can I find more exercises like this one?
See the Debugging Language category page for related exercises, or browse the main Exercises hub for other IT English topics.