My Silent Addiction in Software Development

Photo by Dagmara Dombrovska on Unsplash

They say that the first step in solving a problem is admitting you have one, and I think I’ve got one. I’m one of many software engineers who do have a problem, but it’s almost never spoken about. It isn’t drugs, alcohol or cigarettes.

The problem? The job is about solving problems, and that can be addictive when taken to the extreme. Let me explain.

Just One More

When I’ve got a problem to solve, I keep thinking “just one more”. Like other people say “one more episode” when watching Netflix I’m all for solving the next bug.

So, one time I had a couple of copy changes to solve and then needed to look into a bug. They assigned the tickets to me at around 15:00, and I thought I’d make a start on the first ticket. Didn’t take an hour (including getting a coffee), so thought I’d start on the second. I can’t leave a ticket “in progress” overnight if it’s as trivial and changing a string or two. I complete the second ticket and start on the bug. I just…keep…going. I want to solve the problem and get it in the bag and kept going late into the night. The only problem is these three tickets represented my entire planned work for the sprint. It didn’t make any sense to keep working late, but that’s where we are.

I have a misplaced work ethic, and I think it’s starting to affect my health as I often work late to “get things done” even though nobody is pushing me to do so. I’m my own worst enemy.

Breaking Down The Issues

As ever with software development the issues are many. Addiction, poor estimating and assumptions are to blame.

Addiction

Many software developers are conscientious types, and that means that they like to get their work complete (no matter how many hours they have been working).

The “just one more” feeling of squashing bugs can therefore get the better of us. If we can just do a little more on any given day the team will benefit, we will benefit and perhaps everyone will be that little happier. If only it were true.

Poor Estimating

Bugs are like roaches. Fixing one shows two or three more hiding under the floorboards of your codebase, and they never seem to end.

When we think that we can solve a bug tonite, we often discount the fact that the blighters often hunt in packs. If you overpromise to get a bug fixed and it turns out to be bigger than you ever thought you’re setting yourself up for either failure or a late night at the keyboard.

Assumptions

We assume we can beat the bugs, but sometimes legacy spaghetti code can get in the way of our making progress or perhaps even solving the bug.

We assume we can do more than might be possible, and this is seemingly a constant for those who make software.

I’ll tell you what I mean. The default setting for this meme and the developer community as a whole still seems to be that developers are male. The “he” as a default software developer is as dated as VGA. Sure, men still dominate but they’re not as common as the bugs in the legacy codebase I work on.

Conclusion

The silent addiction to problem-solving in software development is a double-edged sword. It can make us good at what we do, but unfortunately it can also keep us at the keyboard long after we should have walked away, leaving us burned out and questioning our work-life balance.

We need to remember that there will always be another bug, another ticket, another challenge. But if we’re not careful, the biggest challenge we’ll face is maintaining our own health and happiness while we chase the next fix.

So, next time you find yourself reaching for “just one more,” ask yourself if it’s really worth it. Sometimes giving yourself a night’s rest and looking at a problem tomorrow makes a hard challenge that much easier.

The real secret to being a great developer isn’t in how many bugs you squash today. It’s in knowing when to log off and live your life.