At Compuware, we have been exploring the need for continuous improvement across three key dimensions of software development: velocity, quality and efficiency. Given today’s current market demands and the importance of digital services, this discussion couldn’t be timelier.
On my previous piece, I focused on quality — how to maintain and improve it as (supposedly) competing demands for velocity and efficiency increase simultaneously. This article will focus on increasing velocity and how it is possible to do so without compromising quality or efficiency. As I discussed in my earlier piece on quality — automation, integration and measurement are once again the key.
Compuware recently conducted a survey finding the overwhelming majority (97%) of application development managers said IT is under more pressure than ever to deliver software innovation faster. Higher demands for innovation are being imposed universally across platforms, from the cloud all the way back to the mainframe.
Mainframe software delivery is a particular area of focus, with 95% of respondents noting their IT teams are under pressure to adopt modern development practices on the mainframe in order to accelerate overall software delivery and innovation. Adding to this pressure, organizations reported they expect to increase the frequency of new mainframe application feature deployments by an average of 41% over the next year, compared to 38% for non-mainframe applications. This shouldn’t come as a shock, given the proliferation of modern web-based applications placing unprecedented demands on back-end mainframes.
Let’s take a closer look at how automation, integration and measurement are equally applicable to the goal of advancing velocity.
Throughout the software lifecycle there are many opportunities for automation — from software design, to development, to build, test, deploy and, ultimately, the production state. The more of these steps that can be automated, the faster developers can work.
Perhaps the biggest area for potential time savings is testing, because of all the phases of the software lifecycle, testing assumes the most manual labor. The Vanson Bourne survey found test automation to be the single most important factor in accelerating innovation, according to 90% of IT leaders.
On the mainframe specifically, development teams spend more than half their time on testing during the release of a new mainframe application, feature or functionality. If you can automate more testing, you can roll out applications faster while maintaining (or even enhancing) quality combined with an extremely high level of developer efficiency.
Integration helps software development technologies interoperate with each other. An integrated pipeline leverages existing investments and enables developers to build, test and deploy faster while providing the additional benefit of reducing errors resulting from human intervention (furthering quality). Integration also decreases the manual labor needed to execute and manage workflow within software delivery processes. When these technologies integrate out of the box, setup time is saved and productivity gains can be realized significantly faster.
For example, the integration of Compuware Strobe application performance solution with Jenkins, makes it easy for developers to take performance measurements early and automatically as part of a Jenkins CI/CD pipeline.
Measuring velocity is critical. Without measuring, it’s impossible to know how changes are impacting the software development process and what areas need to be improved. Measuring is the key to understanding if there are any activities that can be sped up across the phases of build, test and deploy. This enables development teams to find and address bottlenecks with a great level of granularity. Some common metrics for measurement include mean-time-to-build (MTTB), mean-time-to-delivery (MTTD) and mean-time-to-repair (MTTR).
Velocity does not need to exist at the expense of quality or efficiency — on the cloud, the mainframe or any other development platform. Like quality, the key to achieving and improving velocity lies in the disciplines of automation, integration and ongoing measurement. The next piece of this series will explore the keys to maximizing developer efficiency amidst near constant demands for exceptionally fast, high-performing rollouts.