Common Mistakes Made by Developers While Redesigning

Change is constant… even in Software Design!

Most developers, the naive ones at least, skip straight to writing code when they are presented with a problem. The love of writing code or the eagerness to solve the problem takes over, perhaps a little too much.

A good design is something a developer should consider while solving problems. In fact, design is the solution that the developer codes.

“First, solve the problem. Then, write the code”

— John Johnson

Redesigning the software is an integral part of developers’ work. You need to rethink the relationship between the product and the user. Does it resonate with the users or not?

In one case, you might have to make changes to scale; otherwise, you need to make improvements.

I have made many mistakes myself and have seen others make mistakes while redesigning —

Trying to perfect the design

Once your design has failed, whether in solving the problem itself or scaling it, you want to solve the problem once and for all. This feeling takes you to the dreamland of perfectionism.

“Perfectionism is self-abuse of the highest order.”

— Anne Wilson Schaef

Designing a perfect solution is a fantasy that wastes your time and often leads to over-engineering.

Blindly following the trend

Trends in the software industry change faster than fashion. Developers fall for these trends even if they don’t go well with the problem.

I have seen small teams break down their monolith app into many microservices even when they did not have the means to manage all of them. New design patterns and architectures bring in new perspectives but forcefully fitting your unique scenario to these patterns only brings in trouble.

Going for a big change in one shot

Sometimes your code needs a complete overhaul. Even when your code is completely shitty, I don’t recommend changing it in one shot.

Developers love writing code and fixing design. The idea of overhauling your code might give a kick. But what you need to realize is this code is tested and it works. While developers will not like to accept, new code will introduce new bugs and will need a lot of time to fix.

The best way to do this is to gradually change the code towards an overhaul in an agile way.

Considering it to be a one-time activity

A design that is good today might not cater to tomorrow’s requirements. A good design is one that is flexible and can be changed when required.

Redesigning is not a one-time activity, it is a continuous process. I have tried to fix a design by speculating future scenarios that might not happen. I have tried to solve scale before it was required.

Don’t do that. Embrace the inevitability of change

Final Words

“The function of good software is to make the complex appear to be simple.” — Grady Booch

Having a simple design is one of the most important aspects of a good code. As I have gained experience I started to appreciate the design process and the advantages it brings in the later stages of the software development life cycle.

In this article, I have presented my views on the problems developers face while redesigning.

Also published here