Home / Blog /
Code debugging: Definition, techniques, and automating with generative AI

Code debugging: Definition, techniques, and automating with generative AI

Tabnine Team /
6 minutes /
May 19, 2024

What is code debugging? 

Code debugging is a systematic process that involves identifying and removing errors or bugs in a computer program. These errors can be syntax issues, logical errors, or runtime errors, each of which can hinder the smooth functioning of a program. Debugging involves tracing the source of these errors and correcting them to ensure the software runs as intended.

The term “debugging” is attributed to Admiral Grace Hopper, a pioneering computer scientist in the mid-20th century. While working on the Harvard Mark II computer, a moth lodged in the machine caused an error, leading Hopper to coin the term ‘debugging’ to describe the process of finding and fixing the issue.

Debugging is not a one-time process but rather an ongoing activity that continues throughout the software development lifecycle. It involves not just the removal of errors but also the prevention of potential bugs, making it a critical aspect of creating robust and reliable software.

Code debugging vs. code testing 

While code debugging and code testing are both integral parts of the software development process, they serve different purposes and are carried out at different stages. Code testing is a proactive process that involves checking a program for potential errors before its deployment. In agile development teams, tests are typically written by developers and either executed manually or as part of continuous integration (CI) pipeline.

On the other hand, code debugging is a reactive process that comes into play after an error has been identified. Whether the bug was discovered during testing, post-deployment, or by an end-user, debugging involves delving into the code to trace the source of the issue and rectify it. While testing aims to prevent bugs, debugging deals with the ones that slip through the cracks.

Common code debugging techniques 

Print-based debugging

Print-based debugging, also known as “printf debugging,” is one of the simplest and most commonly used debugging techniques. It involves inserting print statements at various points in the code to output the values of certain variables or the flow of execution. These outputs can then be examined to trace the source of the error.

While this method may seem rudimentary compared to more sophisticated debugging tools, it is an effective way of gaining insights into the program’s behavior. Moreover, it is language-agnostic, making it a universally applicable technique. Another benefit is that this method can be used in a production environment, to provide insights of a problem after it occurred.


Breakpoints are a feature offered by many Integrated Development Environments (IDEs) and debuggers. They allow the programmer to pause the execution of the program at a specific point, enabling them to examine the state of the program, the values of variables, and the flow of execution.

This technique is particularly useful for debugging complex programs where the error might not be immediately apparent. By pausing the program at strategic points, the programmer can step through the code, examining each operation in detail to pinpoint the source of the bug.

Step-through debugging

Step-through debugging is a technique that involves executing the program one line at a time. This allows the programmer to closely observe the flow of execution and the changes in variable values, helping them identify any anomalies that could be causing the error.

Most IDEs and debuggers provide features for step-through debugging, such as “step into,” “step over,” and “step out.” These allow the programmer to control the execution flow, delve into function calls, and navigate through the code with precision.

Reverse debugging

Reverse debugging, also known as “backwards debugging” or “historical debugging,” is a technique that allows the programmer to step back in time to examine the state of the program at previous points in the execution. This can be useful for tracing non-deterministic bugs, which are difficult to reproduce and may not manifest every time the program is run.

While reverse debugging is a powerful tool, it is not commonly used due to the complexity and computational overhead involved. However, with advances in technology and the development of more efficient algorithms, it is becoming increasingly accessible.

Debugging in popular programming languages 

To understand the process of debugging better, let’s look at some examples in different programming environments.

VS Code debugging

Visual Studio Code, or VS Code, is a popular code editor that comes with built-in debugging support. It offers a range of features designed to make the debugging process easier and more efficient.

To debug a program in VS Code, you first need to set breakpoints in your code. Breakpoints are markers that tell the debugger to pause execution at a certain point. Once the program reaches a breakpoint, you can inspect the current state of the variables and the call stack, step through the code line by line, and evaluate expressions on the fly.

The debugging functionality in VS Code is extensible, meaning that you can add support for different programming languages and debugging protocols via extensions.

C code debugging

Debugging in C can be challenging due to the language’s low-level nature. Fortunately, there are tools like GDB (GNU Debugger) that can help.

GDB allows you to set breakpoints, step through the code, and inspect the state of your program. It also supports conditional breakpoints, which only pause execution if a certain condition is met, and watchpoints, which trigger a pause whenever a specific variable changes.

One thing to keep in mind when debugging C code is the potential for memory-related bugs. These can be particularly tricky to track down, but tools like Valgrind can help by detecting memory leaks and other memory-related issues.

Learn more in our detailed guide to C code debugging 

Java code debugging

Debugging in Java can be done using various tools, but one of the most commonly used is the Java Debugger (JDB). JDB is a command-line tool that allows you to set breakpoints, step through the code, and inspect the state of your program.

However, many Java developers prefer to use integrated development environments (IDEs) like Eclipse or IntelliJ IDEA for debugging. These IDEs offer a more user-friendly interface for debugging and come with additional features like the ability to evaluate expressions on the fly, view the call stack, and navigate to the source of an exception.

Another useful tool for Java debugging is JUnit, a framework for writing and running tests. By writing tests for different parts of your code, you can quickly identify and fix bugs.

Python code debugging

Python offers several tools for debugging, one of which is the built-in pdb module. pdb provides an interactive debugging environment where you can set breakpoints, step through the code, and inspect variables.

For a more user-friendly debugging experience, many Python developers use IDEs like PyCharm or Visual Studio Code. These IDEs provide a graphical interface for debugging, with features like conditional breakpoints, call stack inspection, and expression evaluation.

Another useful tool for Python debugging is the pytest framework. By writing tests for your code, you can quickly identify bugs and verify that your fixes have resolved them.

Learn more in our detailed guide to Python code debugging

Fully automating debugging with Tabnine and generative AI

For most developers, the process for fixing errors in your code starts with an IDE plug-in that notifies them there are errors in the code. Some of these tools provide recommendations that can help with simple errors. 

However, for complex debugging, developers will have to manually investigate the error. This might require getting feedback from other developers or searching online for similar issues, based on the limited information provided from the debugging tool. Traditional debugging tools today don’t tell developers how to resolve the error, and the help they provide isn’t personalized to their specific problem. This makes it difficult and time-consuming to solve programming errors. 

Tabnine’s AI coding assistant makes debugging code errors much easier. As tools identify errors with the code and error notifications emerge in the problems tab, or inline using colored indicators, developers can simply click on the error indicator and ask the Tabnine coding assistant to suggest a fix.

In this demo video, you can see how Tabnine fixes an error identified in the IDE. It shows a React App written in TypeScript, where the IDE indicates coding errors, denoted by red underlines. The developer highlights line 26 and uses the /fix-code command in the chat.

Based on the response, you can see that the problem lies the usage of a process instead of a window. Tabnine can directly apply that change, resolving the error and saving valuable time, without leaving the IDE to search Google for solutions.

With an AI coding assistant like Tabnine, developers see massive efficiency gains by fixing errors almost instantly—instead of taking an hour to fix a complex issue, Tabnine can fix it in seconds. This improves productivity and increases developer velocity. 

Try Tabnine for free today or contact us to learn how we can help accelerate your software development.

Tabnine: The AI coding assistant that you control

Tabnine is the AI coding assistant that helps development teams of every size use AI to accelerate and simplify the software development process without sacrificing privacy, security, or compliance. Tabnine boosts engineering velocity, code quality, and developer happiness by automating the coding workflow through AI tools customized to your team. Tabnine supports more than one million developers across companies in every industry. 

Unlike generic coding assistants, Tabnine is the AI that you control:

It’s private. You choose where and how to deploy Tabnine (SaaS, VPC, or on-premises) to maximize control over your intellectual property. Rest easy knowing that Tabnine never stores or shares your company’s code.  

It’s personalized. Tabnine delivers an optimized experience for each development team. It’s context-aware and delivers precise and personalized recommendations for code generation, code explanations, guidance, and for test and documentation generation.

It’s protected. Tabnine is built with enterprise-grade security and compliance at its core. It’s trained exclusively on open source code with permissive licenses, ensuring that customers are never exposed to legal liability.

Tabnine provides accurate and personalized code completions for code snippets, whole lines, and full functions. Tabnine Chat in the IDE allows developers to communicate with a chat agent in natural language and get assistance with various coding tasks, such as: 

  • Generating new code 
  • Generating unit tests 
  • Getting the most relevant answer to your code
  • Mentioning and referencing code from your workspace
  • Explaining code
  • Extending code with new functionality
  • Refactoring code
  • Documenting code
  • Onboarding faster with the Onboarding Agent