Is Complexity Killing Your Code Quality?
Complexity leads to bugs, and bugs lead to unemployment. Is your code getting too complex?
Join the DZone community and get the full member experience.Join For Free
Since its inception, software development has never been an easy feat, but today, it's arguably even harder than before due to the sheer number of considerations necessary. Will you develop for one smartphone manufacturer or multiple? What operating system will be supported and what are the requirements for each piece of hardware? With increasing device fragmentation, it's likely that some groups will cut corners in the software development process and find themselves in technical debt. This complexity could be inhibiting the overall quality of your software, and it's important for QA management to both understand these challenges and overcome them.
One of the biggest issues in application development and deployment is application sprawl. This happens when there are numerous programs available, but many are risky, out-of-date, or unnecessary. However, because users argue their necessity, teams are forced to continue supporting this software. Computerworld noted that some organizations may simply shut down the application's server to see if anyone notices. If an access attempt isn't made within six months, it's then assumed that the program isn't truly necessary.
By maintaining this type of outdated resource, teams are hindering themselves from making inroads for new projects and improving software quality across the board. It's also very costly to support this unstable software. Gartner vice president and fellow Andy Kyte told Computerworld that 80 percent of IT's budget may be made up of less than 20 percent of its applications. Organizations must retake control of this sprawl in order to reduce complexity and start building in quality.
"You have to manage all applications for value. Know what you've got, why you've got it, what it costs, what you plan to do with it, and how you're going to continue to manage it," Kyte stated.
Combining legacy code and new efforts has also introduced a layer of complexity for teams to overcome. While integrating legacy code can be cheap at first, teams will find that it can take significant funds to maintain and test it. Cast contributor Jonathan Bloom noted that rewritten and overwritten code, as well as legacy system remnants, can add to the challenges teams may experience.
"With multiple system interfaces and complex requirements, the complexity of software systems sometimes grows beyond control, rendering applications and portfolios too costly to maintain and too risky to enhance," Bloom wrote. "Left unchecked, software complexity can run rampant in delivered projects, leaving behind bloated, cumbersome applications."
Teams must use quality test management tools to identify weak areas in the code and measure software complexity. This information will help teams determine what move to make next as well as how to keep complexity down. Challenges within applications can be inherently harming overall software quality. It's up to each team and each individual tester to help mitigate these issues and support agile development practices while providing quality deliverables. This will only happen once teams realize where the complexity is stemming from and how they can leverage tools to help them simplify it.
Published at DZone with permission of Francis Adanza. See the original article here.
Opinions expressed by DZone contributors are their own.