How do you evaluate code refactoring?

The most important metric in a refactoring should be working code and no regressions. Keep in mind you need to have a good test coverage to whatever part of the codebase you intend to refactor. I’d say that’s the number one requirement to start any refactoring work. If you’re missing the test coverage don’t even start, give a step back and fix your test coverage first.

Use code quality matrix to check internal code quality. check : code complexity matrix. (Inheritance levels, branching ) Duplicate code Class or method length limit.

Using checkstyle or linter can ensure that the coding and formatting patterns are standardized and improves readability. Integrating these into your CI/CD will ensure that this acts as a gatekeeper for your code getting pushed into your repositories.

Good set of metrics can give great insight on the code quality and a well refactored code will always have optimum metric values. It is also important to publish these metrics for everyones review; thats where tools like SonarQube can help. Once you know the areas for improvement, the next thing to do is to find the time for refactoring improvements. In general, your product manager wouldn't prioritise these improvements as the impact is not tangible :), so it is important for the developer to call out the importance of these and get the time for it. Fact is that refactoring is a continuous process, so make it part of every work the team picks up; if not, your code will starts to become complex and unable maintain and will die slowly.

If the reason for code refactoring is performance gains, performance metrics can be used to measure. If the reason for code refactoring is clean code or improve the reusability, metrics may not help alone, testing different uses cases may help

Unit tests are the best way to ensure that refactoring does not break anything. The unit tests should exist before any code refactoring begins. If there are no unit tests present prior to refactoring, by writing the tests, the author will be able to better understand the code he/she is refactoring and can structure the code in such a way that lends itself to more isolated tests, and higher quality tests in general. In addition, code coverage tools only check to see how much code is executed by the tests. They do not assess the usefulness or completeness of the tests. Just because a piece of code is executed does not mean it was tested with a high quality test.

If Refactor limited to class only then Write Unit Test before Refactoring. If Refactoring spread multiple classes & those interacted closely then write Integration Test before Refactoring.

It is also good to check if the code under tests follow the famous "test pyramid" model; a well maintained and refactored code is supposed to have their tests in decreasing order of percentage: unit tests > integration tests > end to end tests > manual tests

Any tests can help if they exist. If they don't, we can refactor right away after starting the regression cross-test with your team. It can help to check different cases without knowing particular details of the solution. As a result of cross-testing: 1. A solution will have been tested. 2. Mock data for future tests will have been found. There are two problems with this approach: 1. Time with untrusted code on test layers, which can be a problem if you need to send new code to production. 2. We need to come back and write tests with mocks. Eventually, this approach can work if you have at least a couple test layers and can afford to break them :D

To get feedback on the refactoring while doing it, prefer techniques like pair- and mob-programming over pull requests. This technique leads to a better code quality as the feedback time is drastically reduced and the feedback can therefore directly be considered as the code is written. When combined with trunk-based development and done in small steps, other team members benefit from the refactoring immediately.

Using feature branches to isolate the refactored changes gives the ability to be able to deploy in an integrated environment from the feature branch and execute smoke/regression tests. If things are broken rollback to the artifact from master.

In my opinion, benefits of having a refactored system You make a business case for refactoring by comparing the business bottom-line benefits between doing and not doing it. It means either reduction of current real costs, or an increase in future real cash inflow. Software quality impact on sales - if the current system is frequently causing customer-visible problems e.g. crashes or downtime despite adequate maintenance effort, then a rewrite can be a solution. IF this is a major issue, then the same sales people can quantify the value of a 'feature' called 'more stable product'.

Ensure Your Architecture's Design Principle Intact after refactoring or Add new feature code. Follow SOLID and basic clean code principles. Get it reviewed.

Never try to refactor everything at once, try with smaller chunks of code or micro modification and make sure to test your code after each refactoring to ensure that it still works as expected..

If you are owner of the codebase, always make the best use of feedback to improve or refactor your code. It is very much possible that you understand the code and is able to maintain it well because of your familiarity with the code for a longer time. So one easy way to take feedback is to ask the new joiner in your team, how easy it was for her/him to ramp up the code and the design by reading the docs, code, tests ... etc. If they find it difficult, it means there is scope for improvement.

In my experience user feedback is another valuable source of information for code refactoring. By gathering feedback from users, you can identify areas of the code that are causing problems or could be improved.

Some key points to consider while refactoring: - Start with small goals such as refactoring before a behavior change, refactoring a functionality, refactor if you are touching a section of code for an enhancement. - Add comments where needed while refactoring. Comments help improve readability but not too many comments. That leads to clutter. Strike a balance. - Empower your team to refactor code confidently with unit and integration tests. Performance tests, functional and regression tests integrated into your release pipeline will help with building confidence to refactor code without the fear of breaking functionality.

Instead of letting the code degrade and then have specific refactoring tasks, I would follow the boyscout rule ("Always leave the code you are working on a bit better than you found it"). As Martin Fowler explained in his book, refactor is a regular part of the programming activity. You should integrate it in your development process and keep improving your code in small steps that keep new features easy to add. Automated testing should keep you covered from breaking the existing codebase.

One thing that seems to have been forgotten in modern software development is... performance. Highly perforando code also leads to less CPU cycles amd less power consumption... something that seems to have been forgotten since all the new coners to development aren't taught assembler or C++. Something to think about.

For beginners I'd always recommend the "Clean Code" book by Robert C. Martin, he brings principles of refactoring and even how to detect bad smells on code that would require refactoring.