Developers are forced to constantly make decisions about what to do with the problematic code: rewrite it entirely, partially redo it, or ignore the flaws. There are many recommendations for resolving this issue in case of small flaws, but when it comes to a large project, the decision is more difficult. What factors should be considered here?
Refactoring existing code in the hope of successful integration is less risky than rewriting everything from scratch. In what cases is it still worth considering the second option? Rebuilding is a big and risky project, but sometimes it is cheaper because it can take more time to make many small changes. The conditions under which to consider re-creating are as follows:
- You cannot add something new without rewriting the old one.
- It is very difficult to introduce new people to the project, it takes more than two months.
- It is not possible to configure Continuous Integration or deployment.
- Simple bug fixes take a very long time.
- The platform the app is running on is no longer supported.
- An increase in the number of users is expected, which the old system will not withstand.
- The interface is outdated, and you are rewriting it to be more modern.
- When you have studied the project thoroughly and know every detail of it;
- When the implementation of improvements takes an extremely long time and / or a lot of money due to the excessive complexity of the system.
In all these cases, it will be easier if the system can be divided into components since then you can choose between ignoring, refactoring, and rewriting each of them. Among other things, it was for this very opportunity that microservices architecture was proposed. The practice of splitting the system and rewriting piece by piece is safer, but it’s still a series of mini-projects to build code from scratch.
If you chose to rewrite the code base of the project, we highly recommend you to find for these purposes reliable and trustworthy supplier of software development services.