As mentioned in
my earlier blog, the software engineering skills we've learned assumes a green-field project where we starts on a clean sheet of paper. In this case, we can apply a number of practices to build a solid foundation for future evolution and maintenance.
- Test Driven Development will force you to document the external behavior of your system in terms of Unit Test
- Enforce a coding standard and use a tool to enforce that
- Make sure the code is regularly reviewed to ensure readability and modularity
In reality, less than 2% project are under this situation. Mostly likely, we are dealing with a piece of software that is not built on this foundation. In many cases, even the projects starts from a good foundation, it will deteriorate over time because of schedule pressure, lack of engineering skills, people turnover ... etc.
How can one support such a legacy system ? By support, I mean the following ...
- Fix bugs when it occurs
- Tune performance when loading increases
- Add features when new requirement arrives
In order to do the these things effectively, we need to first "understand" the legacy code and then "refactor" it. "
Understanding" is about how to quickly establish an insight of the inner workings of the legacy code without making any modifications that may accidentally change its external behavior and causes bugs. "
Refactoring" is about how to improve the understandability of legacy code by making modification to the code without changing its external behavior.
In later blogs, I will share my techniques of how to understand a piece of code written by someone else and also how to refactor it safely.
No comments:
Post a Comment