The Software System Lifecycle Stages

• RESEARCH & DEVELOPMENT stage (R&D) comprises the Proof of Concept Phase and Elaboration Phase, typically bid in a risk sharing manner as cost plus award fee contract (CPAF).
• PRODUCTION stage comprises the Construction Phase and Deployment Phase, typically bid as a firm, fixed priced contract (FFP).
• MAINTENANCE stage if any, typically bid as a level of effort contract (LOE).

The Software System Lifecycle Phases

• THE PROOF OF CONCEPT phase brings to light an original vision of a potential product, and transforms it into an actual project. Its purpose is to establish the business case for a new product or a major update, and to specify the project scope. For the development of a new product, the main outcome of this phase is a "go - no go" decision to move into the next phase and to invest time and money to analyze in detail what is to be built, can it be built, and how to build it. For the evolution of an existing product, this may be a simple and short phase, based on users' or customers' requests, on problem reports, and on new technological advances. For a contractual development, the decision to proceed is based on experience of the specific domain and on the competitiveness of the development organization in this domain or market. In this case the proof of concept phase may be concluded by a decision to bid, or by the bid itself. The idea may be based on an existing research prototype, whose architecture may or may not be suitable for the final software.
• THE ELABORATION phase has as the main goal to more thoroughly analyze the problem domain, to define and stabilize the architecture, and to address the highest risk elements of the project. In this phase an executable architectural prototype is built, in one or several iterations depending on the scope, size, risk, novelty of the project, which addresses at least the top key use cases identified in the inception phase, and which addresses the top technical risks of the project. This is preferably an evolutionary prototype, of production quality code, which becomes the architectural baseline, but it does not exclude the development of one or more exploratory, throw-away prototypes to mitigate specific risks: refinements of the requirements, feasibility, human-interface studies, demonstrations to investors, etc. It becomes the architectural baseline. At the end of this phase, there is again a "go-no go" decision point to actually invest and build the product (or bid for the complete development of the contract). The plans produced must be detailed enough, and the risks sufficiently mitigated to be able to determine with accuracy the cost and schedule for the completion of the development.
• THE CONSTRUCTION phase is broken down into several iterations--fleshing out the architecture baseline and evolving it in steps or increments toward the final product. At each iteration, the various artifacts prepared during the elaboration phase (see above) are expanded and revised, but they ultimately stabilize as the system evolves in correctness and completeness. New artifacts are produced during this phase beside the software itself--documentation, both internal and for the end-users, test beds and tests suites, and deployment collateral to support the next phase (marketing collateral, for example).
• THE DEPLOYMENT phase is the phase where the product is put in the hands of its end users. It involves issues of marketing, packaging, installing, configuring, supporting the user-community, making corrections, etc. From a technical perspective the iterations continue with one or more releases (or deliveries):`beta' releases, general availability releases, bug fixes, or enhancement releases. The phase is completed when the user community is satisfied with the product: formal acceptance for example in a contractual setting, or when all activities on this product are terminated. It is the point where some of the accumulated assets can be made reusable by the next cycle or by some other projects.

The Software System Lifecycle Activities

The names of the phases of our Software System Lifecycle stay away from the term describing an intellectual activity: analysis, design…so that is understood that this activity is not confined to that phase. These activities do take place, but in varying degree in each phase iteration. This change focus explains also that, although all structured in the same way, the exact nature and contents of the iterations evolves over time.This also shows that the beginning of an activity is not bound to the end of another, e.g. design does not start when analysis completes, but the various artifacts associated with the activities are revised as the problem or the requirements are better understood.Finally, in an iterative process, the activities of planning, test and integration are spread incrementally throughout the cycle, in each iteration, and not massively lumped at the beginning and at the end, respectively. They appear as separate steps or phases in the process. CST Software System Lifecycle is handled by means of the next activities throughout the whole system lifecycle:

• Analysis,
• Planning,
• Architecture Specification,
• Design,
• Implementation,
• Integration,
• Test/Assessment,
• Deployment Activity,
• Maintenance & Customer Support,
• Closing,
• Evaluation.

Below we present our main Software System Development Lifecycle:

/\ TOP of Page