Debugging for Beginners: Finding Bugs in Your Code

April 24th, 2012 Leave a comment
Like the article?

One of the most challenging things for a new developer to learn is how to debug their code. It seems that sometimes, problems can seem impossible to find or fix. For new developers, this process can be overwhelming and lead to needless frustration. In this article, I will talk about problem-solving as well as the art of debugging so that you can become more familiar with the practice of finding bugs in your code and fixing problems.

When new developers are first learning how to code, it is not uncommon for them to stumble upon an error that leaves them completely befuddled and without working code. Instead of just crying “my code doesn’t work!” developers must begin to dissect the problem and find the proper approach to fixing it. There is (or should be) a methodical set of steps to debugging instead of just making random changes hoping you’ll hit upon the solution. To provide a straightforward approach to debugging, you should focus on the following key elements:


Often a bug is found and reported without a clear way of reproducing the error. Being able to recreate the circumstances that cause a bug is the first step towards finding its location in your code. A bug that appears through a precise set of steps is easy to solve, where a bug that seems random or intermittent can be harder to track down. Though the process of cause and effect deduction, you are most likely going to be able to find and fix a bug easily if you can reproduce it.


Reduction is the process through which you reduce a problem to its essence. What is the smallest path to the bug? The simpler the path, the easier it can be to track it down. If you have a large amount of data it can provide a big blockade to tracking down a problem, therefore you may need to cut the file in half as you narrow down the problem, throwing the other half out until you determine if the problem exists in this set or not. If not, begin working on the other data set until the problem can be found.


Using deduction we can find the general path through the program, the components that the data interacts with on our way to the problem area. Is the data getting damaged on its way to the component where the failure occurs? What is the difference between data that doesn’t work and data that does? You want to narrow down the field of possibilities by forming and eliminating hypotheses.


Just like how scientists create experiments to try to prove a hypothesis, you will need to experiment with your data and input to see if your bug disappears. Using your logic skills and powers of deductive reasoning you can create a set of theories about the possible problem and set up experiments to test those theories. If you are correct, then your changes will most likely tell you where the problem is.


There is no substitute to experience; it’s not something you can get in a classroom. To become a better programming you must write code, make mistakes and learn how to fix those mistakes. Experience can help in debugging because you will grow in your ability to execute the previous four elements and you may have seen this particular problem before in another program and will know how to fix it. You also learn more about how different systems work and can lend that experience to this particular problem you are on now. When in doubt, borrow experience from another programmer for the same reasons as above. Getting a different perspective on the problem can also help lead you to the problem area.


Programmers are going to make mistakes, especially new ones. You must begin with the attitude that you will mess up and that you will be able to fix the problems that you have created. Do not give up no matter how long it takes to find the problem and correct it. Each time you solve a problem you will become more confident in your programming skills and you will become a much better programmer from the experience you gained fixing those bugs.

These elements are not in any particular order and you may use some or all in fixing each problem with your code. One thing to remember is that once you have found and fixed the bug that is not the end of the learning experience. You should also understand why the bug was occurring and how your solution has fixed it. The key to learning is to understand and only by understanding what we are doing in our code will we be able to use this experience in the future. This is especially true if we found a solution online that works, but we don’t truly know what it is doing.

In the end, debugging can be one of the most difficult and frustrating parts of programming. How you approach problems and your attitude will make a big difference. Most programmers approach problems as a challenge that must be overcome and they enjoy the interesting aspects of research and problem solving. This way, they can attack problem with confidence, knowing they will eventually solve it. A good programmer can distinguish themselves by learning to take the right attitude and become a tenacious problem solver. I hope this has helped provide you with a strategy to follow that will increase your confidence as you find and correct your bugs.

Help us spread the word!
  • Twitter
  • Facebook
  • LinkedIn
  • Pinterest
  • Delicious
  • DZone
  • Reddit
  • Sphinn
  • StumbleUpon
  • Google Plus
  • RSS
  • Email
  • Print
Don't miss another post! Receive updates via email!