Software development is an inherently creative process. Many developers compare it to art, and— like artists— take great pride in their work. However, creative processes typically are not efficient. The software development process is no exception, as the above quote clearly indicates.

Given that software development is a business, many software development managers and team leads want to make it more productive and predictable. Yet, they worry that such efforts will frustrate developers and impact the creativity that is vital for successful software projects. Fortunately, efficiency and creativity can peacefully coexist within the software development process. When the more mundane aspects of development are automated, developers can focus on the creative tasks they enjoy most…and still deliver better software in less time. This paper explains how five industry-standard practices reduce the amount of avoidable waste in the software development process, enabling developers to satisfy business goals without compromising their craft.

Fewer Bugs or Shorter Schedules?

Surprisingly, the fastest schedule is actually one with a very high defect removal rate. Consider the following graph, which is taken from Capers Jones’ Applied Software Measurement: Assuring Productivity and Quality, 2nd edition (McGraw-Hill, 1996):

This graph, which is based on industry statistics, shows the relationship between total development time and the percentage of defects removed before a software release. As you can see, the development time steadily declines until the 95% defect removal rate is reached, then it spikes as the percentage of defects removed approaches 100%.

These findings show that— contrary to popular belief— delivering better quality software does not necessarily take more time than delivering lower quality software (i.e., software with more defects). Rather, the optimum schedule is attained with a pre-release defect removal rate of 95%, which is quite high in terms of software quality. This development point results in both the shortest schedule and a very low percentage of defects. Removing more defects will likely improve perceived quality, but would dramatically increase development time.

Two key points to take away from these findings are:

• Defect removal does not occur “naturally.” It requires the engineering team to proactively adopt appropriate practices and tools.
• Most organizations admittedly are in the sub-optimal area of this graph. This means that they can not only improve the quality of delivered code, but also produce the code at a lower cost.

Examples of Waste

The first step in moving towards this optimal development zone is identifying the types of waste that can and should be avoided. Granted, there is some unavoidable waste inherent in the software development process. For instance, examples of such waste include basic research and development that does not get productized, prototyping, and so forth.

The scope of avoidable waste, however, is quite substantial. It can include:

• A day spent fixing a build breakage that occurred because someone checked in code without locally compiling it. This occurs far more often than most managers think.
• Two weeks spent manually chasing a memory bug. This is especially common in C/C++.
• Two weeks spent debugging a missing curly brace. This seems incredible, but can actually occur when the team is looking at functional manifestations of this error and trying to debug the error from that end.
• Figuring out what the heck this variable g stands for. This is a result of poor naming conventions.
• Nominal case design and development. This is typically a result of ignoring corner case conditions.

Notice a common thread here: much waste stems from late detection of defects that could have been detected much earlier, or sometimes prevented altogether. This applies to all types of defects– including missing requirements, lack of error checking for unexpected user actions, or structural code problems.

Motivators for Waste Reduction

One benefit of reducing waste is that it allows your team to reach the development point that results in a reduced development time and a very low percentage of remaining defects. Thinking back to the “development time vs. percentage of defects removed” graph in the earlier section, the organizations that are in the optimal area of their development cycles are those that dramatically reduce their waste by targeting defect removal earlier in the process. Thus, they achieve both higher quality software and lower development costs.

The other tangible benefit of reducing waste is that it improves the professional life of developers. Their job satisfaction typically improves when they are relieved from having to spend excessive time fixing bugs (unproductive work), and can instead focus on the creative tasks that they enjoy the most.

Five Countermeasures to Development Waste

Our own experience at Parasoft matches very well with many of the recommendations of Boehm and Basili’s “Software Defect Reduction Top 10 List.” In fact, most of the approaches that Parasoft products implement line up with one or more of the top 10 methods. We reduced this list even further to facilitate the introduction and adoption of these practices.

The five cornerstones of our approach to reducing development waste are:

• Robust development infrastructure
• Consistent coding – personal and team practices
• Consistent peer code review
• Early testing
• Automated regression testing

Finally— and most importantly— reducing waste in a systematic manner also requires a reporting system that enables teams to track qualitative progress towards their goals for all five of the above countermeasures.

The above strategies are explained in the following sections...

To read more, download the PDF.