As an old saying in the IT industry goes, you can’t manage what you can’t measure. With knowledge into the complexity an organization’s application portfolio comes a greater ability to manage the same. The biggest problem is that the things that make up software complexity – overwritten and rewritten code, legacy system remnants, etc. – are the very same things that make measuring it a feat.
In some cases, with so many system interfaces and compound requirements, the complexity of software systems can spiral out of control, leading to soaring costs and risks. Unless corrected, software complexity can run rampant in finished projects, leaving behind puffed, burdensome applications. In fact, IT professionals would say that to maintain software is to degrade it.
A variety of techniques have fortunately been established for measuring software complexity, among which is cyclomatic complexity, which determines a program’s amount of control flow. Programs that operate with more conditional logic are harder to understand, and measuring its level of cyclomatic complexity reveals how much has to be managed.
However, the use of cyclomatic complexity by itself can turn in wrong results. A module may be complicated but have fewer interactions with external modules. A module can be comparably simple as well and yet highly coupled with a range of other modules, hence dramatically increasing the total complexity of the codebase. Complexity metrics will be bad in the first scenario. In the second, they will seem to be better, but the result will be incorrect. In other words, measuring the coupling and cohesion of the modules in the codebase is necessary as well if a true system-level, software complexity measure is to be attained.
On this information, organizations can capitalize in many different ways, including:
By knowing the level of complexity of the code, it becomes easier to know how much maintenance will be required for a program.
Software Risk Reduction
Software complexity management reduces the chances of issues being introduced into production.
Being proactive in terms of avoiding too much or less important software complexity can reduce costs as an organization as able to prepare for what is to come.
As seen in past years, too complex applications lead to issues. When complexity is in check, organizations are able to preserve the value of their applications and also lengthen their use.
Some codes tend to be extremely complex and thus not worth the save. Proving the costs of a rewrite, it can be decided whether existing code must be kept or a new code must be written altogether.