Two captivating figures often emerge in software development: the Stubborn Stumper and the Strategic Solver. Picture the Stubborn Stumper, a seasoned developer with grit in his eyes, fervently hammering at the keyboard as if it were an anvil, relentlessly seeking the elusive solution. We’ll call him Benjamin.

“There’s honor in grinding and a sense of achievement in a solution hard-earned,” Benjamin would argue, his belief echoing in the cathedral of code he’s built.

Now, meet the Strategic Solver, the composed Sherlock of software, armed with an arsenal of tried-and-true methods. She embodies wisdom — collecting, cataloging, and deploying strategies with surgical precision. We’ll call her Laura.

“Elegance lies in efficiency and the well-timed use of the right tool,” she’d whisper as she conjures up the perfect piece of code, as if from thin air.

So, who’s right? Or better yet, is there even a ‘right’ way when problem-solving in software development?

1. A Bug on the Horizon: The Different Approaches — Benjamin and Laura were software developers at Phoenix Technologies, a growing tech startup. Then came the day a nasty bug slipped into their codebase, causing random crashes in their software. Benjamin and Laura were assigned to tackle this problem together, their contrasting strategies about to be put to the test.
2. Benjamin’s Battle: The Cost of Stubbornness — Benjamin jumped into the fray, his mind brimming with ideas. For him, it was a test of stamina and resilience. But despite his best efforts, the solution eluded him. Yet he soldiered on, becoming more frustrated with each passing hour.
3. Laura’s Strategy: Wisdom Through Proven Techniques — Meanwhile, Laura took a different approach. She recognized that this was a complex problem that could not be solved simply by brute force. She decided to employ various problem-solving techniques documented by others.
4. A Duck, Divide and Conquer, and Logging: Laura’s Arsenal — First, Laura tried the ‘Rubber Duck Debugging’ technique. When that didn’t fully solve the problem, she switched to the ‘Divide and Conquer’ strategy. Days passed, and Laura slowly led her toward the bug using another method called ‘Trace Logging.’
5. The Reveal: Triumph of the Strategic Solver — Finally, Laura pinpointed the bug. It was a memory management issue, a tough one to crack, hidden deep within the code. But Laura’s systematic approach and the strategic application of different troubleshooting methods had paid off.
6. Lessons Learned: The Power of Strategic Problem-Solving — When Laura finally shared her solution, a weary and slightly embarrassed Benjamin conceded that his stubborn approach hadn’t been enough. He recognized the power of strategic problem-solving and, for the first time, acknowledged that he had a lot to learn from Laura’s methodical approach.

Troubleshooting Techniques Employed by Laura

Rubber duck debugging

This method involves explaining your problem to an inanimate object, like a rubber duck. It’s surprising how often this can lead to insights and solutions. Verbalizing your problem can make it more apparent, leading to an ‘aha’ moment.

The Rubber Duck method is based on the principles of cognitive psychology. Explaining a problem out loud helps activate different parts of the brain and can lead to new insights and solutions. Additionally, breaking down a problem into smaller parts and explaining it step-by-step can help uncover hidden issues and identify potential solutions.

Divide and conquer

This strategy is about breaking down the codebase or the problem into smaller pieces and isolating the source of the error. This systematic approach can help navigate complex issues and identify where the problem lies.

While the strategy has roots in algorithms, it has a nice application in the troubleshooting toolkit. Dealing with smaller subproblems can help identify the root cause of the problem more quickly and accurately. It also helps us avoid getting stuck in a particular line of thinking, which can lead to a dead end in problem-solving.

From a psychological perspective, the Divide and Conquer approach helps manage cognitive overload, a common problem in complex problem-solving. By breaking down a problem into smaller subproblems, we can focus on one specific aspect of the problem at a time, reducing the cognitive load and improving problem-solving efficiency.

Divide and Conquer works on a few levels by breaking down a complex problem into smaller, more manageable subproblems where we can improve problem-solving efficiency and accuracy and avoid getting stuck in a particular line of thinking, all while managing cognitive overload.

Trace logging

This technique involves adding logging statements in the code to track the program’s execution flow. By reviewing these logs, you can understand how the application behaves at specific times and where things are going wrong. It’s beneficial for identifying elusive bugs that are difficult to reproduce.

Trace logging can be implemented in various ways, depending on the programming language and platform used. Some languages and platforms provide built-in support for trace logging, while others require some code. This can be done with little debug messages like, “got here.”

However, it is important to note that trace logging can also generate a large amount of data, which can be difficult to analyze and interpret. We must use this method deliberately and focus on the most relevant areas to avoid getting bogged down in irrelevant details — and remove the logs when no longer necessary.

Embracing Strategy Over Stubbornness

In our industry, problems are inevitable. Bugs, crashes, and unexplained behaviors are all part and parcel of a developer’s life. But as Benjamin and Laura have demonstrated, how we tackle these problems can drastically affect our productivity, stress levels, and even our sense of job satisfaction.

Benjamin’s relentless, headstrong approach may have a heroic ring to it, but the quiet, strategic wisdom of developers like Laura often carries the day. By stepping back from the problem’s immediacy, evaluating the situation, and applying targeted troubleshooting techniques, we can transform problems from daunting obstacles into minor challenges.

Ultimately, the most effective problem solvers are willing to learn from others, leverage proven strategies, and adapt their approach based on the task. Stubbornness may win battles, but strategy wins wars.

When the inevitable tricky bug or complex feature next comes your way, think of Laura with her rubber duck, her divide-and-conquer strategy, and her meticulous logging. Embrace the art of strategic problem solving, and turn your coding challenges into opportunities for growth and learning.

As the ancient proverb says, “Give me six hours to chop down a tree and I will spend the first four sharpening the axe.”

Stubborn vs. Strategic: Navigating Problem Solving in Software Development was originally published in Better Programming on Medium, where people are continuing the conversation by highlighting and responding to this story.