Java Programmer Code Refactoring needs to be gradual

There are many ways to refactor code. Many people think that refactoring code should be put in the backlog. But in fact, this is not an ideal method.

　　

At the beginning of the project, your code is clean.

　　

Even if there is a need for a small detour, but this time we can easily and smoothly add functionality. This stage is generally not a problem, and because we are more anxious, so even if there are some small problems, we will not notice.

　　

However, as the project grows longer, these small problems accumulate. This is what people call "technical debt." Its essence, is not particularly good code, but this time the problem has not been fully revealed.

　　

But as we continue to add new features, these problems will gradually emerge, and we have to be careful to circumvent them.

　　

Inevitably, our development speed will be slowed down. But in order to pursue speed, we began to become more and more careless, soon after, the problem will be more and more.

　　

These problems will accumulate like bricks and layers, making our development slower. Although we are finally aware of the problem, there is no time to solve it completely. We can only continue to carefully bypass them.

　　

Soon, we will find that more than half of the code is in line with the small problems that are affecting our development speed at all times. Until one day, you find yourself unable to continue to bypass them.

　　

Have to do something about it. We have to do a complex code refactoring, and let's Get clean code back. You have to apply time to the supervisor to refactor the code. In fact, this way of working is not good, we take the time to fill in the hole we dug before. And sometimes, the company doesn't have time to refactor your code.

　　

Even if the company gives you time, it's hard to refactor the code very well. You know, the time it takes to refactor code is much higher than you expect. If these messy codes are written in 10 weeks, it's hard to refactor them for another 10 weeks.

This shows that the way the code refactoring is not good. So what should we do?

　　

It is simple, that is, every encounter with a problem, immediately solve it, rather than choose to bypass it. Improve the code that you are currently using, and ignore the problems that you have not yet encountered. On the road ahead, clear all obstacles, and you will surely go this way again, and next time you come here, you will find that there are no obstacles on the way. This is how software is developed.

Maybe it will take you a little more time to solve this problem. But in the long run, it will help you save more time.

　　

When adding new features, we will first clean up the code needed for this feature. Take a moment to gradually clean up the code in a hollows way, and as time goes by, our code will become cleaner and faster to develop.

　　

After a while, you'll find that all the technical debts are gone and all the pits are filled. The benefits of this progressive code refactoring are beginning to manifest and the speed of programming is significantly faster

This is the correct way to open code refactoring!

If there are different views welcome message, this article is only the author's personal point of view, the author of the trouble to identify the author's support, Welcome to pay attention to the author, the author will continue to update.

Java programmer Code Refactoring needs to be gradual