The principles of debugging: Explained


Programming may be easy or difficult, based on the programmer. There are several parts present in programming, and you might even excel in one of them and not excel in another. That is totally fine. But when you act as a proper developer or programmer, you have to be able to find problems in your program and engage in a debugging process. Debugging is a bit difficult. If you are dealing with a large program, then finding the error would be like searching for a needle in the haystack. But even if you do identify the problem, how do you deal with it effectively? Will your first solution be the fix too? Not necessarily.

Debugging can be a complex situation. And that’s the reason why we need to find a way out of it. We have certain principles that we need to follow to be able to troubleshoot or debug our program.

Let’s say that your program encountered an error. So, what are the steps that you are going to take?

  1. Identify The Problem: Yes, it will be difficult. You will not be able to find it easily but the first step will always be to look for the problem. Check the program thoroughly and find the problem.
  2. Reproduce The Problem: This is a difficult step but a necessary one. Keep the root program unchanged and then, create a situation on a separate project where you reproduce the problem. It is in this project that you will apply the fix and work on to finalize a debugged program.

So, now, you have identified the problem as well as reproduced a situation where a problem is present. What do you do now? This is the time when you take the ‘Scientific approach’. What is the scientific approach?

  1. Developing a hypothesis: You have a problem in your hand but you are not quite sure about the solution. What do you do? Develop a hypothesis of your solution. You may have many solutions in your mind — but select the most appropriate. WRITE IT DOWN. Also, think of the hypothesis as a hypothesis — not a solution, not a diagnosis. It is a guess which can easily be wrong.
  2. Falsifying a hypothesis: This is what we mean by the scientific method. In science, when scientists come up with a hypothesis but they don’t try to prove that it is right. Rather, they try to prove that it is wrong — they try to negate/falsify it. If it is negated, the hypothesis undergoes changes, until a non-negated hypothesis is created. So, come up with your own hypothesis and do your best to negate it.
  3. Operating Hypothesis: Now, after you have applied all the different hypotheses, you are supposed to come up with a hypothesis that cannot be negated. This is a non-falsifiable hypothesis, your strongest one yet. Now, you can consider this hypothesis as a potential fix. Why is the word ‘potential’ being used here? Well, the fix is also a guess. It can go wrong easily and so, you cannot consider it as a diagnosis. Rather, you have to understand it as another hypothesis which stood the battery of tests and has passed to become properly tested as a fix. For now, this is your best guess — hence, your effective fix.
  4. Testing out the fix: Now, your hypothesis becomes a fix. This time, you come up with a new hypothesis: “My fix worked”. Go back to step one. Try to negate this hypothesis as well.
  5. Slow Down: As you can see that the debugging process can get quite complicated over time. So, don’t rush through it — it will only cause more problems and slow down the debugging process. Go slow and be careful — it will increase your chances of becoming correct.

So, apply these principles of debugging and you can easily minimize the errors in your program fast and most effectively. With that, you’re now on your way to debugging any problem that comes in your code. However, if you feel stuck or would need an expert to help you through, reach out to us at Coding Ninjas — we’ve got your back.