Main Description |
A prototype is a version of the system that is produced by an incremental (spiral) development cycle. One of the
prototypes will be released as the final system, but even early prototypes are executed and validated against the
requirements they implement. A prototype is generated to meet a mission that identifies its purpose and scope and is
validated against that mission. Subsequent prototypes contain the elements of earlier prototypes augmented by elements
to realize new requirements and reduce further risks. During the validation of a prototype, not only is the new
functionality tested, but a subset of the functionality from previous prototypes is also ensured through regression
testing.
A prototype may be thought of as a "vertical slice" through the layers of design of the system. It may not be complete
- in the sense that all the final functionality is present - but what it can be validated against what the requirements
it implements. Subsequent prototypes must often reorganize some set of the previous prototypes elements to fit in the
new functionality, a process known as Refactoring. Refactoring is common, but is very rarely an issue, as it is mostly
an organic set of minor changes to evolve the system to its final, fully functional state.
The prototype can exist in a number of different conditions, or states. These are:
-
Pre-integrated: the prototype content is being updated in the analysis, design, or implementation phases
-
Partially Integrated: during integration, the architectural components are being added, but the integration is not
yet complete
-
Integrated: the integration of the components to form the prototype is complete, and some sanity checks have been
performed to ensure the prototype is properly integrated, but it has not yet been validated
-
Validated: the prototype has passed the validation test suite
-
Baselined: the validated prototype has been baselined in the underlying configuration management system.
|