Home > Articles > Programming > C/C++

Improving Software Economics, Part 1 of 7: From Software Development to Software Delivery

  • Print
  • + Share This
In part 1 of this series, Walker Royce discusses the economic changes inherent in moving from the software development model to the software delivery model.
From the author of

The world is becoming more dependent on software delivery efficiency and world economies are becoming more dependent on producing software with improved economic outcomes. What we have learned over decades of advancing software development best practice is that software production involves more of an economics than an engineering discipline. This series of articles provides a provocative perspective on achieving agile software delivery and the economic foundations of modern best practices.

Improvement in software lifecycle models and software best practices has been a long slog that accelerated in the 1980s as the engineering roots of software management methods continued to fail in delivering acceptable software project performance. IBM's Rational team has partnered with hundreds of software organizations and participated in thousands of software projects over the last 25 years. Our mission has been twofold: first, to bring software best practices to our customers; and second, to participate directly on their diverse projects to learn the patterns of success and failure so that we could differentiate which practices were best, and why. The Rational team didn't invent iterative development, object-oriented design, UML, agile methods, or the best practices captured in the IBM® Rational® Unified Process. The industry evolved these techniques, and we built a business out of synthesizing the industry's experience and packaging lessons learned into modern processes, methods, tools, and training. This series of articles provides a short history of this transition by looking at the evolution of our management principles. It presents our view of the Top 10 principles in managing an industrial-strength software organization and achieving agility at any scale of business challenge.

Most organizations that depend on software are struggling to transform their lifecycle model from a development focus to a delivery focus. This subtle distinction in wording represents a dramatic change in the principles that are driving the management philosophy and the governance models. Namely, a "software development" orientation focuses on the various activities required in the development process, while a "software delivery" orientation focuses on the results of that process. Organizations that have made this transition—perhaps 30–40% by our estimate—have recognized that engineering discipline is trumped by economics discipline in most software-intensive endeavors.

Table 1 provides a few differentiating indicators of successful transformation from conventional engineering governance to more economically driven governance.

Table 1 Differentiating Conventional Engineering Governance from Economically Driven Governance

Software Development: Engineering Driven

Software Delivery: Economics Driven

Distinct development phases

Continuously evolving systems

Distinct handoff from development team to maintenance team

Common process, platform, and team for development and maintenance

Distinct and sequential activities from requirements to design to code to test to operations

Sequence of usable capabilities with ever-increasing value

Phase- and role-specific processes and tools

Collaborative platform of integrated tools and process enactment

Collocated teams

Evolving precision as uncertainties are resolved

Early precision in complete plans and requirements

Governance through measurement of incremental outcomes, and progress/quality trends

Engineering discipline: Precisely define requirements/plans completely, and then track progress against static plans and scope

Economic discipline: Reduce uncertainties, manage variance, measure trends, adapt and steer with continuous negotiation of targets

Success rates in applying engineering governance (a.k.a. waterfall model management) have been very low; most industry studies assess the success rate at 10–20%. Where waterfall model projects do succeed, the project usually has been managed with two sets of books. The front-office books satisfy the external stakeholders that the engineering governance model is being followed, and the back-office books, where more agile techniques are employed with economic governance, satisfy the development team that they can predictably deliver results in the face of the uncertainties. The results of the back-office work are fed back to meet the deliverables and milestones required for the front-office books. "Managing two sets of books" has been expensive, but it is frequently the only way for developers to deliver a satisfactory product while adhering to the stakeholder demand for engineering governance. Advanced organizations have transitioned to more efficiently managing only one set of honest plans, measures, and outcomes. Most organizations still manage some mixture of engineering governance and economic governance to succeed.

Let's take a minute to think about engineering vs. economics governance—i.e., precise up-front planning vs. continual course correction toward a target goal—in terms relatable even to those outside the software industry. This hypothesis may be thought-provoking: Software project managers are more likely to succeed if they use techniques similar to those used in movie production, compared to those used conventional engineering projects, such as bridge construction. [1, 2] Consider this:

  • Most software professionals have no laws of physics or properties of materials to constrain their problems or solutions. They are bound only by human imagination, economic constraints, and platform performance once they get something executable.
  • Quality metrics for software products have few accepted atomic units. With the possible exception of reliability, most aspects of quality are very subjective (such as responsiveness, maintainability, and usability). Quality is best measured through the eyes of the audience.
  • In a software project, you can seemingly change almost anything at any time: plans, people, funding, requirements, designs, tests. Requirements—probably the most misused word in our industry—rarely describe anything that is truly required. Nearly everything is negotiable.

These three observations are equally applicable to software project managers and movie producers. These are professionals that regularly create a unique and complex web of intellectual property bounded only by a vision and human creativity. Both industries experience a very low success rate relative to mature engineering enterprises.

The last point above is worth a deeper look. The best thing about software is that it is soft (i.e., relatively easy to change), but this is also its riskiest attribute. In most systems, the software is where we try to capture and anticipate human behavior, including abstractions and business rules. Most software does not deal with natural phenomena where laws of physics or materials provide a well-understood framework. Hence, most software is constrained only by human imagination; the quality of software is judged more like a beauty contest than by precise mathematics and physical tolerances. If we don't carefully manage software production, we can lull ourselves into malignant cycles of change that result in massive amounts of scrap, rework, and wasted resources.

With the changeability of software being its greatest asset and greatest risk, it is imperative that we measure software change costs and qualities and understand the trends therein. The measure of scrap and rework is an economic concern that has long been understood as a costly variable in traditional engineering, as in the construction industry. While in the software industry we commonly blow up a product late in the lifecycle and incur tremendous scrap and rework to rebuild its architecture, we rarely do this in the construction industry. The costs are so tangibly large, and the economic ramifications are dire. In software, we need to get an equally tangible understanding of the probable economic outcomes.

A lesson that the construction industry learned long ago was to eliminate the risk of reinventing the laws of construction on every project. Consequently, they enforced standards in building codes, materials, and techniques, particularly for the architectural engineering aspects of structure, power, plumbing, and foundation. This resulted in much more straightforward (i.e., predictable) construction, with innovation mostly confined to the design touches sensed by its human users. This led to guided economic governance for the design/style/usability aspects, with standardization and engineering governance driving most of the architecture, materials, and labor. When we innovate during the course of planned construction projects with new materials, new technology, or significant architectural deviations, it leads to the same sorts of overruns and rework that we see in software projects. For most products, systems, and services, you want to standardize where you can, and not reinvent.

Economic discipline and governance is needed to measure the risk and variance of the uncertain outcomes associated with innovation. Most software organizations undertake a new software project by permitting their most trusted craftsmen to reinvent software capabilities over and over. Each project and each line of business defend the reasons why their application is different, thereby requiring a custom solution without being precise about what is different. Encumbered with more custom developed architectures and components than reused ones, they end up falling back on the waterfall model, which is easy to understand. But this approach is demonstrably too simplistic for uncertain endeavors such as software.

The software industry has characterized new and improved software lifecycle models using many different terms, such as spiral development, incremental development, evolutionary development, iterative development, and agile development. In spirit, these models have many things in common, and as a class they represent a common theme: anti-waterfall development. However, after 20–30 years of improvement and transition, the waterfall model mindset is still the predominant governance process in most industrial-strength software development organizations. By my estimation, more than half of the software projects in our industry still govern with a waterfall process, particularly organizations with mature processes. Perhaps geriatric could be used as an explicit level of process maturity, one that should be recognized in software maturity models to help organizations identify when their process has become too mature and in need of a major overhaul.


[1] Royce, Bittner, Perrow, The Economics of Iterative Software Development: Steering Toward Better Business Results, Addison-Wesley, 2009.

[2] Royce, Walker, "Successful Software Management Style: Steering and Balance," IEEE Software, Vol. 22, No. 5, September/October 2005.

  • + Share This
  • 🔖 Save To Your Account