Telecom companies are facing great challenges from both internal and external forces. While on the one hand, 5G is just around the corner, it’s not uncommon that crucial transactions in mobile solutions are handled by 10-year-old legacy systems. And these legacy systems have typically been built worse than others, as the fast-paced environment in the telecoms industry keeps driving development teams to prioritize delivering functionality over software quality.
If you’re a manager or developer in the telecoms industry, you must be familiar with the term “technical debt,” which refers to the current “debt” in software quality that has been accumulated through sub-optimal technical quick fixes over many years. This “technical debt” accrues interest in the form of high maintenance costs, slow time-to-market, and unpredictable future release delays. And eventually, it will lead to a huge collection of code that’s very hard to understand and very risky to change for functional extension.
During the 2020 SIG Symposium this past June, our head of research, Dr. Magiel Bruntink, shared an interesting finding about the telecoms industry taken from this year’s Benchmark Report, our annual report on the state of the software industry. The report includes a software quality ranking by industry, based on the SIG software assurance database containing 36 billion lines of code across 280+ technologies and 5,000 system inspections. Dr. Bruntink explained that the telecoms sector currently ranks lowest (out of 12 industries evaluated) in its average software maintainability rating. The average maintainability rating of systems in the telecoms sector is 2.6, on a scale where 3.0 is market average.
However, this doesn’t mean you need to accept irreversible increases in cost and risk in software development and maintenance. In the past three years, among our many telecom clients, we’ve successfully helped a large international telecom provider improve the quality of its software landscape with our portfolio monitoring service. And the client now sees a 20% productivity increase over nearly their entire application landscape.
As in most telecom organizations, we found that this client’s software landscape was large and complex. It consists of more than 10 systems written in 20 different technologies, from Java applications and SAP solutions to Tibco service bus and Angular frontend portals. And these systems are in various stages of their lifecycles. A few applications are newly developed, whereas others have been running for more than 15 years. Overall, the mixed box of systems contains about 600 person years of code, which means, in theory, it would take one developer 600 years to develop the current landscape.
Having too many technologies in one software landscape is definitely a risk for maintenance, but it wasn’t the most worrisome challenge that we identified; the most critical issue here was the software’s low quality. The average Maintainability rating for the landscape was far below market average.
After understanding the purpose and the future plan for each system in the software landscape, we defined specific improvement targets with each development team, including those from external vendors. Though each individual system is different, the general principles are the same:
- Always aim for high quality for newly added code. We provide a simple set of rules and an automated measurement, support and advice system for this.
- When a developer works with an existing piece of code, he/she should refactor it to achieve higher quality. This is also called The Boy Scout Rule: Leave things better than you found them.
- Actively clean unused code from the system, especially in legacy systems. Smaller systems are easier to maintain.
After three years of actively monitoring and advising the teams on strategies to improve code quality, by the end of 2019, the average Maintainability rating of the software landscape had improved by 30%. This is significant. When we translate that into effort and cost, it means the quality improvement would save this client over 40 FTEs per year for maintenance. In other words, they’d have 40 more FTEs to work on key new features rather than resolving bugs in existing functionalities.
It’s important to note that this transformation towards a quality-centric organization goes beyond just the involved developers; this particular software landscape was maintained and expanded by five different suppliers as well. Also, after the first year of monitoring, the client reshuffled two suppliers based on their performance in writing high quality code, and from then on, the SIG Maintainability rating has become an KPI in the contract with all suppliers.
Adding such concrete metrics in supplier contracts has become an increasingly accepted way to manage and help suppliers in delivering high quality software – for immediate use and for the future.