Beginner
Debugging Language
#rubber-duck
#self-explanation
Rubber Duck Debugging Language
6 exercises — articulate a problem clearly enough to find the bug yourself, using goal/expected/actual framing and line-by-line narration.
0 / 27 completed
1 / 27
You are about to explain a bug out loud to a colleague (or a rubber duck). Which opening correctly frames the problem before diving into details?
Rubber duck debugging works because articulating the goal, expected behaviour, and actual behaviour out loud forces you to slow down and notice gaps in your own reasoning — often before the listener says a word.
Formula:
This three-part frame is the verbal equivalent of a bug report's "expected vs. actual" structure, and it's the single most effective habit for self-resolving bugs before asking for help.
Formula:
"Here's what I'm trying to do: [goal]. Here's what I expect: [expected]. Here's what's actually happening: [actual]."This three-part frame is the verbal equivalent of a bug report's "expected vs. actual" structure, and it's the single most effective habit for self-resolving bugs before asking for help.
2 / 27
Midway through explaining your code line-by-line, you suddenly realise the bug yourself. What is the correct way to acknowledge this out loud?
The classic "rubber duck moment" — say what triggered the realisation ("saying that out loud"), and state your new hypothesis explicitly before verifying it. This keeps the explanation useful even if you're talking to a real colleague who was following along.
Formula:
Narrating the "aha" moment (rather than silently going quiet) is respectful to a human listener and reinforces the habit of externalising your reasoning, which is the whole point of the technique.
Formula:
"Wait — actually, saying that out loud, I think I see it. Let me check: [hypothesis]."Narrating the "aha" moment (rather than silently going quiet) is respectful to a human listener and reinforces the habit of externalising your reasoning, which is the whole point of the technique.
3 / 27
A junior engineer says "I tried explaining it to my rubber duck but I still don't see the bug." What is the best follow-up coaching advice?
The technique fails when the explanation stays too high-level ("this function processes the order"). Coaching should push toward literal, line-by-line narration of actual behaviour, not intended behaviour — the gap between "what I think it does" and "what it literally does" is where most bugs hide.
Useful phrase: "Walk through it line by line and say exactly what each line does, not what you intend it to do." This distinction — narrating actual vs. intended behaviour — is the core mechanic that makes rubber duck debugging effective.
Useful phrase: "Walk through it line by line and say exactly what each line does, not what you intend it to do." This distinction — narrating actual vs. intended behaviour — is the core mechanic that makes rubber duck debugging effective.
4 / 27
You're rubber-ducking with an actual colleague (not a toy) and want to clarify your own understanding mid-explanation. Which phrase is most appropriate?
When rubber-ducking with a real person, periodically check your own understanding out loud rather than assuming it — this invites the listener to correct you if your mental model is wrong, which is often exactly where the bug lives.
Formula:
This phrase does double duty: it's good rubber-ducking practice (surfacing assumptions) and good collaborative debugging (giving the listener an explicit point to interject).
Formula:
"Let me make sure I'm explaining this right — [restated assumption], correct?"This phrase does double duty: it's good rubber-ducking practice (surfacing assumptions) and good collaborative debugging (giving the listener an explicit point to interject).
5 / 27
After successfully rubber-ducking your way to a fix, how should you summarise the process to a teammate who asks "how did you find it?"
A good debugging summary explains the method (narrating line by line) and the specific finding (the off-by-one error), so the technique itself becomes a transferable lesson for the listener, not just an anecdote.
Formula:
Sharing not just the fix but the process reinforces good debugging habits across the team, and normalises rubber duck debugging as a legitimate first-line technique rather than something to be embarrassed about.
Formula:
"I walked through it out loud step by step and realised [specific finding] — explaining it line by line surfaced [type of bug] I kept missing when reading silently."Sharing not just the fix but the process reinforces good debugging habits across the team, and normalises rubber duck debugging as a legitimate first-line technique rather than something to be embarrassed about.
6 / 27
You want to use rubber duck debugging asynchronously, by writing (not speaking) an explanation in a scratch document before asking for help. Which framing is correct?
Written rubber-ducking ("the written duck") follows the same principle: state the goal, expected, actual, and what you've ruled out in writing before you ask anyone. Many people find the bug simply by forcing themselves to write a clear, complete explanation.
Formula:
This habit produces a bonus benefit: if you don't solve it yourself, you now have a well-structured bug report ready to post, rather than a vague "it's broken" message.
Formula:
"Writing this out to think it through: I expect [X], I'm seeing [Y], I've already ruled out [Z]."This habit produces a bonus benefit: if you don't solve it yourself, you now have a well-structured bug report ready to post, rather than a vague "it's broken" message.
7 / 27
During a code review, another developer points out a potential issue with the asynchronous API call in ServiceX. You're explaining your logic to them and realize you initially miscalculated the expected response time. Which of the following phrases best conveys this realization while maintaining professionalism?
The key here is acknowledging your mistake clearly and concisely. Option A shifts blame and avoids responsibility. Option B directly admits the oversight and expresses regret – this demonstrates self-awareness and a willingness to learn. Options C and D are too vague or focus on irrelevant factors. It's important to take ownership of the error in a professional setting, showing you understand the impact of your actions.
8 / 27
You're reviewing a pull request for a new feature in the Payment Service. A senior engineer comments: 'I'm noticing a potential issue with the API call to ChargePoint – you seem to be assuming a synchronous response when it might be asynchronous. I've seen this cause delays if ChargePoint is busy.' You realize, while explaining your reasoning aloud, that you hadn't properly accounted for ChargePoint's potential latency. Which of the following responses best addresses the situation and maintains a collaborative tone?
// Assume ChargePoint will respond immediately
This scenario highlights the importance of acknowledging potential misunderstandings during code reviews. Option A is too dismissive and doesn't demonstrate learning. Option B avoids admitting the mistake and relies on potentially inaccurate documentation.
9 / 27
PR Description
During a code review, you've been explaining your approach to handling user authentication in the new UserProfile service. As you detail the flow, you suddenly realize that you haven't properly validated the input from the client-side JavaScript – specifically, ensuring it conforms to the expected format before processing it. Which of the following descriptions would best capture this realization and prompt further discussion with the reviewer?
PR Description
'I'm currently working through the authentication flow and wanted to ensure we're handling user input correctly. I've implemented the core logic, but I'm now realizing that I need to add stricter validation on the JavaScript side to prevent potential issues with malformed data.'The correct option acknowledges the oversight directly and proactively seeks clarification. Options A and B shift blame or request help without admitting the problem. Option C is overly defensive and doesn't demonstrate an understanding of the review process. The key here is to frame the realization as a learning opportunity and invite collaboration – this aligns with the purpose of rubber duck debugging and code reviews.
10 / 27
You're explaining a complex data transformation in the Order Processing Service to a colleague during a code review. As you walk through each step, you suddenly notice an error in how you're handling null values. Which of the following phrases best communicates this realization and invites collaboration without sounding like you made a significant mistake?
The key here is to frame the realization as a collaborative opportunity for improvement rather than a personal error. Option A sounds overly self-critical and could make your colleague uncomfortable. Option B is too vague and doesn't clearly indicate you need help. Option C suggests a major problem requiring a complete overhaul, which isn't necessary. Option D proactively invites discussion and focuses on the solution – demonstrating ownership and willingness to learn from the process.
11 / 27
During a code review, another developer points out a potential issue with the asynchronous API call in ServiceX. You're explaining your logic to them and realize you initially miscalculated the expected response time. Which of the following phrases best conveys this realization while maintaining professionalism?
The key here is acknowledging your mistake clearly and concisely. Option A shifts blame and avoids responsibility. Option B directly admits the oversight and expresses regret – this demonstrates self-awareness and a willingness to learn. Options C and D are too vague or focus on irrelevant factors. It's important to take ownership of the error in a professional setting, showing you understand the impact of your actions.
12 / 27
You're reviewing a pull request for a new feature in the Payment Service. A senior engineer comments: 'I'm noticing a potential issue with the API call to ChargePoint – you seem to be assuming a synchronous response when it might be asynchronous. I've seen this cause delays if ChargePoint is busy.' You realize, while explaining your reasoning aloud, that you hadn't properly accounted for ChargePoint's potential latency. Which of the following responses best addresses the situation and maintains a collaborative tone?
// Assume ChargePoint will respond immediately
This scenario highlights the importance of acknowledging potential misunderstandings during code reviews. Option A is too dismissive and doesn't demonstrate learning. Option B avoids admitting the mistake and relies on potentially inaccurate documentation.
13 / 27
PR Description
During a code review, you've been explaining your approach to handling user authentication in the new UserProfile service. As you detail the flow, you suddenly realize that you haven't properly validated the input from the client-side JavaScript – specifically, ensuring it conforms to the expected format before processing it. Which of the following descriptions would best capture this realization and prompt further discussion with the reviewer?
PR Description
'I'm currently working through the authentication flow and wanted to ensure we're handling user input correctly. I've implemented the core logic, but I'm now realizing that I need to add stricter validation on the JavaScript side to prevent potential issues with malformed data.'The correct option acknowledges the oversight directly and proactively seeks clarification. Options A and B shift blame or request help without admitting the problem. Option C is overly defensive and doesn't demonstrate an understanding of the review process. The key here is to frame the realization as a learning opportunity and invite collaboration – this aligns with the purpose of rubber duck debugging and code reviews.
14 / 27
You're explaining a complex data transformation in the Order Processing Service to a colleague during a code review. As you walk through each step, you suddenly notice an error in how you're handling null values. Which of the following phrases best communicates this realization and invites collaboration without sounding like you made a significant mistake?
The key here is to frame the realization as a collaborative opportunity for improvement rather than a personal error. Option A sounds overly self-critical and could make your colleague uncomfortable. Option B is too vague and doesn't clearly indicate you need help. Option C suggests a major problem requiring a complete overhaul, which isn't necessary. Option D proactively invites discussion and focuses on the solution – demonstrating ownership and willingness to learn from the process.
15 / 27
During a code review, another developer points out a potential issue with the asynchronous API call in ServiceX. You're explaining your logic to them and realize you initially miscalculated the expected response time. Which of the following phrases best conveys this realization while maintaining professionalism?
The key here is acknowledging your mistake clearly and concisely. Option A shifts blame and avoids responsibility. Option B directly admits the oversight and expresses regret – this demonstrates self-awareness and a willingness to learn. Options C and D are too vague or focus on irrelevant factors. It's important to take ownership of the error in a professional setting, showing you understand the impact of your actions.
16 / 27
You're reviewing a pull request for a new feature in the Payment Service. A senior engineer comments: 'I'm noticing a potential issue with the API call to ChargePoint – you seem to be assuming a synchronous response when it might be asynchronous. I've seen this cause delays if ChargePoint is busy.' You realize, while explaining your reasoning aloud, that you hadn't properly accounted for ChargePoint's potential latency. Which of the following responses best addresses the situation and maintains a collaborative tone?
// Assume ChargePoint will respond immediately
This scenario highlights the importance of acknowledging potential misunderstandings during code reviews. Option A is too dismissive and doesn't demonstrate learning. Option B avoids admitting the mistake and relies on potentially inaccurate documentation.
17 / 27
PR Description
During a code review, you've been explaining your approach to handling user authentication in the new UserProfile service. As you detail the flow, you suddenly realize that you haven't properly validated the input from the client-side JavaScript – specifically, ensuring it conforms to the expected format before processing it. Which of the following descriptions would best capture this realization and prompt further discussion with the reviewer?
PR Description
'I'm currently working through the authentication flow and wanted to ensure we're handling user input correctly. I've implemented the core logic, but I'm now realizing that I need to add stricter validation on the JavaScript side to prevent potential issues with malformed data.'The correct option acknowledges the oversight directly and proactively seeks clarification. Options A and B shift blame or request help without admitting the problem. Option C is overly defensive and doesn't demonstrate an understanding of the review process. The key here is to frame the realization as a learning opportunity and invite collaboration – this aligns with the purpose of rubber duck debugging and code reviews.
18 / 27
You're explaining a complex data transformation in the Order Processing Service to a colleague during a code review. As you walk through each step, you suddenly notice an error in how you're handling null values. Which of the following phrases best communicates this realization and invites collaboration without sounding like you made a significant mistake?
The key here is to frame the realization as a collaborative opportunity for improvement rather than a personal error. Option A sounds overly self-critical and could make your colleague uncomfortable. Option B is too vague and doesn't clearly indicate you need help. Option C suggests a major problem requiring a complete overhaul, which isn't necessary. Option D proactively invites discussion and focuses on the solution – demonstrating ownership and willingness to learn from the process.
19 / 27
During a code review, another developer points out a potential issue with the asynchronous API call in ServiceX. You're explaining your logic to them and realize you initially miscalculated the expected response time. Which of the following phrases best conveys this realization while maintaining professionalism?
The key here is acknowledging your mistake clearly and concisely. Option A shifts blame and avoids responsibility. Option B directly admits the oversight and expresses regret – this demonstrates self-awareness and a willingness to learn. Options C and D are too vague or focus on irrelevant factors. It's important to take ownership of the error in a professional setting, showing you understand the impact of your actions.
20 / 27
You're reviewing a pull request for a new feature in the Payment Service. A senior engineer comments: 'I'm noticing a potential issue with the API call to ChargePoint – you seem to be assuming a synchronous response when it might be asynchronous. I've seen this cause delays if ChargePoint is busy.' You realize, while explaining your reasoning aloud, that you hadn't properly accounted for ChargePoint's potential latency. Which of the following responses best addresses the situation and maintains a collaborative tone?
// Assume ChargePoint will respond immediately
This scenario highlights the importance of acknowledging potential misunderstandings during code reviews. Option A is too dismissive and doesn't demonstrate learning. Option B avoids admitting the mistake and relies on potentially inaccurate documentation.
21 / 27
PR Description
During a code review, you've been explaining your approach to handling user authentication in the new UserProfile service. As you detail the flow, you suddenly realize that you haven't properly validated the input from the client-side JavaScript – specifically, ensuring it conforms to the expected format before processing it. Which of the following descriptions would best capture this realization and prompt further discussion with the reviewer?
PR Description
'I'm currently working through the authentication flow and wanted to ensure we're handling user input correctly. I've implemented the core logic, but I'm now realizing that I need to add stricter validation on the JavaScript side to prevent potential issues with malformed data.'The correct option acknowledges the oversight directly and proactively seeks clarification. Options A and B shift blame or request help without admitting the problem. Option C is overly defensive and doesn't demonstrate an understanding of the review process. The key here is to frame the realization as a learning opportunity and invite collaboration – this aligns with the purpose of rubber duck debugging and code reviews.
22 / 27
You're explaining a complex data transformation in the Order Processing Service to a colleague during a code review. As you walk through each step, you suddenly notice an error in how you're handling null values. Which of the following phrases best communicates this realization and invites collaboration without sounding like you made a significant mistake?
The key here is to frame the realization as a collaborative opportunity for improvement rather than a personal error. Option A sounds overly self-critical and could make your colleague uncomfortable. Option B is too vague and doesn't clearly indicate you need help. Option C suggests a major problem requiring a complete overhaul, which isn't necessary. Option D proactively invites discussion and focuses on the solution – demonstrating ownership and willingness to learn from the process.
23 / 27
During a code review of the new UserProfile service, you're discussing a potential issue with data validation. A junior developer asks, 'So, if we don't explicitly check every possible input value, does that mean we're implicitly trusting the user to provide correct data?'
This question tests understanding that implicit trust is a dangerous assumption in development. The core concept is about proactive security measures - always validating user input regardless of perceived risk. Option A highlights the critical need for validation to prevent vulnerabilities. Option B mistakenly suggests it's acceptable with monitoring, while option C correctly states that implicit trust should *never* be relied upon.
24 / 27
You're in a Slack channel discussing a bug fix for the Inventory Service. Another developer writes: 'I'm debugging this by stepping through the code and just… thinking about what I'm doing. It's working!' What technique is the developer implicitly using?
The phrase 'stepping through the code and just thinking about what I'm doing' is a classic description of Rubber Duck Debugging. This technique involves verbalizing your thought process to yourself, often by explaining it to an inanimate object (like a rubber duck), to identify logical errors. Option A perfectly captures this.
25 / 27
As part of a PR review for the Shipping Service, you're reviewing a comment from a lead engineer: 'I'm noticing a potential issue with the API call to UPS – you seem to be assuming a synchronous response when asynchronous communication would significantly improve performance and resilience.' What is the *primary* reason this comment suggests?
This question assesses understanding of asynchronous communication and its benefits. The comment highlights that assuming a synchronous response can create a bottleneck, particularly when dealing with external services like UPS which may have latency issues. This is the core reason for suggesting asynchronous communication.
26 / 27
During a standup update on the Order Processing Service, you realize you've been focusing solely on the technical implementation and haven't clearly articulated *why* this change is valuable to the user. What could you have done to better explain your work using debugging principles?
This question tests understanding that debugging isn't just about finding errors in code; it's also about clarifying the *reasoning* behind decisions. Verbalizing your thought process (explaining why a solution was chosen) helps others understand the context and value of the change, which is crucial for effective communication.
27 / 27
You're reviewing a pull request for the Reporting Service. A senior developer comments: 'I'm seeing that you're using a direct database query to retrieve customer data – could this potentially impact performance if the queries aren't optimized?' What is the underlying debugging principle being highlighted?
This question focuses on identifying potential performance issues – a key aspect of debugging. The comment suggests recognizing that direct database queries can be bottlenecks if not optimized, directly relating to the debugging principle of anticipating and addressing potential problems before they manifest.
Frequently Asked Questions
What does the "Rubber Duck Debugging Language" exercise practise?
Practise articulating a problem clearly out loud or in writing: goal/expected/actual framing, self-explanation, and the written rubber-duck technique. 6 exercises.
How many questions are in this exercise?
This exercise has 27 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Beginner. 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 Language" 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.