Incremental Life Cycle Model
This article discusses incremental and evolutionary development models beyond variants of the System Life Cycle Process Models: Vee.
Incremental and Evolutionary Development
Overview of the Incremental Approach
Incremental and iterative development (IID) methods have been in use since the 1960s (and perhaps earlier). They allow a project to provide an initial capability followed by successive deliveries to reach the desired System-of-Interest.
The IID approach, shown in Figure 1, is used when:
- Rapid exploration and implementation of part of the system is desired,
- The requirements are unclear from the beginning,
- Funding is constrained, or
- The customer wishes to hold the System-of-Interest open to the possibilities of inserting new technology at a later time.
- Experimentation is required to develop successive prototype versions.
The features that distinguish IID from the single-pass plan-driven approach are velocity and adaptability.
Figure 1 - Incremental Development with multiple deliveries (Forsberg, Mooz, Cotterman. 2005, Pg 358)
Incremental development may also be “plan-driven” in nature when the requirements are known early in the life cycle but the development of the functionality is performed incrementally to allow for the latest technology insertion or potential changes in needs or requirements.
Incremental development also imposes constraints. The model shown in Figure 2 uses the increments to develop high-risk subsystems (or components) early, but the system cannot function until all increments are complete.
Figure 2 - Incremental Development with a Single Delivery (Forsberg, Mooz, Cotterman. 2005, Pg 358)
Overview of the Evolutionary Approach
A specific IID methodology called evolutionary development is common in research and development (R&D) environments. Figure 3 illustrates this approach. It was used in the evolution of the high temperature tiles for the NASA Space Shuttle (Forsberg 1995).
Figure 3 - Evolutionary Generic Model (Forsberg, Mooz, Cotterman. 2005, Pg. 357)
The real world development environment is complex to map because many different project cycles are underway simultaneously. Figure 4 shows the applied research era for the development of the space shuttle orbiter. Figure 4 illustrates multi-levels of simultaneous development, trade studies, and ultimately implementation.
Figure 4 - Evolution of components and orbiter subsystems (including space shuttle tiles) during creation of a large “single-pass” project (Forsberg 1995)
Iterative Software Development Process Models
Software is a flexible and malleable medium, which facilitates iterative analysis, design, construction, verification, and validation to a greater degree than is usually possible for the physical components of a system. Each iteration of an iterative development model adds code to the growing software base; the expanded code base is tested, reworked as necessary, and demonstrated to satisfy the requirements for that baseline.
Process models for software development support iterative development on cycles of various lengths. Table 1 lists three iterative software development models presented in the Life Cycle Models topic area and the aspects of software development that are emphasized by those models.
Table 1 - Primary emphases of three iterative software development models
Iterative-development process models
Developing and modifying software involves creative processes that are subject to many external and changeable forces. Long experience has shown that it is impossible to “get it right” the first time, and that iterative development processes are preferable to linear, sequential development process models such as the well-known Waterfall model.
In iterative development, each cycle of the iteration subsumes the software of the previous iteration and adds new capabilities to the evolving product to produce a next, expanded version of the software. Iterative development processes provide the following advantages:
- continuous integration, verification, and validation of the evolving product,
- frequent demonstrations of progress,
- early detection of defects,
- early warning of process problems,
- systematic incorporation of the inevitable rework that occurs in software development, and
- early delivery of subset capabilities (if desired).
Iterative development takes many forms in software engineering, including these:
- An Incremental-build process is used to produce periodic (typically weekly) builds of increasing product capabilities;
- Agile development is used to closely involve a prototypical customer in an iterative process that may repeat on a daily basis;
- The Spiral model is used to confront and mitigate risk factors encountered in developing the successive versions of a product.
This section focuses on the Incremental-build model.
The Incremental-build model
The Incremental-build model is a build-test-demonstrate model of iterative cycles in which frequent demonstrations of progress and verification & validation of work to date are emphasized. The model is based on stable requirements and a software architectural specification. Each build adds new capabilities to the incrementally growing product. The process ends when the final version is verified, validated, demonstrated, and accepted by the customer.
Table 2 lists some partitioning criteria for incremental development into incremental build units of, typically, one calendar-week each. The increments and the number of developers available to work on the project determine the number of features that can be included in each incremental build. This, in turn, determines the overall schedule.
Table 2 - Some partitioning criteria for incremental builds
Figure 5 illustrates the details of the build-verify-validate-demonstrate cycles in the Incremental-build process. Each “build” includes detailed design, coding, integration, and review and testing by the developers. In cases where code is to be reused without modification, some or all of an incremental build may consist of review, integration, and test of the base code augmented with the reused code.
Figure 5 - Incremental build-verify-validate-demonstrate cycles (Fairley 2009, Figure 2.11)
Development of an increment may result in rework of previously developed components to for integration, to fix defects in previous components, or to fix defects in the new components.
Incremental verification, validation, and demonstration, as illustrated in Figure 5 overcomes two of the major problems of a Waterfall approach: 1) problems are exposed early and can be corrected as they occur; 2) minor in-scope changes to requirements that occur as a result of incremental demonstrations can be incorporated in subsequent incremental builds.
Figure 5 also illustrates that it may be possible to overlap successive builds of the product. It may be possible, for example, to start detailed design of the next version while the present version is being validated.
Three factors determine the degree of overlap that can be achieved:
- availability of personnel,
- adequate progress on the previous version , and
- the risk of significant rework on the next overlapped build because of changes to the previous in-progress build.
The Incremental-build process works well when each team consists of 2 to 5 developers plus a team leader (who is also a technical contributor).
The Incremental-build model can be scaled up for large projects.
A significant advantage of an Incremental-build process is that features built first are verified, validated, and demonstrated most frequently because subsequent builds incorporate the features of the earlier builds. In building the software to control a nuclear reactor, for example, the emergency shutdown software could be built first. Operation of emergency shutdown (scramming) would then be verified and validated in conjunction with the features of each successive build.
In summary, the Incremental-build model, like all iterative models, provides the advantages of continuous integration and validation of the evolving product, frequent demonstrations of progress, early warning of problems, early delivery of subset capabilities, and systematic incorporation of the inevitable rework that occurs in software development.
The role of prototyping in software development
In software engineering, a prototype is a mock-up of the desired functionality of some part of the system. This is in contrast to physical systems, where a prototype is usually a first full functionality version of a system. (Fairley 2009, p 74)
In the past, incorporating prototype software into production systems has created many problems. Prototyping is a useful technique that should be employed whenever appropriate; however, prototyping is not a process model for software development. When building a software prototype, we keep the knowledge we have gained but we do not use the code in the deliverable version of the system
In many cases it is more efficient and more effective to build the production code “from scratch” using the knowledge gained by prototyping than to re-engineer the prototype code.
Life cycle sustainment of software
Software, like all systems, requires sustainment efforts to enhance capabilities, to adapt to new environments, and to correct defects. The primary distinction for software is that sustainment efforts change the software; unlike physical entities, software components do not have to be replaced because of physical wear and tear. Changing the software requires re-verification and re-validation, which may involve extensive regression testing to determine that the change has the desired effect and that the change has not altered other aspects of functionality or behavior.
Retirement of software
Useful software is seldom retired. Software that is useful often experiences many upgrades during its lifetime so that a later upgrade may bear little similarity to the initial version. In some cases, software that ran in a former operational environment is executed on hardware emulators that provide a virtual machine on newer hardware. In other cases, a major enhancement may replace, and rename, an older version of the software, but the enhanced version provides all of the capabilities of the previous software in a compatible manner. Sometimes, however, a newer version of software may fail to provide compatibility with the older version, which necessitates other changes to a system.
Primarily Evolutionary and Concurrent Processes: The Incremental Commitment Spiral Model (ICSM)
Overview of the Incremental Commitment Spiral Model
A view of the Incremental Commitment Spiral Model is shown in Figure 6.
Figure 6 - The Incremental Commitment Spiral Model (Pew and Mavor 2007, Figure 2-5)
Each spiral will be concurrently rather than sequentially addressing requirements and solutions; products and processes; hardware, software and human factors aspects; and business case analysis of alternative product configurations or product line investments.
The stakeholders consider the risks and risk mitigation plans, and decide on a course of action. If the risks are acceptable and will covered by risk mitigation plans, the project would proceed into the next spiral.
The Development spirals after the first Development Commitment Review follow the three-team incremental development approach for achieving both agility and assurance shown in Figure 2 and discussed in System Life Cycle Process Drivers and Choices.
Other Views of the Incremental Commitment Spiral Model (ICSM)
Figure 7 presents an updated view of the ICSM life cycle process recommended in the National Research Council “Human-System Integration in the System Development Process” study (Pew and Mavor 2007). It was called the Incremental Commitment Model (ICM) in the study.
The ICSM builds on the strengths of current process models: early verification and validation concepts in the V-model, concurrency concepts in the Concurrent Engineering model, lighter-weight concepts in the Agile and Lean models, risk-driven concepts in the spiral model, the phases and anchor points in the Rational Unified Process (RUP) (Kruchten 1999; Boehm 1996), and recent extensions of the spiral model to address SoS capability acquisition (Boehm and Lane 2007).
Figure 7 - Phased View of the Generic Incremental Commitment Spiral Model Process (Pew and Mavor 2007 Fig 2-1)
The top row of Activities in Figure 7 indicates that a number of system aspects are being concurrently engineered at an increasing level of understanding, definition, and development. The most significant of these aspects are shown in Figure 20, an extension of a similar “hump diagram” view of concurrently engineered software activities developed as part of the RUP [Kruchten 1999].
Figure 8 - ICSM Activity Categories and Level of Effort (Pew and Mavor 2007 Fig 2-3)
As with the RUP version, the magnitude and shape of the levels of effort will be risk-driven and likely to vary from project to project.
Figure 8 indicates that a great deal of concurrent activity occurs within and across the various ICM phases, all of which needs to be synchronized and stabilized (a best-practice term taken from Microsoft Secrets (Cusumano and Selby 1996) to keep the project under control.
The review processes and use of independent experts are based on the highly successful AT&T Architecture Review Board procedures described in (Maranzano et al. 2005). Figure 9 shows the content of the Feasibility Evidence Description. Showing feasibility of the concurrently-developed elements helps synchronize and stabilize the concurrent activities.
Figure 9 - Feasibility Evidence Description Content (Pew and Mavor 2007 Box 2-2)
The Operations Commitment Review (OCR) is different, in that it addresses the often much higher operational risks of fielding an inadequate system. In general, stakeholders will experience a factor of two-to-ten increase in commitment level in going through the sequence of ECR to DCR milestones, but the increase in going from DCR to OCR can be much higher. These commitment levels are based on typical cost profiles across the various stages of the acquisition life cycle.
Underlying ICSM Principles
ICSM has four underlying principles which must be used with the diagrams.
- Stakeholder value-based system definition and evolution.
- Incremental commitment and accountability.
- Concurrent system and software definition and development.
- Evidence and risk-based decisionmaking.
Model Experience to Date
The National Research Council (2008) Human-Systems Integration study found that the ICSM processes and principles correspond well with best commercial practices. Further examples are found in (Pew and Mavor 2007, Chapter 5); (Royce 1998, Appendix D); and the annual series of Top-5 software-intensive systems projects published in CrossTalk (CrossTalk 2002-2005).
Primarily Interpersonal and Unconstrained Processes: Scrum and Agile
Figure 10 shows an example of Scrum as an agile process flow. As with most other agile methods, Scrum uses the Evolutionary Sequential process shown in Table 1 and described in Fixed-Requirements and Evolutionary Development Processes, in which systems capabilities are developed in short periods, usually around 30 days. The project then re-prioritizes its backlog of desired features and determines how many features the team (usually 10 people or less) can develop in the next 30 days.
As shown in Figure 10, once the features to be developed for the current Scrum have been expanded (usually in the form of informal stories) and allocated to the team members, the team establishes a daily rhythm of starting with a short meeting at which each team member does about a one-minute summary of progress since the last Scrum meeting, potential obstacles, and plans for the upcoming day.
Figure 10 - Example Agile process flow: Scrum (Boehm and Turner 2004; ControlChaos.com)
Architected Agile Methods
Over the last decade, several organizations have been able to scale up agile methods by using two layers of 10-person Scrum teams. This involves, among other things, having each Scrum team’s daily meeting followed up by a daily meeting of the Scrum team leaders, and by up-front investments in an evolving system architecture (Boehm et al. 2010). Figure 11 shows an example of the Architected Agile approach.
Figure 11 - Example of Architected Agile Process (Dingsoyr, et. al. 2010. Fig 9.6)
Agile Practices and Principles
Here are summaries of the general practices and principles shared by most agile methods. As seen with the Scrum and Architected Agile methods, generally-shared does not mean uniformly followed.
Iterative Development - any organization can improve its velocity to customer satisfaction.
- The project team understands, respects, works, and behaves within a defined SE process.
- The project is executed as fast as possible with minimum down time or staff diversion during the project. The critical path is managed.
- All key players are physically or electronically collocated. Notebooks are team property and are available to all.
- Baseline management and change control are achieved by formal, oral agreement based on “make a promise, keep a promise” discipline — participants hold each other accountable.
- Opportunity exploration and risk reduction are accomplished by expert consultation and rapid model verification, coupled with close customer collaboration. Software development is done in a rapid development environment, while hardware is developed in a multi-disciplined model shop.
- A culture of constructive confrontation pervades the project organization. The team takes ownership for success; it is never “someone else’s responsibility.”
Agile Development principles (adapted for SE) are as follows (see “Principles behind the Agile Manifesto” 2009):
- First, satisfy the customer through early and continuous delivery of valuable software [and other system elements].
- Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
- Deliver working software [and other system elements] frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
- Business people and developers must work together daily throughout the project.
- Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
- The most efficient and effective method of conveying information is face-to-face conversation.
- Working software [and other system elements] is the primary measure of progress.
- Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
- Continuous attention to technical excellence and good design enhances agility.
- Simplicity — the art of maximizing the amount of work not done — is essential.
- The best architectures, requirements, and designs emerge from self-organizing teams.
At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.
Concluding Remarks
While there are a number of different models describing the project environment, the Spiral model and the Vee model have become the dominant approaches to visualize the development process. Both the Vee and the Spiral are useful models that emphasize different aspects of the process.
The majority of projects will use Incremental and Iterative Development (IID). Evolutionary development is particularly appropriate to new products coming from research whether in the commercial or government environment.
References
Citations
Boehm, B. 1996. "Anchoring the software process." Software, July, 73-82.
Boehm, B., and J. Lane, October 2007. “Using the Incremental Commitment Model to Integrate System Acquisition, Systems Engineering, and Software Engineering,” CrossTalk, pp. 4-9.
Boehm, B., and R. Turner. 2004. Balancing Agility and Discipline. New York, NY, USA: Addison-Wesley.
CrossTalk, January 2002, July 2003, July 2004, September 2005. “Top Five Quality Software Projects,” www.stsc.hill.af.mil/crosstalk
Cusumano, M. and R. Selby, 1996. Microsoft Secrets. New York, NY, USA: Harper Collins.
Dingsoyr, T., T. Dyba. and N. Moe (eds.). 2010 "Agile Software Development: Current Research and Future Directions”; Chapter in Boehm, J. Lane, S. Koolmanjwong, and R, Turner, Architected Agile Solutions for Software-Reliant Systems. New York, NY, USA: Springer.
Fairley, R. 2009. Managing and Leading Software Projects. New York, NY, USA: J. Wiley & Sons.
Forsberg, K. 1995. “’If I Could Do That, Then I Could…’ System Engineering in a Research and Development Environment,” Proceedings, Fifth INCOSE Summer Symposium.
Forsberg, K., H. Mooz, H. Cotterman. 2005.Visualizing Project Management. 3rd Ed., J. Wiley & Sons.
Kruchten, P., 1999. The Rational Unified Process. New York, NY, USA: Addison Wesley.
Maranzano, J., et al., March/April 2005, “Architecture reviews: Practice and experience,” IEEE Software, pp. 34-43.
Pew, R., and A. Mavor (eds.) 2007. Human-System Integration in the System Development Process: A New Look. Washington, D.C., USA: The National Academies Press. http://www.nap.edu
Primary References
Boehm, B., J. Lane, S. Koolmanojwong, and R, Turner. 2012 (planned publication date). Embracing the Spiral Model: Creating Successful Systems with the Incremental Commitment Spiral Model. New York, NY, USA:Addison Wesley.
Boehm, B., and R. Turner. 2004. Balancing Agility and Discipline. New York, NY, USA: Addison-Wesley.
Fairley, R. 2009. Managing and Leading Software Projects. New York, NY, USA: J. Wiley & Sons.
Forsberg, K., H. Mooz, H. Cotterman. 2005.Visualizing Project Management. 3rd Ed. New York, NY, USA: J. Wiley & Sons.
Faisandier, A. 2011. Engineering and Architecting Multidisciplinary Systems (to be published).
INCOSE. 2011. Systems Engineering Handbook, version 3.2.1. INCOSE-TP-2003-002-03.2.1.
Lawson, Harold. 2010. A Journey Through the Systems Landscape. London, UK: College Publications.
Pew, R., and A. Mavor (eds.) 2007. Human-System Integration in the System Development Process: A New Look. Washington, D.C., USA: The National Academies Press. http://www.nap.edu
“Principles behind the Agile Manifesto,” 15 Dec 2009, http://www.agilemanifesto.org/principles.html
Royce, W. E. 1998. Software Project Management. New York, NY, USA: Addison Wesley.
Additional References
Anderson, D., 2010. Kanban. Sequim, WA, USA: Blue Hole Press.
Baldwin, C., and K. Clark, 2000. Design Rules: The Power of Modularity. Cambridge, MA, USA: MIT Press.
Beck, K., 1999. Extreme Programming Explained. New York, NY, USA: Addison Wesley.
Biffl, S., A. Aurum, B. Boehm, H. Erdogmus, P. Gruenbacher (eds.), 2005. Value-Based Software Engineering. New York, NY, USA: Springer.
Boehm, B., May 1988. “A Spiral Model of Software Development,” Computer 21(5), pp. 61-72.
Boehm, B., 2006. “Some Future Trends and Implications for Systems and Software Engineering Processes”, Systems Engineering 9(1), pp. 1-19.
Boehm, B., A. Egyed, J. Kwan, D. Port, A. Shah, and R. Madachy, July 1998. “Using the WinWin Spiral Model: A Case Study,” IEEE Computer, 31(7): 33-44.
Checkland, P., 1981. Systems Thinking, Systems Practice. New York, NY, USA: Wiley.
CrossTalk, January 2002, July 2003, July 2004, September 2005. “Top Five Quality Software Projects,” www.stsc.hill.af.mil/crosstalk
Crosson, S., and B. Boehm, April 2009. “Adjusting Software Life cycle Anchorpoints: Lessons Learned in a System of Systems Context,” Proceedings, SSTC 2009.
Dingsoyr, T., T. Dyba. and N. Moe (eds.). 2010 "Agile Software Development: Current Research and Future Directions”; Chapter in Boehm, J. Lane, S. Koolmanjwong, and R, Turner, Architected Agile Solutions for Software-Reliant Systems. New York, NY, USA: Springer.
Dorner, D., 1996. The Logic of Failure. New York, NY, USA: Basic Books.
Forsberg, K. 1995. “’If I Could Do That, Then I Could…’ System Engineering in a Research and Development Environment,” Proceedings, Fifth INCOSE Summer Symposium.
Forsberg, K. 2010. “Projects Don’t Begin With Requirements.” IEEE Systems Conf. San Diego, CA. April.
Gilb, T., 2005. Competitive Engineering. Maryland Heights, MO, USA: Elsevier Butterworth Heinemann.
Goldratt, E., 1984. The Goal. Great Barrington, MA, USA: North River Press.
Hitchins, D., 2007. Systems Engineering: A 21st Century Systems Methodology. New York, NY, USA: Wiley.
Holland, J., 1998. Emergence. New York, NY, USA: Perseus Books.
ISO/IEC 15288:2008. Systems and software engineering – System life cycle processes.
ISO/IEC 19760:2003. A guide for application of ISO/IEC 15288 System Life Cycle Processes.
ISO/IEC 24748-1:2010. Systems and software engineering, Part 1: Guide for life cycle management
Kruchten, P., 1999. The Rational Unified Process. New York, NY, USA: Addison Wesley.
Landis, T. R. 2010. Lockheed Blackbird Family (A-12, YF-12, D-21/M-21 & SR-71). North Branch, MN, USA: Specialty Press.
Madachy, R., 2008. Software Process Dynamics. New York, NY, USA: Wiley.
Maranzano, J., et al., March/April 2005, “Architecture reviews: Practice and experience,” IEEE Software, pp. 34-43.
National Research Council of the National Academies (USA). 2008. Pre-Milestone A and Early-Phase Systems Engineering. Washington, D.C., USA: The National Academies Press. http://www.nap.edu
Osterweil, L. 1987. “Software Processes are Software Too,” Proceedings, ICSE 9.
Poppendeick, M. and T., 2003. Lean Software Development: an Agile Toolkit. New York, NY, USA: Addison Wesley.
“Principles behind the Agile Manifesto,” 15 Dec 2009, http://www.agilemanifesto.org/principles.html
Rechtin, E. 1991. System Architecting.: Creating and Building Complex Systems. Upper Saddle River, NY, USA: Prentice-Hall.
Rechtin, E., and M. Maier, 1997. The Art of System Architecting. Boca Raton, FL, USA: CRC Press.
Schwaber, K. and M. Beedle, 2002. Agile Software Development with Scrum. Upper Saddle River, NY, USA:Prentice Hall.
Warfield, J., 1976. Societal Systems: Planning, Policy, and Complexity. New York, NY, USA: Wiley.
Womack, J., and D. Jones, 1996. Lean Thinking. New York, NY, USA: Simon and Schuster.