In software development (and in life) it pays to be thorough. Being thorough means that you care about doing things right. It means that you understand your actions and the rational behind them as opposed to fighting your way through a problem. The thorough programmer knows why they are approaching the problem in the way they are approaching it.

Thorough developers:

• Care about getting things right
• Understand their actions and the rationale behind them
• Realise taking action just to get the product out the door is extremely shortsighted

How sloppiness sets you up for failure

In contrast, developers who are sloppy set themselves up for headaches throughout the entire development lifecycle. Fighting their way through task after task, in the end they don’t understand what they’ve built or how it works. They just know it somehow does the task that they’ve set out to achieve.

Herein lies the problem, the moment the requirements change or a new feature is required the sloppy developer is in trouble. The system or product they’ve built is fragile and doesn’t accept change well. Because the developer has not been thorough the product is extremely likely to have bugs and constantly fall over, which leads to a bad experience and diminishing value for the end user.

Productivity is also affected, nobody wants to work on a codebase that had been built by the developer described above, including the developer who initially wrote it! This leads teams and individuals alike to procrastinate whenever they should be working on the system, constantly finding reason to put it off and work on something else.

The sloppy developers’ life is more stressful because they don’t understand what they’ve built or how the product works resulting in constantly having to ‘put out fires’ and rework.

Where being thorough matters and where it doesn’t

Being thorough in programming and in life always matters with very few exceptions. Yes, when you are learning something new you may find yourself hacking your way through the problem to gain the base understanding. But you must make sure you don’t stop at a base understanding, you need to revisit what you are learning until you fully understand it.

For example, let’s say you are deciding whether to use a new library or not. you need a basic understanding of the library and generally gain that understanding by playing around with the library. This helps you make a decision about whether you would like to use the library going forward but the moment you decide you would like to use the library the rules of thoroughness apply.

How to be thorough

If you are hacking together your product through a series of Stack Overflow answers and constant frantic googling sessions you’re taking the wrong approach, so how do you break this habit?

Practice awareness

Every time you find yourself going down a developer rabbit hole you need to catch yourself and realise what is happening, then stop yourself! It is time to step back from the code and assess the situation.

Question your understanding

Constantly ask yourself “Do I understand what I’m doing and why I’m doing it?” Take the time to explore, focus on what it is that you don’t understand. Is the lack of understanding purely related to the problem at hand or is there some deeper issue that needs resolving?

One you’ve taken the time to understand what you don’t understand you then need to take the time to unpick the problem, learn the subject you know you need to learn and when you are confident you know what you’re doing and why return to the task at hand.

After you’ve finished working through a problem and have reached a solution ask yourself if you truly understand how the software you’ve built works. You need to be confident in the decisions and understand why you made those decisions.

Don’t lie to yourself

We’ve all been in a situation at one point or another where we tell ourselves that the code we’ve written doesn’t really matter or worse we know the code matters but we tell ourselves we will come back and rewrite the code later. You and I both know that more often than not ‘later’ never comes so it’s best to stop lying to yourself and fix the issue now rather than putting it off.

Practice patience

The difficulty in being thorough is an issue of patience (or the lack of it). You need to learn to be patient and trust the process. I know you want to “just get it done” but resist the urge your future self will thank you.

Rush now, regret later

Every time I rush something I regret it later. After returning to a codebase after months away I could literally kill my past self, be nice to your future self and do the job right to the bed of your ability. Taking a thorough approach not only helps you with your current problem but also has the benefit of making you a better developer.

Take some time to think about it, think about a time when you took the time to learn something properly, did you find that it helped you in more ways than one? I bet it did.

The thorough developer is the fast developer. The thorough developer is also a less stressed developer. Everyone has a choice between being sloppy and being thorough, which developer are you?