Subsection 1.1.1: Classifying Bugs

Bugs can be categorized based on two axes: the method of writing and logic, and the distinction between the intended code and the actual code produced.

• Silly Mistakes: These are minor errors such as typos in variable names. Such bugs are often elusive and may go unnoticed, even upon careful review of the code. It’s vital to scrutinize error messages, as they can point to these trivial mistakes.
• Writing Mistakes: These occur when the initial intentions are miscommunicated in code due to misunderstandings or lack of knowledge. For instance, a programmer might misorder variables or misinterpret JavaScript behavior. This type of error is challenging to spot without further research or study.
• Logic Implementation Errors: This type of bug arises when the intended logic is not properly translated into the code. These errors usually do not generate immediate error messages, making them difficult to identify through mere observation.
• Logic Design Errors: Here, the underlying logic is fundamentally flawed from the outset. Similar to logic implementation errors, these bugs typically do not trigger errors, and identifying them may require a detailed review of the logic involved.

Summary

In debugging, it's essential to assess both your understanding of the code and whether that understanding is accurately reflected in your implementation. When confronted with a bug, it’s crucial to identify its type, as this will guide your debugging strategy.

Relying solely on code inspection or searches can often be unproductive. Bugs resulting from misunderstandings may remain hidden, and simple mistakes are frequently overlooked.

An Efficient Approach to Debugging

With a grasp of bug classifications and common pitfalls in debugging, let's explore effective debugging techniques.

First, observe how your code behaves. A bug arises from a disparity between your expectations and the actual behavior of the code. Instead of just reading the code, execute it and verify its functionality.

The initial step in observing behavior should involve examining error messages. Errors indicate where the code has failed and can provide critical insights into the nature of the bug. Approximately 80% of bugs can be resolved by understanding error messages correctly, as many errors stem from simple oversights.

If an error message is unclear, consider employing print statements to debug. This technique allows you to inspect the values of variables at specific points in the code, helping you confirm whether the code behaves as anticipated.

For instance, if you encounter an error regarding a variable's unusual value, printing the variable's value can clarify whether it's truly erroneous.

Numerous tools and methods exist to enhance print debugging, so explore them to find what works best for you.

The key is to prioritize action over passive reading—by executing the code, you can confront its actual behavior rather than being constrained by your assumptions.

Next, articulate the expected behavior of your code. Formulate assumptions such as "this variable should hold this value at this point" or "this function should execute at this time." By verbalizing these assumptions, you can more effectively monitor your code's behavior.

For example, if you print both the expected and actual values simultaneously, it becomes evident when discrepancies arise. Additionally, utilizing assertions can help catch logical errors before they escalate.

Finally, understand that it’s perfectly acceptable if your code isn’t flawless. Debugging can be mentally taxing, especially when your hard work yields unexpected results.

Moreover, the isolation that comes from remote work can heighten feelings of frustration, particularly when you lack the insight that comes from observing experienced programmers tackle debugging challenges.

Even seasoned developers sometimes spend extended periods simply scrutinizing their code in exasperation. Remember, it's not essential to achieve perfection on the first attempt. When faced with a bug, consider the strategies you've learned, such as print debugging or articulating your assumptions.

Video: 80% of Programmers are UNHAPPY...Why is that?

This video explores the underlying issues contributing to the widespread unhappiness among programmers, offering insights into common frustrations in the industry.

You can find more information at PlainEnglish.io. Don’t forget to subscribe to our weekly newsletter for updates, and follow us on Twitter, LinkedIn, YouTube, and Discord. If you're interested in scaling your software startup, check out Circuit.