What is Debugging?

Debugging is the process of finding and fixing errors or bugs in software source code. When software does not work as expected, computer programmers study the source code to determine why any errors occurred. They typically use code analysis tools to run the software in a controlled environment and analyze the code step by step.

The terms “bug” and “debugging” were common within the fields of engineering and aeronautics by the 1940s, as insects interfered with the operation of new technologies. However, Admiral Grace Hopper at Harvard University was first known to log a “bug” in computer science. In 1947, when one of her colleagues found a moth impeding the operation of one of the university's computers, Hopper and her colleagues recorded in a logbook that they had successfully found the bug. By the mid-1960s, the term debugging was well-known in the computer programming community in reference to finding the problem with a computer’s operation - whether an insect cause or a different cause.

Well-designed software code, built with the most sophisticated systems, and in the hands of the most experienced programmers can still experience errors.

Software development involves abstracting complex logic into human-readable code. Within this code, errors in logic, structure, syntax, or referencing can result in bugs, which cause unexpected software behavior.

The process of debugging helps to find these errors, which developers then fix. Debugging tools and strategies help improve developer productivity and support faster bug fixes. By identifying errors and resolving issues faster, both software quality and the user experience improve.

The debugging process typically involves several core steps:

1. Error identification

Developers, testers, and end-users report bugs they discover while testing or using the software.

2. Error isolation

Developers use tools to locate the exact line of code or the code module causing the bug. This can be time-consuming when performed manually.

3. Error analysis

When isolated, developers use debugging tools to analyze the error by inspecting the program's state at the moment of failure.

4. Fix and validation

Developers identify the issue to fix the bug and run tests to make sure that the software continues to work as expected. They will perform new tests to check if the bug recurs in the future.

Debugging vs. testing

Debugging and testing are complementary processes that share the common goal of making sure that software runs as intended. After writing a section of code, programmers will test it to identify bugs and errors. When they find a bug, they can begin the debugging process.

Bug prioritization

Developers prioritize bug fixes in their work queue based on the bug’s impact across factors such as software performance and user experience. The software team identifies a timeline for bug fixing depending on development goals and requirements. This is a management process for debugging across a project.

Software defects are a common byproduct of the complex software development process. Even after rigorous testing, bugs often emerge in production when users interact with the application in unforeseen ways. For example, in modern cloud applications, a single action might initiate processes in distributed databases, servers, and third-party APIs.

The debugging process typically focuses on resolving the following types of errors:

Syntax errors

The program may not compile or run if syntax errors are present. A syntax error is a bug that occurs when a computer program has an incorrectly typed statement. It is the equivalent of a typo in natural language. Code-editing software often includes inbuilt highlighting of these errors as developers write code.

Semantic errors

Semantic errors result in incorrect software behavior. Semantic errors occur due to incorrect meaning in programming statements. For example, if you are translating the expression x/(2 π) into Python, you might write: y = x / 2 * math.pi

However, this statement is not correct in the Python programming language because multiplication and division have the same precedence and are evaluated from left to right. Therefore, this expression evaluates to (xπ)/2, which likely causes a bug. To fix this semantic error example in Python, you must use parentheses to group the denominator: y = x / (2 * math.pi).

Logic errors

Logical errors result in incorrect software behavior. Logical errors occur when programmers misrepresent the stepwise process or flow within a software program. For example, the code can exit a loop too early or can have an incorrect if-then outcome. In this case, you could identify the logic errors in a debugging tool by stepping through the code for several different input/output scenarios.

Runtime errors

Runtime errors happen due to the code performing invalid operations, running out of memory, or having the wrong type. Runtime errors throw an exception or halt the software. You can handle runtime errors by surrounding statements in try-catch blocks, logging the exception, and then feeding the exception into the debugging process.

There are several strategies programmers use to minimize errors and reduce the time required for debugging.

Debugger stepping

Debugger stepping is a popular technique to debug code, particularly for small programs. Developers use backtracking, a debug mode where you step backward from the point of failure, line by line, to identify errors in the code. Unfortunately, the process can become more challenging to achieve as the number of code lines increases.

Incremental program development

Incremental development is a software engineering process in which developers write code in smaller increments, allowing them to test small portions of the code frequently. By doing this, programmers can localize bugs they find. It also allows them to work on one bug at a time rather than multiple bugs identified after writing large sections of code.

Instrumentation

Instead of manually watching program execution, developers will now often "instrument" their code to emit signals, or traces, logs, or metrics. This allows them to visualize the request path as it moves through the system.

Remote debugging

Remote debugging is the process of connecting a development tool with remote debugging features on your local system to an application running on a separate server, container, or cloud instance. This strategy helps fix environmental bugs, or issues that appear in production configurations that developers can't reproduce locally or in another test environment.

Logging

Most computer programs record internal data and other critical information in log files, such as their runtime and operating system state. Developers use log files to locate error messages that help them identify and fix bugs. They also use debugging tools such as log analyzers to automate log file processing.

Cloud debugging

Debugging complex cloud applications is challenging because developers have to emulate cloud architectures on local machines. Over time, configuration differences can arise between the cloud and emulated environments. This can cause more bugs in production and longer development cycles. Special debugging tools are required for more efficient cloud debugging.

Although these strategies work in theory, applying them to a massive cloud environment requires specialized, built-in debugging tools that can automatically handle billions of log lines and traces.

AWS supports coding and debugging efforts with several services for monitoring in production:

AWS Toolkit for Visual Studio Code is an open-source plug-in for the Visual Studio Code that makes it easier to create, debug, and deploy applications on Amazon Web Services. The toolkit provides an integrated experience for developing serverless applications, including assistance for getting started, ML-powered code recommendations, step-through debugging, and deploying from the IDE.

Amazon CodeGuru Profiler continuously monitors your applications in production. When it identifies opportunities to optimize application performance, it shows you what's causing the issue, how to resolve it, and where in the code it’s impacting your application. CodeGuru Profiler also estimates the cost of continuing to run inefficient code.

Application Observability (APM) allows you to prevent, optimize, and resolve application issues faster. Get one-click setup with automatic instrumentation across Amazon ECS, EKS, Lambda, EC2, and more—plus instant, automated insights from prebuilt dashboards that highlight your most critical telemetry.

With Application Signals you can:

• Investigate production issues using natural language directly in your Integrated Development Environment (IDE) such as Kiro or GitHub without switching tools or learning query languages
• Keep your customers happy by tracking service reliability using SLOs and SLIs
• Catch site problems before customers do by running synthetic monitoring (canaries) that simulate critical customer journeys in CloudWatch

Get started with debugging on AWS by creating a free AWS account today.