How Code Review Reveals Software Evolvability Issues
Code reviews aren't just a huge part of the software development life cycle, they're also an essential process for any respectable software company. Information system managers need to have the power to predict and plan the long-term evolution of their systems on an objective, quantified basis. This is a pretty difficult task, especially when a system is deeply embedded in an organization’s business processes. Simply put, managing software evolution and estimating the extent of future projects takes a lot of work!
Probably the most popular justification for spending time on code review is to increase code quality. New features and enhancements can cause downstream issues in maintainability and performance if not properly integrated (and if they aren't, can they really be called "enhancements"?).
Code reviews can reveal issues related to the inner quality (evolvability) of software because reviews find defects in the system whether they're visible to the user or not. Since evolvability defects are not visible to the customer, some people believe that they can't cause a system failure. In reality, evolvability defects can have a huge impact on the cost and quality of the final product.
Quality code should:
- Require minimal effort to understand
- Require minimal effort to add new features
- Require minimal effort find and fix defects
You should be noticing a pattern here...
No matter what industry the software system is developed for, lack of coding standards and poor coding structure result in increased development effort. Since no two systems are exactly alike, making coding standards is mission-critical.
For example, you can look at different systems that seem to be functionally similar, but are structurally different, have different levels of evolvability, and may have varying times associated with fixing any errors tied to new functionality. Therefore, poor coding standards will greatly influence productivity, resulting in additional costly rework.
There's also a direct relationship between good coding techniques and evolvability in relation to your company’s economic bottom line - specifically with development of system features and error fixing efficiency.
Newer development methods (extreme programming, Agile development, etc.) that focus on short development cycles already recognize the value of high evolvability. Developers in these environments work closely with the customer over continuously changing requirements that acclimate the system as needed with a smaller up-front cost to the company. Both of the methodologies above emphasize a continuous refactoring claim in order to produce high evolvability in their systems.
Industry experts support the refactoring claim that high evolvability results in:
- Easier program comprehension and defect detection
- Increased software development speed
- Better testing, auditing, and documenting
- Reduced dependency on individuals
- Greater job satisfaction
- Extension of a system’s lifetime
All of these results help to preserve the software value for the organization and provide for better software development management. Keep in mind that the costs associated with not fixing evolvability defects may result in higher costs over the duration of the project.
And if the thought of a formal code review process makes you trepidatious, remember... “code review doesn't have to suck!”