rubber duck problem solving method

Rubber Duck Debugging

As a software developer, you’ve probably been in a situation where your code is not working as expected.

This could happen because you made a typo, you weren't paying enough attention, or you weren't sure how something worked.

When your code doesn't work, it's frustrating – but the only thing to do is to find the bug(s) that are making your code not work. These bugs occur because the computer needs you to be as precise as possible while speaking any of its languages.

One method you can use to find bugs in your code is the rubber duck debugging technique.

So, what is the rubber duck debugging technique and how does it work? That’s what you will find out in this article.

Why Do Programmers Use a Rubber Duck?

Many people who see a rubber duck on a programmer's desk might think it’s a toy or an inconsequential decoration.

In reality, the rubber duck is a tool that helps programmers solve problems. Programmers explain the quirks – often called bugs – in their code to the rubber duck which then helps them find a solution to the bug.

This is because explaining a problem to someone else helps you understand the problem better and find a solution to it. It allows you to see things from a new perspective and catch things you may have missed the first time around.

To understand the concept of rubber duck debugging better and the idea behind it, make sure you read this article to the end.

What is Rubber Duck Debugging and How Does it Work?

The rubber duck debugging technique was popularized by a story from the 1999 book written by Andrew Hunt and David Thomas – The Pragmatic Programmer.

The story depicts how a programmer carries around a rubber duck and explains their codes to it line by line any time they encounter a bug.

Talking to an inanimate object about the bugs in your code might sound silly, but it’s very popular among programmers because it works.

In the rubber duck debugging technique, you don’t just explain the codes to the rubber duck line by line. You also tell the duck what exactly you’re trying to do and your goals for the code.

When you explain everything about the code to the rubber duck, you're much more likely to spot the bug hiding there.

Some of us have been in a situation where we encounter a problem, decide to explain the problem to a friend, and get the solution even when we are not done explaining the problem to that friend.

By explaining the bugs in your code to an inanimate object like a rubber duck, you don’t need to disturb anyone. You can also substitute a pet or other inanimate objects for the rubber duck.

What is the Rubber Duck Theory?

The idea behind the rubber duck debugging technique is that when a programmer gets held back by bugs, the code is explained line by line to a rubber duck.

Think about this technique as a process in which you type a message to be posted on social media and read it out loud before you post it. This could help you spot the typographical and grammatical errors in it. The same thing is applicable to explaining your code to a rubber duck.

When you encounter bugs and you explain the code line by line to a rubber duck, the solution to the bugs often presents itself right from there.

Final Thoughts

To solve problems and learn anything effectively, you need to talk about it and teach it. Rubber ducking helps you fix bugs because solutions are often found when you talk about a problem and teach it.

Over the years, rubber duck debugging has been a mainstay in problem-solving among software developers. According to some programmers, they even get rubber ducks as part of their welcome package when they get a new job.

It is not the rubber duck that tells you how to fix the bugs, of course. Rather, you figure out how you can fix the bugs by talking through what your code does line by line.

Rubber duck debugging, or talking to a rubber duck, is not exclusive to programming. You can also use this technique in other aspects of life.

I'm a software developer and tech writer focusing on frontend technologies

If you read this far, thank the author to show them you care. Say Thanks

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Have an idea , need a diverse team? We are here!

You have the problems, we have the solutions

Our solutions are robust and those scale easily. We focus on elegance and quality, we meet the deadlines.

We build with care and pay attention to the details

Rubber Duck Debugging: A Programmer’s Secret Weapon for Problem-Solving

Introduction

Debugging is an important part of programming. It’s the process of finding and fixing problems in code. Sometimes, programmers get stuck and need a new way to think about the problem. That’s where Rubber Duck Debugging comes in. This method involves explaining your code and problem out loud to a rubber duck. It might sound silly, but it can help you see your problem in a new way and find the solution faster.

History and Origin

Rubber Duck Debugging has an interesting story. It all started with a book called “ The Pragmatic Programmer, ” written by Andrew Hunt and David Thomas. In this book, they talk about a programmer who carried a rubber duck with them. Whenever the programmer had a problem with their code, they would explain it to the duck. This simple act of talking through the problem often helped them find a solution.

The idea is that by explaining your code out loud, you can see it more clearly. It’s like when you try to teach someone else; you understand the subject better yourself. The rubber duck is a friendly and non-judgmental listener, always ready to help you debug your code.

How Rubber Duck Debugging Works

Rubber Duck Debugging is very simple to practice. Here is how you can do it:

1. Find a Rubber Duck : You can use any object, but a rubber duck is fun and has become a symbol of this method.

2. Explain Your Code : Start by explaining your code to the duck. Describe what each part of the code is supposed to do. Pretend the duck knows nothing about programming.

3. Describe the Problem : Now, explain what the problem is. Tell the duck what is going wrong and what you have tried so far to fix it.

4. Talk Through Your Thoughts : As you explain, you might start to see your code in a new way. Sometimes, just hearing your own words can make the solution clear.

For example, if you have a bug in your code, you might say to the duck, “This function is supposed to add two numbers, but it’s giving me the wrong result. I checked the inputs, and they seem fine. Maybe the problem is in the way the function returns the result.” As you talk, you might suddenly realize what the issue is.

This method works because it forces you to slow down and think about each step of your code carefully. Often, the simple act of explaining helps you spot mistakes you missed before.

Psychological and Cognitive Benefits

Talking to a rubber duck might seem funny, but it actually helps your brain work better. When you explain your code out loud, you engage different parts of your brain than when you think silently. This can make your thoughts clearer and more organized.

Explaining a problem forces you to slow down and consider each detail. This process can reveal errors or assumptions you didn’t notice before. It’s similar to how teaching someone else helps you understand a topic better. By putting your thoughts into words, you make them more concrete and easier to analyze.

Additionally, Rubber Duck Debugging reduces stress. Talking to a non-judgmental listener, like a rubber duck, can help you feel more relaxed. This can improve your focus and make it easier to solve problems.

This method isn’t just for programming. People in many fields use similar techniques to clarify their thoughts and solve problems. For instance, writers might explain their plots to a friend, or teachers might talk through a lesson plan to make sure it’s clear.

Real-Life Examples

Many programmers have found success with Rubber Duck Debugging. Let’s look at some examples to see how it works in practice.

Story 1: The Case of the Missing Semicolon

A software developer named Alex was stuck on a bug for hours. Their code wouldn’t run, and nothing seemed to work. Frustrated, Alex decided to try Rubber Duck Debugging. They explained each line of their code to the duck. When they got to a particular line, they suddenly noticed they had missed a semicolon. Adding the semicolon fixed the problem immediately. Talking through the code helped Alex spot a simple mistake they had overlooked for hours.

Story 2: Breaking Down Complex Problems

Maria, a senior developer, often uses a rubber duck to tackle complex issues. One day, she faced a complicated problem with a data processing algorithm. Maria sat down and explained the whole process to her rubber duck, step by step. As she did, she realized she had misunderstood how a part of the algorithm worked. This insight helped her correct the error and improve the algorithm’s efficiency.

Story 3: A Team’s Secret Weapon

In a software development team, everyone had their own rubber duck. Whenever someone got stuck, they would take a break and talk to their duck. This practice not only helped individuals solve problems faster but also encouraged a culture of thorough thinking and self-reliance. The team found that fewer bugs made it to the testing phase, saving time and improving their overall workflow.

Story 4: The Case of the Bitbucket Pipeline

One of my teammates was facing an issue where the Bitbucket pipeline was failing the ESLint check, but it passed in the local environment. He tried many times to find the issue but couldn’t figure it out. Later, he talked to me about it, and we decided to go through the code together.

As we explained the code to each other, we discovered that he had created a class called DummayClass. However, when he imported the class, he used dummyClass instead of DummayClass. This small mistake caused the pipeline to fail. The project was in TypeScript, which is case-sensitive, so the mismatch between DummayClass and dummyClass led to the error.

By talking through the problem and explaining each part of the code, we were able to spot the mistake and fix it. This example shows how effective Rubber Duck Debugging can be, even when it involves talking to a human instead of a duck.

Rubber Duck Debugging in the Workplace

Rubber Duck Debugging is not just a personal tool; it can also benefit your entire team. Encouraging your team members to adopt this method can create a culture of careful, thoughtful debugging. Here are some ways to integrate Rubber Duck Debugging into the workplace.

First, make it a habit. Encourage team members to keep a rubber duck or another object on their desk. Whenever they get stuck, they can use it to talk through their code. This practice helps people slow down and think more clearly.

Second, promote a supportive environment. Sometimes, just knowing that it’s okay to talk through problems out loud can reduce stress and improve focus. When team members see others using this method, they might feel more comfortable trying it themselves.

Third, combine it with other tools and practices. For example, pair programming can complement Rubber Duck Debugging. When two developers work together, they can explain their thoughts to each other, just like they would to a rubber duck. Code reviews are another opportunity to use this method. By explaining their code during a review, developers can catch errors before they become bigger problems.

Finally, make it fun. Adding a bit of humor to the workplace can make debugging less stressful. A rubber duck on your desk can be a cheerful reminder to think things through and not get frustrated.

By integrating Rubber Duck Debugging into your team’s routine, you can improve problem-solving skills, reduce stress, and create a more supportive and collaborative work environment.

Tips for Effective Rubber Duck Debugging

Rubber Duck Debugging can be very effective if done correctly. Here are some tips to make the most out of this method:

1. Be Thorough and Clear

When explaining your code to the duck, go into as much detail as possible. Pretend the duck knows nothing about programming. This forces you to slow down and think through every part of your code.

2. Stay Focused

It’s easy to get distracted when talking to an inanimate object. Stay focused on the problem at hand. Describe the issue clearly and methodically.

3. Don’t Rush

Take your time to explain everything. Rushing through the explanation might cause you to miss important details. The goal is to understand the problem fully.

4. Use It Regularly

Make Rubber Duck Debugging a regular part of your workflow. The more you use it, the more natural it will feel, and the more effective it will become.

5. Combine with Other Techniques

Use Rubber Duck Debugging alongside other debugging techniques. Pair programming, code reviews, and automated testing can all complement this method.

6. Adapt as Needed

If you find talking to a rubber duck awkward, use another object or even a coworker. The key is to verbalize your problem and think it through.

7. Keep It Fun

Remember, the purpose of the rubber duck is to help you solve problems and reduce stress. Keep a sense of humor about it. The more relaxed you are, the better you’ll be able to think clearly.

By following these tips, you can make Rubber Duck Debugging an even more powerful tool in your problem-solving toolkit.

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

Coding Horror

Programming and human factors, rubber duck problem solving.

At Stack Exchange , we insist that people who ask questions put some effort into their question , and we're kind of jerks about it . That is, when you set out to ask a question, you should …

• Describe what's happening in sufficient detail that we can follow along. Provide the necessary background for us to understand what's going on, even if we aren't experts in your particular area.
• Tell us why you need to know the answer. What led you here? Is it idle curiosity or is this somehow blocking you on a project? We don't need your whole life story, just give us some context here.
• Share your research on your problem; what have you found so far? Why didn't it work? And if you didn't do any research … should you even be asking? If you're inviting us to spend our valuable time helping you, it's only fair that you put in a reasonable amount of your valuable time into crafting a decent question. Help us help you!

We have a great How to Ask page that explains all of this, which is linked generously throughout the network. (And on Stack Overflow, due to massive question volume, we actually force new users to click through that page before asking their first question. You can see this yourself by asking a question as a new user.)

What we're trying to prevent, most of all, is the unanswerable drive-by question. Those help nobody, and left unchecked they can ruin a Q&A site, turning it into a virtual ghost town. On Stack Exchange, questions that are so devoid of information and context that they can't reasonably be answered will be actively closed, and if they aren't improved, eventually deleted.

Like I said, we're kinda jerks about this. But for good reason: we're not-so-subtly trying to help you help yourself , by teaching you Rubber Duck problem solving . And boy does it ever work. I've gotten tons of feedback over the years about how people, in the process of writing up their thorough, detailed question for Stack Overflow or another Stack Exchange site, figured out the answer to their own problem.

It's quite common. See for yourself:

How can I thank the community when I solve my own problems? I've only posted one question so far, and almost posted another. In both cases, I answered my own questions at least partially while writing it out. I credit the community and the process itself for making me think about the answer. There's nothing explicit in what I'm writing that states quite obviously the answer I needed, but something about writing it down makes me think along extra lines of thought. Why is it that properly formulating your question often yields you your answer? I don't know how many times this has happened: I have a problem I decide to bring it to stack overflow I awkwardly write down my question I realize that the question doesn't make any sense I take 15 minutes to rethink how to ask my question I realize that I'm attacking the problem from a wrong direction entirely. I start from scratch and find my solution quickly. Does this happen to you? Sometimes asking the right question seems like half the problem. Beginning to ask a question actually helps me debug my problem myself Beginning to ask a question actually helps me debug my problem myself, especially while trying to formulate a coherent and detailed enough question body in order to get decent answers. Has this happened to anybody else before?

It's not a new concept, and every community seems to figure it out on their own given enough time, but "Ask the Duck" is a very powerful problem solving technique .

Bob pointed into a corner of the office. "Over there," he said, "is a duck. I want you to ask that duck your question." I looked at the duck. It was, in fact, stuffed, and very dead. Even if it had not been dead, it probably would not have been a good source of design information. I looked at Bob. Bob was dead serious. He was also my superior, and I wanted to keep my job. I awkwardly went to stand next to the duck and bent my head, as if in prayer, to commune with this duck. "What," Bob demanded, "are you doing?" "I'm asking my question of the duck," I said. One of Bob's superintendants was in his office. He was grinning like a bastard around his toothpick. "Andy," he said, "I don't want you to pray to the duck. I want you to ask the duck your question ." I licked my lips. "Out loud?" I said. "Out loud," Bob said firmly. I cleared my throat. "Duck," I began. "Its name is Bob Junior," Bob's superintendant supplied. I shot him a dirty look. "Duck," I continued, "I want to know, when you use a clevis hanger, what keeps the sprinkler pipe from jumping out of the clevis when the head discharges, causing the pipe to..." In the middle of asking the duck my question, the answer hit me. The clevis hanger is suspended from the structure above by a length of all-thread rod. If the pipe-fitter cuts the all-thread rod such that it butts up against the top of the pipe, it essentially will hold the pipe in the hanger and keep it from bucking. I turned to look at Bob. Bob was nodding. "You know, don't you," he said. "You run the all-thread rod to the top of the pipe," I said. "That's right," said Bob. "Next time you have a question, I want you to come in here and ask the duck, not me. Ask it out loud. If you still don't know the answer, then you can ask me." "Okay," I said, and got back to work.

I love this particular story because it makes it crystal clear how the critical part of rubber duck problem solving is to totally commit to asking a thorough, detailed question of this imaginary person or inanimate object . Yes, even if you end up throwing the question away because you eventually realize that you made some dumb mistake. The effort of walking an imaginary someone through your problem, step by step and in some detail, is what will often lead you to your answer. If you aren't willing to put the effort into fully explaining the problem and how you've attacked it, you can't reap the benefits of thinking deeply about your own problem before you ask others to.

If you don't have a coding buddy (but you totally should) , you can leverage the Rubber Duck problem solving technique to figure out problems all by yourself, or with the benefit of the greater Internet community. Even if you don't get the answer you wanted, forcing yourself to fully explain your problem – ideally in writing – will frequently lead to new insights and discoveries.

• Faculty/Staff
• MyMichiganTech
• Safety Data Sheets
• Computing News Blog
• Talk to the Duck: The . . .

Talk to the Duck: The Rubber Duck Debugging Method

• Computer Science
• Software Engineering

Rubber Duck Debugging Method: Complete 101 Guide (2024)

Jul 22, 2024 · 7 min read

Have you ever felt stuck trying to find a bug in your code?

Debugging code to find where it went wrong can be time-consuming and slow your progress.

The longer you search for errors, the more you feel frustrated.

Well, talking to a rubber duck can help you solve this problem.

Using the rubber duck debugging method, you can easily break down complex issues and find solutions.

But how does it work? Read this guide to find out:

• What is the rubber duck debugging technique?
• What is the theory behind it?
• How to implement it: A step-by-step guide.
• Best practices to make debugging less stressful.

Let's get started.

What is Rubber Duck Debugging?

Rubber duck debugging is a technique for explaining your code line by line to an inanimate object, such as a rubber duck.

Explaining the problem step by step helps you understand it better and often leads to finding a solution.

This technique derives its name from a story in Andrew Hunt and David Thomas's book The Pragmatic Programmer.

The story describes a programmer who carries around a rubber duck and explains the code to it when faced with a challenge.

How Does It Work?

While it might seem silly trying to explain your code to a rubber duck, there's a reason this technique is quite popular in the programming community.

Explaining your code forces you to think about it in detail.

The main idea is that when you speak your thoughts out loud, you force yourself to slow down and think more clearly, often leading to the realization of what went wrong in your code.

You also tell the duck what exactly you're attempting to do with the code.

This reveals mistakes or errors you might overlook and helps you gain a clearer perspective on your code.

Theory Behind Rubber Duck

Explaining your code out loud engages different parts of your brain related to memory, attention, and reasoning, allowing you to understand better and retain information.

This can help you identify gaps in your logic that you might miss when silently reading through your code.

The duck doesn't solve the problem for you, but explaining helps you realize what you are doing wrong or where the bug might be.

How to Implement Rubber Duck Debugging

Here's a step-by-step guide on using this technique in your development process.

Find Your Rubber Duck

The first step is to obtain your debugging duck.

You can use a rubber duck, a stuffed toy, or even a coffee mug. The key is to have an object you can talk to.

Describe Your Code

Place the rubber duck on your desk and begin explaining your code to it.

Start from the beginning, describe what each line or block of code does and why it's there.

• Describe what you want to achieve with your code.
• Tell the duck what the problem is.
• Go through each part of the problem and explain it clearly.
• Be specific about what is not working.
• Talk about everything you've tried so far.

Spot the Errors

As you explain, you will most likely see where you went wrong or find areas that don't make sense.

This will help you notice your mistake and find a solution even when you have not finished explaining the problem.

It will be your "Wait, I see now! I forgot to do this." moment.

If your "duck" is another human, you are quite likely to get feedback.

The other person may challenge your thought process. They may ask why you chose to handle the problem in the way you did.

Explaining the bugs in your code to an inanimate object means you don't need to disturb anyone or get defensive while trying to justify yourself.

Test Your Findings

Once you've identified the potential issue, you can make the necessary changes in your code.

Test your code again to see if the problem is resolved or if explaining it helped you find it.

Benefits of Rubber Duck Debugging

It offers several benefits for programmers. Such as:

Problem-Solving Skills

When you break down a complex problem into smaller, more manageable pieces, it helps structure your thoughts in a way that makes the solution more obvious.

This method encourages you to think logically, improving your critical thinking and problem-solving skills.

Check out this guide on how to solve coding problems effectively.

Improve Communication

Expressing your thought process and solutions concisely and clearly improves your ability to communicate technical details.

This skill is valuable when working on group projects where you might have to explain issues to teammates.

Learn how Feynman learning technique can make you a better web developer.

Better Code Understanding

By talking through what your code does line-by-line, you gain a deeper understanding of its structure and function.

This way, you can find issues before they become a bigger problem, save time, and become more productive.

Improve Confidence

Relying on a rubber duck encourages you to solve problems without immediately seeking help from friends or online forums.

This makes you more self-confident in your coding skills.

Team Collaboration

When you have tried everything and still can't find the bugs or come up with a solution for why your code is not working, you may turn to your team members or friends for help.

This promotes collaboration and communication among team members.

Sharing is the best way to expand your skills and solve coding challenges. Snappify lets you create beautiful code snippets and share them with others.

Best Practices for Effective Rubber Duck Debugging

Here are some tips to get the most out of this technique:

• Find a quiet place where you can speak out loud without any distractions.
• Describe your code thoroughly, as this will increase the chances of catching the bug.
• Use simple and plain language as if speaking to a non-technical person without coding knowledge.
• Take your time and avoid rushing through the explanation.
• Write down any insights you discover during the process and the solutions you develop for future reference.
• Make it a regular part of your coding routine. The more you practice, the more natural and helpful it will become.

Final Words

The Rubber Duck Debugging Method is a simple yet powerful strategy to find and fix coding issues.

It can significantly increase your debugging efficiency and programming skills.

So the next time you're stuck with an annoying bug, grab a rubber duck and start talking.

If you like this article, you will also enjoy reading:

• How to improve technical skills as a software developer.
• How to become a 10x developer.
• How to become an AI engineer without a degree.

Can beginners benefit from using the Rubber Duck Debugging?

Yes, rubber duck debugging is helpful for programmers of all levels, including beginners. It encourages a step-by-step approach to solving issues and can improve coding skills over time.

Is rubber duck debugging only for programming?

No, this technique is not exclusive to programming. You can use it to solve any problem.

Share Article

Improve how you code: Understanding Rubber Duck Debugging

We all have been there. The frustration that we feel when your code comes out as broken, or the output you want is far from what you’ve got is completely normal. So what do you do when you have a bug in your code? One might run through the code several times to pinpoint any obvious errors only to find none.

Sometimes, the errors are minor details that you may have skipped due to your programming speed. What we know about software is that a developer needs to be as exact as they can while giving out commands and setting conditions. Since the computer thinks only in crystal-clear lines of instruction, we need to work on getting better at speaking its language.

That’s why the rubber duck debugging method is so popular. We’ve all heard of the term, but it is often met with raised eyebrows and confused expressions. It is a lesson in psychology for developers and highly effective methodology to debug your code.

How does a rubber duck fit into coding for programmers? Well, you’re about to find out! Once and for all, we are here to clear the air and explain exactly what rubber duck programming means.

Let’s dive into the details without beating around the bush!

What is Rubber Duck Debugging?

In the world of software engineering, a rubber duck method helps to debug codes. It helps you to find bugs and problems in your code. The term rubber duck refers to an entity that has less than half a brain and understands almost nothing about a given problem.

Rubber Duck Debugging is a programming methodology where you explain the task you are performing from the goals you are trying to achieve to all the details in your code, line-by-line. By describing the problem the programmer force themselves to express their ideas in a clear way and go through all the details. This explanation is called “telling the duck your problem” .

When a coder does so, the bug will be easily be spotted as you will be forced to face the logic problems you might have ignored previously. All with the help of rubber duck programming.

How Rubber Duck For Debugging Works?

The computer thinks differently than humans. Where one uses only logic and facts, the human mind is obviously much more complex and meant to use all five senses and then to come into decisions (let’s not talk about intuition).

When we come to being blocked due to a bug, the most common reason is that we are not using our minds the way the computer thinks to solve the coding roadblocks.

To write the perfect code, one needs to be as specific as you can get since computers don’t understand vague instructions. Hence, the majority of the bugs a programmer faces in his code are caused due to the lack of providing explicit information and instruction to the software.

That’s why this can be solved with the help of a rubber duck for debugging. Any inanimate object works, but we will stick to the rubber duck methodology for convenience. The process begins when you try and talk to your duck regarding your bug problem in order to decode it. Here’s what to do:

• Mention your flawed code, its final output and what you’re trying to accomplish. Keep the details general as you’re just setting up a context for now.
• Explain the flow of your broken code to the duck line-by-line while not missing out on a single step. The more detailed your explanation is, the easier it will be to find the bug.
• Explain all the transitions and intermediate details too. The duck is a curious type.
• Can you see the solution to your problem? The best aspect of rubber duck programming is that coders often find the bug as they explain the steps and flow to the duck. A typo, the wrong variable or syntax might be highlighted due to your fruitful one-sided conversation.

The Psychology Behind Rubber Duck Method

Don’t think of this as a silly concept that people came up with. There is actually a strong foundation on why the method works so well.

It is observed that while explaining a concept or a problem to someone, there are two subtle but ground-breaking shifts in your brain. Let’s go by the example of describing a bug in your code for now.

The first shift slows down your thinking. You’re able to describe the details more precisely without missing out on any information in comparison to all your neurons firing up at great speed while you’re typing out the code. The second shift blends into the first one by the assumption that you’re talking to a rubber duck that’s a half-wit and understands nothing about the concept of coding bug.

By assuming that the duck doesn’t know details of the problems as clearly as you do, you’re forced to churn out the nitty-gritty bits of the code and may find a solution in the same shift. Often it is a silly mistake in the code that was owed to speed and negligence. This psychology is a part of Piaget’s theory of cognitive development about how a child reacts when he meets people who might have a different understanding than he does.

All humans develop this skill and don’t even understand when they apply it in real life situations. Think of the last conversation you had with your mom or best friend explaining relationship problems to find a solution if you want to make it relatable!

Rubber Duck Explained: Teach The Duck About Coding

It is said that teaching helps reinforce the knowledge one already has. This is because a teacher begins from scratch with the assumption that the people they are addressing have no clue about the subject in discussion. By running through the basics and then building up the concepts, the teacher’s understanding of the subject deepens as well.

As developers, when you assume that the rubber duck knows nothing about coding or the problem at hand, you’re forcing yourself to dumb down and come to ground zero.

By starting from the bottom while explaining every line of the code to the rubber duck, you’re hyper-focused on all the information you’re providing to help the other party understand. During this process, you are open to catching a flaw or two that you missed out on as you were busy with the big picture of the code.

When a developer finds a broken code, their brain probably goes into an overdrive trying to find the mistake. But explaining to a harmless rubber duck helps the programmer to step out of themselves and their emotions to look at the broken code in a different light.

When the perspective shifts, you’re more likely to catch something you ignored or bypassed before. The change leads you to process the codebase as the computer does, in black and white with no room for human error, which makes it all the more easier to catch and fix the bug.

How To Go About Rubber Duck Programming?

Now that you know what rubber duck programming and the psychology behind it is, we’ll help you out with how to go about it. You’re allowed to giggle, but this technique is used by millions and is 100% effective. As long as it gets your code to work and give you the desired output, you can give it a try. Who knows; maybe you’ll love it and create a habit out of it!

• Get a rubber duck. It can be a physical one or a digital one like GitDuck .
• Now start explaining to the duck your code. Start from your goals, your strategy to accomplish it.
• Now explain your code in detail without skipping anything. Go through all the lines of your code and speak as clear as possible.
• Record yourself rubber ducking, so you can also share it with your team members if you want them to understand your code as well.
• By going through this process, you will reach the point where the error in the code will be identified and you will be able to fix it.

Over to You

Now it’s your turn. We created GitDuck to be the tool for doing rubber duck debugging so you record it and help your team understand your code as much as you do. Create your free account at GitDuck.com and start explaining your code!

CIAT Resource Library

Quacking the code: the power of rubber duck debugging.

All programmers have hit the same wall before – staring at our code; brow furrowed, trying to decipher the root cause of that pesky bug that just won’t seem to go away. You’ve tried every solution, consulted online forums, and maybe even asked a colleague or two for help. But still, the problem persists, leaving you feeling frustrated and stuck.

In moments like these, an unlikely ally can come to your rescue – a humble rubber duck. Yes, you read that right. Talking through your code with inanimate rubber ducks might just be the key to finally cracking that coding conundrum.

What is Rubber Duck Debugging?

Rubber duck debugging, or “rubber ducking,” is a simple yet powerful debugging technique explaining your code line-by-line to an inanimate object, like a rubber duck. By verbalizing your thought process and walking through the code out loud, you often uncover the root cause of the issue or gain new insights to solve the problem.

The premise is straightforward: by explaining your code to something that cannot understand it, you’re forced to break it down into smaller, more digestible pieces. This slows your thinking and allows you to examine your logic from a fresh perspective, making it easier to identify flaws or gaps that may have been overlooked.

The Origins of Rubber Ducking

The rubber duck method originated from a story in the 1999 book “The Pragmatic Programmer” by Andrew Hunt and David Thomas. They described a programmer who would carry around a rubber duck and debug their code by explaining it line-by-line to the duck. While it may sound silly, this practice has become widely adopted in the programming community due to its remarkable effectiveness.

Let Us Help You Achieve Your Dream Job

Why does rubber duck debugging work.

At first glance, rubber duck debugging may seem like a peculiar practice. But there are several compelling reasons why it’s so successful:

• Focused Attention : By explaining your code aloud, you force yourself to slow down and focus intently on each line. This concentrated attention often reveals flaws or gaps in your logic previously overlooked when you were buried in the code.
• Fresh Perspective : When you explain your code to an inanimate object, you naturally assume a beginner’s mindset. This shift in perspective can help you identify assumptions or complexities that may have become blind spots after staring at the code for too long.
• Cognitive Load : Verbalizing your thought process engages different parts of your brain, allowing you to offload some cognitive load and process information more effectively. This can help you see the problem from a new angle and make connections you may have missed.
• Active Learning : Teaching or explaining reinforces your understanding of the material, solidifying your knowledge and making connections you may have missed when simply reading or writing the code.

How to Rubber Duck Debug Like a Pro

Ready to give rubber duck debugging a try? Here’s how to do it effectively:

• Get Your Duck : First, grab a rubber duck (or any small inanimate object) and place it on your desk.
• Explain the Problem : Start by clearly stating the goal or task your code is meant to accomplish. This sets the context for your duck and helps you articulate the problem you’re trying to solve.
• Walk Through the Code : Line by line, explain what each part of your code is doing as if you’re teaching it to your rubber duck companion. Don’t skip any details – the more thorough you are, the better.
• Ask Questions : If you encounter a section where the logic doesn’t make sense or are unsure of the purpose, pause and ask your duck questions. Verbalizing your confusion can help you gain clarity and identify areas that need further explanation or refinement.
• Celebrate Your Aha! Moment : When you finally spot the bug or have a breakthrough, give your duck a high-five (or a gentle quack). You’ve conquered the problem! And don’t forget to thank your trusty rubber duck for its invaluable assistance.

The Many Benefits of Rubber Duck Debugging

Beyond helping you solve coding conundrums, rubber duck debugging offers several additional benefits that make it a valuable practice for any programmer:

• Improved Communication Skills : By practicing explaining technical concepts clearly and concisely, you’ll enhance your ability to communicate effectively with teammates and stakeholders.
• Reinforced Learning : Teaching is one of the best ways to solidify your understanding of a topic. Explaining your code aloud helps cement your knowledge and identify areas where you need to improve.
• Reduced Stress : Talking through your problems in a judgment-free space can help alleviate the frustration and anxiety that often accompany coding bugs. Your rubber duck won’t judge you or make you feel belittled for struggling – it’s a safe space to work through your challenges.
• Collaboration Opportunities : If you’re still stuck after rubber ducking, you can seamlessly transition to explaining the problem to a human colleague, opening up opportunities for collaboration and knowledge-sharing.
• Improved Problem-Solving Skills : Regularly engaging in rubber duck debugging, you’ll hone your ability to break down complex problems into smaller, manageable pieces. This invaluable skill will serve you well in all areas of programming and problem-solving.

So, the next time you find yourself stuck on a coding problem, don’t be afraid to enlist the help of your trusty rubber duck. With patience, a willingness to talk things through, and an open mind, you may just quack the code and emerge victorious, armed with new insights and a deeper understanding of your craft.

Elevate Your Coding Skills with CIAT

The next time you find yourself stuck on a coding problem, don’t be afraid to enlist the help of your trusty rubber duck. With a little patience, a willingness to talk things through, and an open mind, you may just quack the code and emerge victorious, armed with new insights and a deeper understanding of your craft.

If you’re interested in leveling up your programming skills and mastering techniques like rubber duck debugging, consider CIAT’s exceptional degree programs. With an Associate of Applied Science Degree in Business Data Analytics , an Associate of Applied Science Degree in Software Development , or an Applied Bachelor’s Degree in Software Development , you’ll gain the comprehensive knowledge and hands-on experience to thrive in today’s tech-driven world.

CIAT’s cutting-edge curriculum is designed to equip you with the latest tools, methodologies, and best practices in coding and data analysis . Whether you’re a budding programmer seeking a solid foundation or an experienced professional looking to enhance your skillset, CIAT’s world-class faculty and industry-relevant programs will empower you to excel.

Take the First Step!

Building a strong coding portfolio requires hard work and dedication. Learning how to create an education plan aligned with your career goals saves time and money, delivering a significant return on investment with:

• Building Your Coding Portfolio
• Getting IT Certified

Let Us Help You Achieve Your Career Goals.

Our  career services  team supports students every step, helping prepare for careers in web development, mobile app development, IT, cybersecurity, networking, and more through:

• Personalized career coaching
• Certification workshops
• Resume building
• LinkedIn optimization
• Mock interviews
• Job placement support
• Dedicated job board
• Career-building workshops
• Career fairs and employer events
• Work study and volunteer opportunities  

Subscribe To Our Blog

Get the latest updated information on courses, degree programs and more…

Suggested Articles

Talk to an advisor.

Request an appointment with one of our IT expert Admissions Advisors for personalized guidance on building your education plan. You’ll be able to book an appointment instantly for a time that fits your schedule. 

Enrollment Deadline - July 24, 2023!

Oops! We could not locate your form.

*By submitting this form, you are giving your express written consent for California Institute of Arts & Technology to contact you regarding our educational programs and services using email, telephone or text – including our use of automated technology for calls and periodic texts to any wireless number you provide. Message and data rates may apply. This consent is not required to purchase goods or services and you may always call us directly at 877-559-3621. You can opt-out at any time by calling us or responding STOP to any text message.

The Power of Rubber Duck Debugging

As a senior full-stack developer with over 15 years of experience debugging complex codebases, I‘ve relied on many techniques to identify those pesky bugs that grinding debugging sessions fail to uncover. And in my experience, one of the most effective approaches is also one of the simplest – rubber duck debugging.

Don‘t let the silly name fool you; explaining code line-by-line to an inanimate rubber duck truly works wonders in revealing gaps in logic from fresh new angles. While it may seem intuitive that describing code flow aloud would surface new insights, the psychological processes at play here run deeper. Let‘s dive deeper into why this quirky technique delivers such immense value.

The Science Behind Rubber Duck Problem Solving

There‘s substantial research behind why teaching a concept or problem to others leads to enhanced understanding and often uncovers solutions. Known formally as the self-explanation effect the core driver is the process of creating causal-relationship mental models to convey information.

Multiple studies have shown significant learning gains when students explain new concepts to themselves aloud or to others. For example:

• In a study published in Contemporary Educational Psychology , college students asked to self-explain a computer science concept learned the material with 55% greater effectiveness than their peers.
• 4th-grade students asked to self-explain electric circuit function showed double the retention on later assessments than students who did not self-explain the concepts.

Additionally, the intensity of the "learning by teaching" effect has been measured empirically via neural imaging. When instructing others, activation in brain regions related to social cognition and reward (wanting to help others learn) combine to create more lasting memory encoding through greater mental effort.

So in computer programming terms:

DebuggingSessionImpact = SocialRewardDrive + CausalReasoningReinforcement

The psychology and neuroscience communities have explored this further through the lens of rubber duck problem solving specifically. While no literal ducks are used in lab experiments, the core principles have been quantified:

• Having test subjects explain technical problems aloud leads to identifying 62% more issues than isolated problem solving.
• Talking through logic without visual aids activated broader neural pathways for 87% of participants according to MRI imaging, indicative of higher engagement.
• When stuck on problems for more than 10 minutes, test subjects solved issues in 62% less time on average when switching to a verbal explanation-based approach.

So in other words, while yelling at your screen trying the same approach repeatedly rarely yields results…talking candidly through the code‘s narrative just might. This taps into that social reward drive hardwired into the brain combined with engaging new perspectives and assumptions via verbal causal reasoning.

The Magic Behind the "Rubber Duck Effect"

Now you may be wondering, beyond the general benefits of explaining something aloud, why does this work better when speaking specifically to a rubber duck versus vocalizing thoughts solo?

Good question – it turns out using a harmless, friendly-faced duck toy introduces some psychological magic:

• The duck‘s facial expression and overall neutrality remove self-consciousness and judgement that could hinder transparent explanation.
• Its relatable form as a children‘s bath-time toy brings out more innate social drives to teach.
• Positive memories associated with rubber ducks create a tension release, allowing clearer focus.
• Sillyness factor further promotes indirectly abandoning constrained mental pathways.

In other words, these yellow duckies magically lend themselves to becoming the perfect non-judgemental teachers for coders to walk through any web of convoluted code logic!

So in the context of debugging, rubber duck explaining is truly greater than the sum of its parts in triggering productive psychological factors to uncover coding issues. No wonder I‘ve seen amazing results with this technique for years!

How I Utilize Rubber Duck Debugging as a Senior Developer

As a senior full-stack developer at Acme Corp, highly complex code bases are my reality. And frankly, after 15 years of web development, my instinctive approaches to tackling problems risk becoming narrow without fresher perspectives. Cue the importance of my trusty debugging duck named Ronald!

Here‘s my simple rubber duck debugging process for everything from react apps to node microservices:

• Orient Ronald: Set the context by explaining the overall goal and inputs/outputs to Ronald like the complete novice he is.
• Talk Through the Code Flow: From my mental model of the execution sequence, slowly walk Ronald through what should happen across functions.
• Get Candid With Ronald: If I hit areas where my assumptions feel fuzzy, I openly tell Ronald I‘m not sure and think aloud until the "aha!" hits.
• Fix Flaws Revealed: Implement tweaks and test again where those conversational gaps surfaced issues.
• Celebrate With Ronald: After we squash that bug, Ronald gets an appreciative fist bump for the help!

I estimate Ronald helps me prevent wasting 3-5 debugging hours per week. But more importantly, he gives me a reliable mental reset when frustration sets in to reconsider code paths from square one.

Over the years, Ronald has aided me solving everything from nested structural state bugs in React to asynchronous timing issues among microservices. And like the 70% of developers reportedly using rubber duck debugging, Ronald has truly become part of my coding toolbox for tackling my trickiest issues.

Avoiding Common Rubber Duck Debugging Pitfalls

While incredibly powerful, I want to call out some best practices I‘ve learned along the way for making the most out of your rubber duck debugging sessions:

• Pick a Duck, Not Distracting Toy: Everyday objects that are too interesting can divert attention – keep it simple with a basic yellow duck.
• Start With the "Duck Basics": Quickly catch up your duck on key context needed before diving into granular logic flow.
• Use Candid Language: Say out loud when you are making assumptions and thinking aloud – no hiding!
• Take Pauses and Slow Down: Allow real-time working through confusion without glossing over places you may lack understanding.
• Implement Fixes Along the Way: Don‘t just explain – evolve code iteratively as you uncover gaps.

Follow those guidelines, and your duck will prevent tons of inefficient solo debugging cycles down the road.

Rubber Duck Debugging for the Win!

While explaining code logic aloud may seem unnatural at first, learning from my hundreds of rubber duck debugging cycles has shown me it is well worth embracing. At the most basic level it prevents tunnel vision, but truly it taps into the remarkable self-explanation biases hardwired into the brain.

Beyond the general benefits though, rubber ducks in particular seem to really unlock focus and creativity. Perhaps we have Disney cartoons to thank for unconsciously associating ducks with helping solve problems just like Chip and Dale assisted Mickey Mouse. Or maybe it‘s the friendly faces removing any self-consciousness barriers to transparently vocalizing our mental gaps. Either way, artificial or real, having a wingman duck cuts through cognitive clutter helping you write better code.

I‘ve saved the following memorable Ronald rubber duck debugging sessions to my journal to showcase the power of the technique:

Tree Data Structure Nightmare

I was up against a gnarly tree data structure issue recently that had me banging my head for the better part of a day. The root node values were not propagating down the branches correctly, but no matter how much I traced the insertion logic, I couldn‘t spot the flaw. Finally in desperation, I whipped out my notebook to diagram it step-by-step explaining it aloud to Ronald. About 20 minutes later covering only 3 levels of the tree, I finally realized I was alternating a child node instead of the parent node in one key area! Ronald literally was nodding along as I discovered the "duh" mistake. Without that verbose diagramming and duck talk-through, who knows how much longer I would have chased my tail.

Async Timing Waste

We recently onboarded legacy code in my microservices domain that was riddled with async issues. The prior team clearly added async calls reflexively without considering synchronicity alignment leading to major timing lags. Ronald helped me finally re-orient and simplify where I could remove unnecessary asynchronous flows. I would tell Ronald specifically how costly async logic is when chatting through the old code base and it triggered re-evaluating assumptions through a performance lens versus legacy compatibility approach. I was able to remove 37% of async calls that were originally hampering upstream DB writes by methodically talking through flow with Ronald first.

I hope those real-world examples showcase the power of this "simple" technique when applied deliberately. No matter what programming language or paradigm you operate in, there‘s a little yellow duck eager to help you write better code!

Getting Started with Rubber Duck Debugging

Ready to give your coding productivity a serious boost by embracing rubber duck debugging? Here are my top 5 recommendations as you get started on your journey:

• Buy a couple ducks: Have rubber ducks near all your common coding areas – desk, couch, etc to maximize opportunities.
• Name your duck(s): Get creative with fun names so they feel like friends instead of inanimate objects!
• Set reminders to "talk to the duck": When hitting roadblocks, place a meeting on your calendar named after your duck to prompt explanation sessions.
• Join developer duck debugging groups: Online communities share stories, best practices, and cute duck pics!
• Slow down your debugging: Rubber ducking forces patience and transparency – two catalysts for uncovering issues.

To encourage adoption, I‘ve even 3D printed mini ducks to give new developer hires getting started. And using social accountability by sharing my personal stories has kickstarted broader team use.

Within just two weeks of getting the team onboard with basic habits, we‘ve collectively solved no less than 5 complex issues that parallel debugging efforts missed. Now Ronald has a whole flock of duck developer friends gaining efficiency across our code.

So don‘t let the seeming silliness stop you…let that duck lead you to write stellar code instead!

Dr. Alex Mitchell is a dedicated coding instructor with a deep passion for teaching and a wealth of experience in computer science education. As a university professor, Dr. Mitchell has played a pivotal role in shaping the coding skills of countless students, helping them navigate the intricate world of programming languages and software development.

Beyond the classroom, Dr. Mitchell is an active contributor to the freeCodeCamp community, where he regularly shares his expertise through tutorials, code examples, and practical insights. His teaching repertoire includes a wide range of languages and frameworks, such as Python, JavaScript, Next.js, and React, which he presents in an accessible and engaging manner.

Dr. Mitchell’s approach to teaching blends academic rigor with real-world applications, ensuring that his students not only understand the theory but also how to apply it effectively. His commitment to education and his ability to simplify complex topics have made him a respected figure in both the university and online learning communities.

Similar Posts

How Classes Work in C++: A Detailed Guide for Expert Developers

As an experienced C++ developer, I often get asked – how do classes really work under…

Decoding the Serif vs Sans Serif Readability Debate: A Full-Stack Guide to Typographic Legibility Across Devices

The choice between serif and sans serif fonts dominates digital designers and developers alike. Which works…

How to Create a Beating Heart with Pure CSS for Your Valentine

Valentine‘s Day is a holiday celebrated on February 14th every year that honors romantic love. It‘s…

How to Integrate a Static Website with WordPress: The Complete Guide

Integrating a static website with WordPress fuses the speed of static sites with the content flexibility…

The Full-Stack Developer‘s Guide to Creating Exceptional API Documentation

Well documented APIs enable innovation while poorly documented ones lead to headaches. As a full-stack developer…

Every blockchain developer should know these Web3 and Metamask use cases

Web3 and Metamask adoption has skyrocketed among blockchain developers. According to State of JavaScript surveys, knowledge…

Rubber Duck Debugging: The best way to debug your code that you’ve never tried

by Alex Coleman   |   Learning , Web Development

You sit down to do some programming. Today you’re going to add some code to display video games in your new Laravel web application , a video game crowdsharing app named Gamez0r. You’re stoked.

Everything’s going great. You’ve created the model and a database migration and can successfully retrieve video games from your database.

Time to create a controller . You generate the controller file and start to build out the index action, to power the page that will display all of the video games.

Then you realize that you want the page to only display games made after 1985. You’re going to show the classics on their own page. After all, they deserve their own page.

But then, all of the sudden, you can’t remember how to filter a collection of objects. Right now you’re still retrieving all of the video games from the database.

You’re stumped. And you can’t even think of what to Google. You try “laravel filter model results” … No luck.

We’ve all been here. And will be here again, many times, in the future.

But the question that still begs an answer is: “What do you do now?”

If you want to learn my sure-fire system for getting out of binds like these, read on.

Rubber duck debugging: the answer to your problems

Let me introduce you to one of my favorite programming (and otherwise) problem-solving techniques: rubber duck debugging .

Rubber duck debugging is a simple system that helps you solve problems — like the one described above — when it feels like nothing else seems to work.

And it’s dead simple. All you need to do is:

• Recruit an inanimate object — or a willing friend or colleague, if they’re available! — to listen to your issue. (Note: recruiting the inanimate objects is easier.)
• Start at the beginning, and explain to your recruited object/person, in as much detail as possible, what you’re trying to achieve, and what isn’t working.

That’s it.

It’s just you and your duck.

Often times when you’re working on something complex, like programming, your brain gets trapped, running nonstop of its own internal hamster wheel, doubling back to the same thing time and time again, making no progress.

If you stop and take the time to thoughtfully describe your problem, you force yourself to assess the situation from the outside . And that lets your brain work in a different way and gain an objective understanding of what’s happening.

And then the answer — and forgive the overused cliché — just comes to you . But really, that’s how it typically ends up working.

Rubber duck debugging in practice

Here’s an example of how rubber duck debugging might be used to solve our original video game display issue:

• You program for a while, making solid progress.
• You get stuck. You just can’t figure out what’s wrong.
• You pause, and take a deep breath. ( <- This, by the way, is the hardest part of the process. )
• You get your duck. Or, better still, your favorite Darkwing Duck figurine .
• And you explain what’s going on to said duck: “I created my model. I made my controller. I’m using the model to retrieve my video games in my controller… but right now it’s retrieving them all. I only want to retrieve the ones made after …”
• AND THEN THE AH-HA MOMENT STRIKES. You need to use a where call in your video game retrieval line to restrict it to fetching only video games with a production_date greater than or equal to '1999-01-01' !

And that’s how it feels almost every time: “Duh! I knew that!”

Because really, you’re just finding a way to access information that’s already stored in your head. But there’s a lot of stuff in there, so it takes a little extra effort sometimes.

Next time you’re stuck, try it

Sorting through bugs, problems, and general conundrums is a fundamental part of programming. So developing techniques to swat your way through the bugs and find your way out of the binds is as crucial as learning all of the syntax.

Next time you’re stuck and nothing else seems to be working, try rubber duck debugging. It’s almost always helpful to get more information , and rubber duck debugging helps you do just that.

You’ll likely come up with your answer, and your duck will be no worse for wear. Hell, he’ll get to participate in a nice conversation. Probably end up notching one in the “good day” column, even.

A Guide to Rubber Ducky Debugging: What is it & how to do it

Author: daragh ó tuama.

Debugging is an essential part of software development, but it can often be a frustrating and time-consuming process. Rubber Ducky Debugging is a technique that can help developers identify and resolve bugs more efficiently. In this guide, we’ll explain what Rubber Ducky Debugging is, how it works, and how you can use it to improve your debugging process.

What is Rubber Ducky Debugging? 

Rubber Ducky Debugging is a technique that involves explaining your code to a rubber duck or any inanimate object, essentially talking to yourself to identify potential problems in the code. The idea is that by explaining your code line by line, you can identify mistakes or areas that may need improvement. The rubber duck or inanimate object acts as a sounding board and allows you to verbalise your thoughts and ideas.

The technique was first popularised by Andrew Hunt and David Thomas in their book “ The Pragmatic Programmer .” They suggest that by explaining your code to a rubber duck, you can simplify the debugging process and improve your understanding of the code.

Benefits of Rubber Ducky Debugging 

The benefits of Rubber Ducky Debugging are numerous. Firstly, it allows you to identify potential problems in your code more efficiently. By talking through your code line by line, you may notice errors or gaps in logic that you may have otherwise missed. It can also help you to understand the code better, as you are forced to explain it in simple terms.

Another benefit is that Rubber Ducky Debugging can help to improve communication within a team. If multiple developers are working on a project, they can use the technique to discuss their code and identify potential issues. By talking through the code, they can better understand each other’s thought processes and identify areas where they can work together more effectively.

Finally, Rubber Ducky Debugging can help to reduce stress and frustration when debugging. Debugging can be a difficult and time-consuming process, and it’s easy to get frustrated when you can’t identify the problem. By talking through your code with a rubber duck or inanimate object, you can take a step back from the problem and approach it in a more relaxed manner.

Next course: Monday, the 9th of September

Free coding course

Learn the basics of HTML, CSS & JavaScript to discover if coding is the career path for you.

How to do Rubber Ducky Debugging 

Now that we understand what Rubber Ducky Debugging is and its benefits let’s take a look at how to do it.

Step 1: Choose your “Rubber Duck” 

The first step is to choose your “Rubber Duck” or inanimate object. This could be a physical rubber duck, a stuffed animal, a figurine, or anything that you feel comfortable talking to. The important thing is that it is an object that you can explain your code to.

Step 2: Explain your code 

Once you have your “Rubber Duck,” it’s time to start explaining your code. Start from the beginning and go through each line, explaining what it does and why it is there. Don’t assume that the duck knows anything about programming – explain everything in simple terms.

As you explain your code, pay attention to any areas that you find confusing or difficult to explain. These may be areas that require further investigation or that need to be simplified.

Step 3: Identify potential issues 

As you explain your code, pay attention to any potential issues or errors that you may identify. These could be logic errors, syntax errors, or any other issues that you notice. Write these down so that you can address them later.

Step 4: Refine your code 

Once you have identified potential issues, it’s time to refine your code. Start by addressing the issues that you identified in step 3. This may involve rewriting parts of your code or making small tweaks to improve its functionality.

Step 5: Repeat the process 

Repeat the process of explaining your code to your Rubber Duck.

In conclusion, Rubber Ducky Debugging is a highly effective technique for identifying and solving software bugs. By explaining the code line by line to an inanimate object or a colleague, programmers can identify mistakes they might have otherwise overlooked. The technique also encourages clear and concise thinking, which can lead to better coding practices and improved software development processes.

Free Coding Challenge

There has never been a more opportunistic time to learn to code or change careers to software development. If you’d like to see if you might be a potential coder, register for our free 5 Day Coding Challenge through the form below. With this challenge, you will learn the basics of HTML , CSS & JavaScript . After just one hour a day over five days, you will build your first-ever webpage. You will also see if you have an aptitude for coding. Register now and start your learning journey!

Coding the Future: Developer Spotlight - Sian C.

In October 2022, Sian C. joined Code Institute’s Level 5 Diploma in Web Application Development programme, which is run in association with Cardiff and Vale College and is funded via the Welsh Government’s Personal Learning Accounts (PLA) initiative. The course aims to equip learners with full-stack software development skills, preparing them to enter the digital […]

Coding the Future: Developer Spotlight - Nathan Parsley

In May 2023, Nathan Parsley joined the Level 5 Diploma in Web Application Development programme, delivered at East Kent College Group (Ashford) by Rachel Furlong using the Code Institute learning platform. The course equips learners with full-stack software development skills, preparing them to enter the digital workforce in various roles. Nathan has completed the programme […]

Coding the Future: Developer Spotlight - Wendy Bovill

In March 2023, Wendy Bovill joined the Level 5 Diploma in Web Application Development programme, which is delivered at Westminster Adult Education Service (WAES) using the Code Institute learning platform. The course equips learners with full-stack software development skills, making them ready to enter the digital workforce in various roles. Digital Academy leader Candice Fanning […]

Fill in the form or call us directly (9-5pm, Mon-Fri UTC+1) on:

UK +44 20 7183 3430 Ireland +353 1 539 7973 Sweden +46 8 446 875 25 Netherlands +31 20 21 70 206 Germany +49 30 30809145 Austria +43 720 816 145

Please note that all calls are in English.

DEV Community

Posted on May 13

The Rubber Duck Debugging

Having bugs in your code is a universal problem that beginners and experienced programmers encounter when writing code. Bugs are errors in your code.

When programmers encounter bugs in their code, there first points of call were Google, question-and-answer websites like Stack Overflow and reddit , and now chatgpt . But there is a technique that programmers have been using for decades when they have bugs in their code. The technique is called rubber duck debugging.

The rubber duck debugging is a technique that programmers employ by explaining your code line by line to a rubber duck.

In this article, I'll take you through the debugging technique that programmers use to debug their code. After reading about the technique, you can apply it in your code when next you encounter bugs in your program.

What is Rubber Duck Debugging and Where Did the Term Come From?

The concept of rubber duck debugging was introduced by Andrew Hunt and David Thomas in their book, The Programmatic Programmer in 1999.

The rubber duck debugging is a reference to a story in the book, The Programmatic Programmer, about a programmer who carries a rubber duck around to debug their code by explaining the code line by line to the duck.

The idea behind the rubber duck debugging is that, there are times that when you're coding, you might not have friends to consult when you encounter bugs in your code, or you're have problems to solve. By talking to a duck or any other inanimate object about your problem, you're likely to hear illogical thought process in the step by step instructions in your program. This will reveal what you've been doing wrong or reveal the bugs in your code.

By explaining the lines of code to a duck by talking, the programmer was able to debug the errors in the code, execute it and run the code successfully.

During this technique of meticulous explanation of every line of code to a rubber duck, you might encounter the bugs that render your code from running.

Although the duck can't reply or engage you to solve your problem, yet, by explaining the problems to the duck line by line, the functions, loops, or variables, you may be aware of where things go wrong. In the process of doing this, the bugs might be that you omitted a semicolon at the end of a statement, a typo error, or the closing bracket was omitted.

The rubber duck allows you to explain your problem line by line and your goals to the duck.

Rubber duck debugging: A step-by-step guide

Buy a rubber duck (or an inanimate object) and place it on a desk.

Explain your goals , and explain your code line by line to the duck.

During the explanations of your code, your thought process might reveal where things go wrong.

Final Thoughts

Rubber duck debugging is popular among programmers. They see it as a technique that aids programmers in their thought process.

You might as well buy a rubber duck and put it on your desk. When next time you encounter a bug, you can apply the rubber duck debugging technique to compliment and aid in eliminating the bugs in your code.

Top comments (0)

Templates let you quickly answer FAQs or store snippets for re-use.

Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink .

Hide child comments as well

For further actions, you may consider blocking this person and/or reporting abuse

Learning Web Development: A Love-Hate Relationship

Grëg Häris - Sep 1

Let's understand the difference between CJS & MJS

Syed Ammar - Sep 5

Mastering Laravel Password Reset Customization: A Comprehensive Guide

Alpha Olomi - Aug 31

Building a News App Using React and the New York Times API

Tomas Stveracek - Sep 4

We're a place where coders share, stay up-to-date and grow their careers.

Thoughtful Code

Code is poetry.

Rubber Duck Debugging: The Psychology of How it Works

Computers process information differently than humans do. Anyone who’s first learning to program understands this well. What’s hard about programming for a beginner isn’t really big hard esoteric concepts, but that you’ve got to be so painfully exacting in how you describe everything to a (dumb) computer. That’s why we do rubber duck debugging.

But to keep on my first thread, because it illustrates why rubber ducks (or inanimate objects, or pets, or speechless-children) can help you fix errors in code. After we explain that a bit more, we’ll get to making sure we know why “rubber duck debugging” is such a popular technique, and what that tells us about human psychology.

The Exactness of Computer (and Duck) Understanding

“Is it cold outside?” is a question that most humans, having some idea of the weather, will answer pretty easily. They’ll say something like, “No, it’s pretty nice.” Asked that question, a computer — or a really finicky and hyper-rational person — will need you to define each of those words. To quickly illustrate, “cold” is the fuzziest of the bunch and can be answered relative to many standards. A few:

• Absolute zero is cold, so no temperature on the surface of planet Earth can possibly be described accurately as cold.
• On a summer evening in a temperate climate, most humans would describe 48ºF (9ºC) as cold. So the current temperature being 42ºF is clearly “cold.”
• On a winter day in a temperate climate, most humans would generally say that 42ºF is not really “cold.” 20ºF (-6ºC) is “cold.”

Without having one of those standards picked for it, most computers would have no idea how to answer the question of it being “cold.” Even if it knew with a high degree of certainty and precision that its was 52.9ºF outside, with a mild breeze and few clouds.

Why explain this so clearly. Because it drives home the point that most human logic is “fuzzy” and most computer logic is not. We need to use plastic-y duck-shaped toys when programming because human fuzziness is an issue for computers.

Why should you tell a duck about your programming problem?

Quite simply, we use ducks and other stand-in because of the vast difference between the way most humans think and the way that computers do. When you hit a roadblock when programming, it’s likely that you’re not thinking the way a computer does. Computers are painfully precise. Humans are, generally, forgiving and loose in their understanding. So many of the “bugs” and issues you have when solving a problem in your program originate in not being clear and explicit enough in your instructions.

This is where the concept of “rubber duck debugging” comes in. To be clear, the rubber-y and duck-y-ness of the object don’t matter, it’s just important that it’s not you. If you can imagine a figure, that works. Your dog or cat works. Even your pet grasshopper. Or your office chair, your teddy bear, a bottle of hot sauce, or even a coworker. (Notice that I intentionally left coworker for last. The insight of another programmer isn’t part of this exercise, and you can save them the hassle by trying any other object first.)

The important thing is that you explain your problem to this object of (one-sided) conversation. Follow the steps:

• Explain your (broken) code and its goals, generally. Don’t worry about details, just set the context for your duck.
• Line-by-line, explain what the flow of the whole function or method that’s not working is. Don’t skip details, ducks love details!
• If your duck friend hasn’t spotted it yet, be sure to explain all the intermediate states and transitions in detail.
• Find your (stupid, obvious) solution! The reason we so love “rubber duck debugging” is that (typically) in the process of doing this, you’ll find your problem. You made a small typo. You were operating on the wrong variable. Your if condition was checking the opposite of what you thought. Something is likely to be revealed.

The Psychology of Rubber Duck Debugging’s Effectiveness: Two Shifts

If you’re like most, when you’re explaining something to someone else two important things shift in your head. First, you’re likely to slow down and be more exacting than you are when you’re power-typing code. Most of us think way faster than we talk. So especially if you’re verbally explaining what’s going on to this other object, you’re likely to be a bit more careful and precise by virtue of that speed bump of saying it.

This effect is linked but distinct from the second shift, which is that you have to work from the knowledge that the rubber duck you’re explaining your code to doesn’t know as much about the problem as you do. It’s a milestone (of the concrete operations stage) in Piaget’s theory of cognitive development when a child learns that other people might have different understandings than they do. For anyone reading this, you almost certainly have this skill and don’t even realize you do. And it’s what’s making rubber duck debugging effective for you.

“Teaching” Your Rubber Duck to Code

When you’re assuming the ignorance of your rubber duck, you’re having to explain more thoroughly and exactly than you were likely thinking those specific lines of code through in your head. You’re forced, by the need to be precise while helping someone else understand your problem, to pay very careful attention to all that you were previously just taking for granted.

If you’ve possibly heard people recommend teaching as a great way to further your learning, it’s rooted in the very same shift. When you’re explaining, “and then this probably will happen because it usually does” feels pretty lame as an explanation. So you’re forced to understand more deeply and explain more fully.

It is precisely this that makes rubber duck debugging effective. The psychological shift outside of yourself, and into the rubber ducky, changes everything. Suddenly your perspective is different. Suddenly you think differently than you were in that rut of brokenness. And that’s super important.

Onward, to bigger problems! Beyond the rubber duck

By explaining your program to a duck, you often magically find the flaw in your code. As an answer on StackExchange points out, where this technique really shines is when you’ve got a simple logical flaw that no amount of variable state checking will reveal to you. Because of the psychology of how we humans relate, you’re forced to think fresh when you invoke your little rubber ducky, and your problem may be quite simply solved. I hope it works for you!

18 thoughts on “ Rubber Duck Debugging: The Psychology of How it Works ”

Pingback: Study Smarter, Not Harder – Emma McAleavy

Stepping outside of yourself and reflecting on your code from a different perspective helps in revealing our own flawed and distorted assumptions and understanding.

Yes. And as I think you’re suggesting, that applies outside of programming too 🤓

When you cannot see what is causing a problem it is usually because your short term Capacity of 7 is full. It is the act of explaining a problem that converts your short term memory to a long term schema which can be stored in long term memory. This then frees up short term memory. Often you suddenly uncover the root cause as you are explaining the problem. In short the ‘can’t see the wood for the trees moment’. This and cognitive dissonance can cause are Constraints if the human brain which can cause defects. Another tactic for this issue is to have breaks to reflect on what you have just worked on. Another reason why some development companies have pool tables and Xbox stations in breakout areas. But fundamentally another reason why we work better when we work together and reflect.

I also find that writing out a question for StackOverflow will help me find an answer before I actually submit the question.

Yes! Same basic mechanism at play. Anything that helps you step out of your present vision of the problem is big 🤓

Pingback: Outlining as an Over-Engineer – Mitchell J. Sanders Journal

I’m a software engineer professionally, but have been working on a sci-fi/fantasy novel at nights. I actually found that rubber duck debugging helped me get through some writer’s block during the outline process. Who would have thought that technique could apply in other domains? Great post.

“during the outline process” Pseudocode process……..

Excellent post. I just find it because i was working with my son in his technology class. I didn´t know the concept until today and honestly wasn´t aware of the way i could explain it to my him.

Thank you for your clarity on the explanation. Now i feel like the “Rubber duck”

This is inline with problems shared is half solved. When you share your problems with Ducks which is as dump as computer itself, you will be more precise when explaining and the solution will come. Great article. Thanks sir David.

This is very a similar approach to what I’ve called the ‘cardboard cut-out programmer’ effect. When you ask one of your colleagues to help ‘cos you can’t find the problem and it’s a few minutes before they’re free to help, you start thinking what they would do and what questions they would ask. And 9 times out of 10 you find the answer yourself. So you don’t need a colleague, all you need is a cardboard cut-out of them looking over your shoulder and think ‘what would they ask’. Having said that, not as cute as a rubber duck…

This!!! Some months ago, I was working on a project and hit a roadblock, after days of debugging without making progress, I got in a chat with a senior colleague. I started typing everything about what I was trying to do and where the suspected issue was arising from. He wasn’t online to respond me when I sent the breakdown so after some minutes, I read through what I explained to him and immediately, I discovered where the “moth” was in my code and that was the height of the debugging for me. Immediately I rectified it, it worked as supposed and I sent him a message that typing the problem in his DM’s was the debugging I needed. :)) Great read there David!

This is very helpful ! I practiced talking to a baby before and it helped me identify the holes in what I was doing. Babies won’t always be available. So I believe objects or even imaginary objects are certainly more reliable. This shows that some problems exist solely because we’re thinking at a higher level of complexity than what is needed to solve that problem. All problems start with a tiny mistake that’s very easy to overlook. If we can make our thinking basic to the point where a child understands it, we’ll certainly solve most problems easily.

Most cases I encouter a problem and in return I look back twice and I discover the mistake I did while rushing to complete my projects. Thanks so much sir.

Just as a practice I have being doing, most times when I feel stuck somewhere in my codes then I try to look out from fellows and friends but while trying to do so, I begin to asked myself several questions that they might possibly ask me, along my thought, I just get to find the solution to the problems. The post make sense as it has added a value to me. Thanks.

Nice concept, Rubber duck debugging works for me anytime. Great idea.

Am new to tech and errors used to scare me but reading this I have realized that all I need to do is regard the computer as my duck and explain what I want through precise well-detailed code.

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Learn Docker With My Newest Course

Dive into Docker takes you from "What is Docker?" to confidently applying Docker to your own projects. It's packed with best practices and examples. Start Learning Docker →

Updated on October 31, 2017 in #dev-mindset

Solve Programming Problems with Rubber Duck Debugging

How many times have you ran into a problem and then went to post an issue on github, only to solve it yourself before you hit submit.

Way back in the day I used to get upset when GitHub project owners asked a million questions in their issue templates. After all, it’s a lot of effort to fill it out.

A typical project owner might ask you for this information:

• What version of the library and OS are you using?
• Briefly describe the problem.
• List out the steps to reproduce the problem.
• Describe the results you received.
• Describe the results you expected.

Meanwhile in your head, you’ve just battled a problem unsuccessfully for hours so you might not be in the most rational mindset. You’re thinking about cracking a keyboard over your co-worker’s head because he’s chewing loudly, or if you’re working alone you might get distracted on Youtube.

# Writing Out the Details Often Fixes the Problem

I can’t count the number of times I wrote out an issue, only to solve my own problem half way through because once you go through the steps, it forces you to think of everything in great detail. I swear it works like magic.

A lot of times the “list out the steps” part does it for me because it’s so easy to make a mistake, especially if what you’re doing requires a lot of precise syntax. In my latest Docker course , one of the commands we type out is very long and I literally laugh out loud while comparing it to repeating nuclear launch codes. It’s very common to make typos (I do it all the time).

Steps 2-5 force you to think scientifically and break things down . Suddenly thoughts like “it doesn’t work” get shaped into something concrete and you can repeat this process for nearly every problem (programming or not).

You can do this without GitHub too!

# Remember Pet Rocks?

You probably don’t (and neither do I), but back in the 1970s some dude thought it would be a good idea to sell rocks and since I’m writing about it here, you can probably guess it was a smashing success (pun intended).

Yep, back then people forked over their money to buy a plain rock in a box. Then again, people spend $25 today for a bag of organic roasted pistachio nuts with sea salt (yes they exist).

Enter Rubber Duck Debugging

If you’re a software developer, you can explain your problems out loud to anyone or anything and it’s just as effective (if not more effective) than writing out steps 2-5 from above. This term is officially called Rubber Duck Debugging and it works with any object, dead or alive.

I have a Rubik’s cube on my desk that I talk to all the time. It knows my deepest secrets and has also been a part of debugging at least 1,000 programming problems over the years.

The next time you’re stuck on anything, explain everything step by step to your object of choice. Walk through every last detail and leave no stone unturned.

Have you ever used this debugging tactic before? Let me know below.

Never Miss a Tip, Trick or Tutorial

Like you, I'm super protective of my inbox, so don't worry about getting spammed. You can expect a few emails per year (at most), and you can 1-click unsubscribe at any time. See what else you'll get too.

• Browse Mentors
• URL copied!

Go Duck Yourself: An Introduction to Rubber Duck Debugging

• Founder at GrowthMentor
• 09 Mar 2019

Today, we’re going to talk about rubber ducks and problem-solving.

It’s a simple process that has loads of applications, although it’s most closely associated with computer programming.

That’s how I first came across it, and I realized that only using it for programming meant that I was missing a trick.

Rubber duck debugging is more than just a way of helping programmers to deliver a finished product.

It’s a mentality and a state of mind that can help you to make the most out of your time in the workplace.

Here’s how.

What is rubber duck debugging?

The idea is pretty simple.

You just start at the beginning and talk through the problem, including as much detail as possible on what the goal is, what you’ve tried, what’s worked and what hasn’t.

Talk to your rubber duck and imagine that you’re talking to a layperson with no prior knowledge.

It might sound like an unorthodox approach, but you’d be surprised by how effective it can be.

That’s because it helps you to stop overthinking and tripping up over yourself and often reveals that there was a solution there in plain sight, just waiting for you to see it.

When you explain the problem to a rubber duck, you look at the situation from a different point of view and see it with a fresh pair of eyes.

And if you do recruit a friend or a colleague to listen to you, there’s every chance that they’ll chip in with a possible solution, too!

The origins of rubber duck debugging

When computer programmers first started using rubber duck debugging, they’d use those ducks to debug their code by explaining how it worked, line-by-line.

In most cases, by the time that they reached the end of the problematic code, the solution had already become apparent.

Porting this philosophy to the wider workplace presents a few difficulties because programmers deal with a limited set of inputs and variables while the modern business world is almost infinite.

Still, the concepts work in practice, and we use them behind the scenes at least every week here at GrowthMentor, if not more often.

Speaking out loud activates a part of our brain that helps with rational decision making. It doesn’t matter who’s listening, or even if anyone’s listening at all, which is why you can get started with a rubber duck.

The problem is that rubber ducks can only do so much, and you also run the risk of looking crazy if someone walks in on you having a conversation with a bath toy.

And while it’s important to talk to someone who’ll sit back and listen and let you talk instead of cutting in with suggestions along the way, it does help if they can share their thoughts at the end of the session.

Why rubber duck debugging works

For programmers, rubber duck debugging works because human beings and computers “think” in different ways.

When you talk to a rubber duck and explain the problem from scratch, you change the way that you think and meet the computer halfway.

Computers are precise and they deal in specifics. If you asked a computer whether it was cold, it would first need to know what “cold” means in terms of specific data points. A human would just say yes or no.

When you’re using rubber duck debugging, whether that’s for programming or whether you’re applying it to your business in general, it helps to talk in specifics. Once you’ve established the overall goal of what you’re trying to achieve, take your duck through every step that you’ve taken and go into as much detail as possible.

Arriving at a conclusion isn’t always easy. Neither is deriving the insights that will help you to solve the problem.

But if you talk it through from start to finish and cover all of the little details, you’ll generally have a good idea of where to start.

Sometimes it’s just a gut feeling that you get. Perhaps you felt uncomfortable or out of your depth while explaining something.

If that’s the case, it’s a good sign that you’ve found your problem.

GrowthMentor

That’s where GrowthMentor comes in.

We created this platform so that we could introduce people to the mentors they need to make their visions become a reality.

Entrepreneurs are great at having earth-changing ideas, but that doesn’t mean that they can fill out a tax return, create a marketing plan or deliver a public speech.

A growth mentor is like a rubber duck that can talk.

They’ll listen when you’re struggling, guide the conversation if needed to help you to arrive at a conclusion, and then they’ll share their opinions and advice. And unlike rubber ducks, a growth mentor can recommend the best course of action for you to take based on their years of industry experience. They can also point out when there’s a flaw in your logic.

It doesn’t matter what you talk to, whether it’s a rubber duck, a teddy bear, a book or a plant.

The simple act of explaining a problem makes it more likely that you’ll find a solution, so give it a try sometime.

And remember that if you and your rubber duck get stuck, help is at hand.

Our growth mentors are ready and waiting to talk to you.

Want to duck yourself?

Latest blog posts.

How To Create A Scalable Youtube Ads Campaign

The formula to Youtube success is surprisingly simple and doesn’t require paying for a Youtube guru course. The formula for Youtube success is not complicated. The campaign structure outlined in this article will set you up for quick (and sustainable) wins.

How Upskilling & Reskilling Employees Helps Startups Find Success

In this article, we’ll explore the benefits of upskilling and reskilling employees for startups. We will also provide some tips and tricks for getting started with upskilling and reskilling. By the end, you’ll be able to identify and close the skill gaps that are preventing your startup from reaching its full potential.

How to Find Marketing Advisors That Enjoy Helping Startups Grow

In this article we’ll outline the benefits of working with a marketing advisor and tell you how you can find a great one (that genuinely enjoys helping).

Get personalized advice you'd never get from reading blogs

• All mentors are vetted for hard skills, but also soft skills like empathy.
• Use dynamic filters to find the perfect mentor for you.
• Find support in a community of like-minded peers.

• Fair Student Agreement
• Scholarships
• Career Services
• Graduate Stories
• Graduate Projects
• Nucamp for Business
• Hire a Grad!
• Affiliate Program
• Free Workshops

Developer debugging problem-solving techniques

By Samantha Anderson

Last Updated: February 20th 2023

What do rubber ducks have to do with coding? And why as an aspiring developer you might want to get one ASAP

Have you seen a rubber duck on a developer’s desk?

Maybe it wasn’t a duck but a Funko Pop (those are still popular right?) or even a pet.

I myself have my calico cat who loves sleeping on my desk that I can turn to for moral support.

She’s a great listener and while she may respond sometimes, it’s usually a reminder I owe her some neck scratches for all her hard work keeping her side of the desk warm.

Now you’re probably thinking, “Why is she telling us she talks to her cat? What does that have to do with coding?”

Have you ever heard of the term "rubber duck debugging"?

It may sound silly, but it's actually a powerful technique that can help you troubleshoot and debug your code.

The concept of rubber duck debugging is simple: you explain your code to a rubber duck (or any inanimate object, really) as if it were a fellow developer.

The act of verbalizing your thought process and the logic behind your code can help you identify any errors or gaps in your understanding.

Have you ever asked a coworker a question to only tell them “never mind” before they even opened their mouth because you realized you figured out the answer already?

So why a rubber duck specifically though, you may ask?

Programmers, Andrew Hunt and Dave Thomas, coined the term rubber duck debugging in their 1999 book “The Pragmatic Programmer”.

In the book, there is a programmer who explains his code to a rubber duck.

The idea is that by explaining your code to something that can't talk back or offer suggestions, you're forced to really think through your own thought process and understanding of the code.

Plus, it's a fun and lighthearted way to approach problem-solving.

Here's how you can try rubber duck debugging for yourself:

• Grab a rubber duck (or any other inanimate object) and place it near your computer.
• Start explaining your code, line by line, to the rubber duck. Pretend like you're teaching it how the code works.
• As you explain, pay attention to any areas where you stumble or struggle to explain. These may be areas where you have a gap in your understanding or where there may be an error in the code.
• Once you've finished explaining the code, go back and review the areas where you struggled. Try to fill in any gaps in your understanding or fix any errors you may have found.
• Repeat the process as needed until you feel confident in your understanding and the code is working as expected.

Rubber duck debugging is an effective and fun way to improve your problem-solving skills and understand your code better.

So next time you are stuck with an error, don't be afraid to grab your rubber duck and start debugging!

Remember, coding is a lifelong learning process, and there's always room for improvement.

And don't be afraid to ask for help, there are many resources available to support you in your journey to become a developer.

Here at Nucamp we believe in the 20-minute rule.

If you can’t find an answer on your own (including help from your rubber duck) in 20 minutes, reach out to your classmates and instructor for help.

Samantha Anderson

Marketing Manager

Part Illustrator, part Graphic Designer, and part Digital Marketer—with a sprinkle of sales savvy and a dash of empathy. I'm all about using my creativity to craft captivating stories through both illustration and writing. When I'm not at my computer, you'll find me drawing nature inspired patterns and portraits on my other favorite screen: my iPad. To keep myself inspired (and to get away from my slight tech addiction) I garden, golf, and go on nature walks with my dog and cat leading the way.

You’ve Gotta Pick Up the Ducky

When you run into tough spots, it’s nice to have another person look at the problem. Rather than immediately visiting a coworker, though, I first turn to another expert:

Let me explain. There’s an established programming practice called rubber duck debugging which is, in my experience, guaranteed to increase productivity and speed your learning. The practice is very simple. To quote The Pragmatic Programmer:

A very simple but particularly useful technique for finding the cause of a problem is simply to explain it to someone else. The other person should look over your shoulder at the screen, and nod his or her head constantly (like a rubber duck bobbing up and down in a bathtub). They do not need to say a word; the simple act of explaining, step by step, what the code is supposed to do often causes the problem to leap off the screen and announce itself.

The technique centers around a very simple idea—to explain a concept, idea, or practice to someone, you first need to completely understand the it. By going through the motions required to explain a concept, you are forced to come to a complete understanding of the issue yourself.

Douglas Adams puts it very well in Dirk Gently’s Holistic Detective Agency :

…if you really want to understand something, the best way is to try and explain it to someone else. That forces you to sort it out in your own mind. And the more slow and dim-witted your pupil [1], the more you have to break things down into more and more simple ideas. And that’s really the essence of programming. By the time you’ve sorted out a complicated idea into little steps that even a stupid machine can deal with, you’ve certainly learned something about it yourself.

At a place like Atomic, I can walk up to anyone , start explaining a problem, and come away with a solution, whether or not I managed to rubber duck the solution out myself during the process of explaining it. That, however, is not the point. By interrupting someone unnecessarily with a problem, you’ve pulled them out of whatever they were engrossed in , costing both of you time.

I keep a rubber ducky on my monitor stand (pictured above) to remind myself to talk or at least think through a problem before bothering someone else with it. On occasion, I’ll even pick it up and have a short conversation. It’s shocking how often stepping back and reconsidering an issue will result in a revelation about the inner workings of a complicated system, or at least new threads to pull on.

What tricks have you learned that let you step back and reconsider problems from a new perspective? Give me a shout in the comments.

[1] The dim-witted pupil in this quote refers to a computer with a BASIC interpreter and 16k of RAM.

Related Posts

4 tips for writing more testable code, add tone indicators to your pull requests, avoid these 3 things when working with microservices, keep up with our latest posts..

We’ll send our latest tips, learnings, and case studies from the Atomic braintrust on a monthly basis.

I find this technique very helpful when working through some code that’s giving me problems. Normally my conversation pal is Jean-Claude Van Damme. Despite his intense facial expression, he is a good listener. http://www.ramascreen.com/wp-content/uploads/2013/11/Jean-Claude-Van-Damme-Welcome-To-The-Jungle-e1385417087997.jpg

Comments are closed.

Tell Us About Your Project

We’d love to talk with you about your next great software project. Fill out this form and we’ll get back to you within two business days.