The Debugging Skills No School Taught You
Do it like a pro!
Not a medium member? Read it here.
Debugging is a skill every software developer eventually masters—not because we’re taught it in school, but because we’re forced to🤯. No textbook will fully prepare you for the hair-pulling frustration of chasing down a bug in a complex project.
I believe, debugging is as much art as it is science, and over time, we develop techniques to untangle the mess.
Let’s see some of the best approaches to debugging like a pro!
1. Start with the Obvious
It sounds trivial, but the first step in debugging is to ask, "Is it plugged in?" Always initially check the most straightforward causes of the issue, like:
- Is the environment properly set up?
- Are the dependencies installed?
- Is the configuration correct?
- Is there a typo or a missing semicolon?
We’ve all spent hours debugging only to realize we were using the wrong API key or forgot to save a file.
So start with double-checking the basics.
2. Reproduce the Bug
Bugs are easiest to fix when they’re consistent. If you can make the bug happen repeatedly, you’re halfway to solving it. Take note of:
- The inputs are causing the issue.
- The sequence of steps leading up to the error.
- Any environmental factors (OS, browser, version, etc.).
If the bug is difficult to reproduce, try logging extensively (we’ll come back to this later).
Reproducibility is key to understanding the root cause.
3. Break It Down
If a system is failing, isolate components one by one:
- Start by commenting out or disabling parts of the code to see which section causes the issue.
- Replace complex functions with simpler versions that mimic their output.
- Use binary search debugging: disable half the code and check if the bug persists, narrowing down the scope iteratively.
It’s like solving a puzzle—remove unnecessary pieces to focus on the problem.
4. Use Logs Like a Pro
Logs are your best friend. Strategic logging gives you visibility into what’s happening under the hood.
- Log everything at first: the inputs, the outputs, intermediate variables, and the execution path.
- Use log levels (DEBUG, INFO, WARN, ERROR) to categorize messages.
- Add unique identifiers to track requests in multi-threaded or asynchronous systems.
Tools like Logstash, Elasticsearch, or cloud monitoring systems (e.g., AWS CloudWatch) make searching logs much easier when dealing with distributed applications.
Pro tip: Make logs meaningful. Writing console.log("here") isn’t helpful. Instead, include variable values and context: console.log("User ID:", userId, "Function: fetchUserDetails").
5. Leverage Debugging Tools
IDE debuggers are criminally underutilized. They allow you to pause execution, step through code, and inspect variables in real time. Here’s how to make the most of them:
- Breakpoints: Set conditional breakpoints to stop execution only when specific conditions are met.
- Watch Expressions: Monitor changes to specific variables as you step through the code.
- Stack Traces: Use them to identify where and why the error occurred.
For web apps, tools like Chrome DevTools or Firefox Debugger are invaluable for inspecting DOM elements, monitoring network requests, and stepping through JavaScript code.
6. Rubber Duck Debugging
In software engineering, rubber duck debugging (or rubber ducking) is a method of debugging code by articulating a problem in spoken or written natural language. — Wikipedia
Yes, talking to a rubber duck (or a teammate) works. Explaining your code out loud forces you to articulate your assumptions and often reveals the flaws in your logic.
Start with, “Here’s what this part of the code is supposed to do...”
As you talk, you will understand the gaps or inconsistencies that often surface.
If no one is around, seriously, use an actual rubber duck or write a detailed note explaining the bug to yourself.
7. Check the Error Message (Don’t Ignore It)
How often do we skim and ignore the big error messages, assuming they’re incomprehensible?
- Read it thoroughly: Error messages often include stack traces, line numbers, and hints about what went wrong.
- Search for clues: Paste the error message into Google, GitHub, or Stack Overflow. Someone else has likely encountered it.
- Look beyond the surface: Sometimes, the reported error is a symptom of a deeper issue. Trace it back to its source.
8. Test Hypotheses
Debugging is like scientific research and unit testing is your best research buddy. Pick a unit test framework that suits your project and write the possible use cases and hypotheses to find the root cause of the bug.
- Form a hypothesis like: "I think the bug occurs because variable x is null."
- Test it: Add logs, assertions, or temporary code to confirm.
- Iterate: If you’re wrong, revise your hypothesis.
Be methodical, not random. Jumping between fixes without a plan wastes time and creates more chaos.
9. Mind the Environment
Bugs often aren’t in the code but in the environment:
- Version mismatches: Ensure libraries, frameworks, and tools are consistent.
- Configuration issues: Check .env files, config settings, and secrets.
- Deployment quirks: Local builds might work, but staging or production fails.
Docker or virtual environments can help you isolate environmental differences.
Docker uses containerization to create isolated environments for running applications, ensuring consistency across different systems. Virtual environments can be used to isolate dependencies for specific projects, preventing conflicts between them.
10. Seek a Fresh Perspective
When you’ve been staring at a problem for hours, it’s time to step away or bring in a fresh pair of eyes.
- Take a break. Sleep on it. Ideas often come when you’re not actively thinking about the bug.
- Do pair programming with a colleague. Explaining the issue to them might reveal the solution.
At the end of the day, debugging is where we grow as engineers. It sharpens our problem-solving skills, deepens our understanding of systems, and often humbles us. Schools may not teach debugging, but experience sure does. Let’s keep learning from the bugs we battle every day.
Thank you so much for reading! Until we meet again, continue to learn, code, and continue to shine!✨
👏 If you found value in this article, don’t forget to give it a clap, Follow and leave a comment! 👏
I’d love to hear what you think! Your feedback helps me improve. ❤
It means a lot to me and helps others discover helpful content too! 💡
