Data-driven continuous management of technical debts for sustainable software development

As technology becomes more integrated and important in our everyday lives, there is more pressure on software developers to create and deliver new software quicker and with higher quality. But this fast-paced development can lead to something called Technical Debt. Technical debt is like a snowball that keeps getting bigger and bigger, if not addressed properly, as more and more shortcuts are taken during the development process, both intentional and unintentional. This can cause problems in the long run for people who use the software in form of unstable services and bugs, and for the companies that make it in form of being able to add new features, improvements, and keep the service operational. According to previous studies, technical debt can cause an average productivity loss of 40% (peaking at 90% in some projects), and potentially costs the world trillions of dollars every year. Currently, there are not many good ways for developers to keep track of and reduce technical debt. That's why our project aims to help companies proactively visualize and manage technical debt. We will work with companies to understand their specific needs and use technology, tools, and theories from scientific literature to develop new methods and tools to continuously monitor, and manage technical debt. These methods and tools will be tested and improved in real-world settings. Companies that use these methods will have a big advantage in the market. And, overall, this project could lead to more sustainable ways of creating software.

The more important, ubiquitous, and complex software is becoming in our society, the more pressure of time-to-market and quality requirements for software development. Today's fast iteration of software deliveries, in a matter of hours if not less, foment Technical Debt (TD) to be created and accumulated into "snowballs". TD creates a constant and increasing risk of disruption, both for the users of the systems and for the future business of the organizations. TD causes an average productivity loss of 40% (peaking at 90% in some projects) costing the world $5.82 trillion. Despite the strong interest in both industry and academia, existing methods and commercial tools (e.g., Veracode, Coverity, SonarQube) for software developers to proactively monitor and reduce TD are limited and fragmented. Moreover, modern software engineering practices and architectures represented by DevOps and microservices, provide new challenges to manage TD, which are not yet tackled. Our project aims to empower companies with a competitive edge to systematically deal with the serious invisible problem of TD, by enabling the proactive management of TD for all software products. Our research towards realizing the planned innovation will follow a design science approach. We will empirically elicit requirements and business needs from the industrial contexts, to understand how DevOps teams can exploit the available data to continuously measure, avoid, and deal with TD and its impact. Technologies, related tools, and existing theories from scientific literature will provide the foundation to develop novel methods and tools. Such methods and tools will be evaluated and continuously refined with input from their practical application at the industrial partners contexts. The companies that successfully implement such methods will benefit from a major competitive edge in the market. The project results can lead to more sustainable ways of software development in the software industry.