Sunteți pe pagina 1din 10

Requirements Prototyping

Prototyping is used in both requirements phase and the design phase to :


demonstrate a concept demonstrate options
interface technology etc.

demonstrate feasibility to reduce risks

In Requirements phase prototyping may be used for:


requirements elicitation : especially in the UI area requirements validation : performance or functional completeness and consistency

Prototyping Process
Establish the Prototyping Objectives
do not try to do too much and escalate cost and time consider some non-obvious usage of prototype
early training early test plan early documentation initial version for iterative development

Define Prototype Functionality Develop the Prototype Evaluate the Prototype Document the results from the Prototype

Two Major Prototyping Approaches


Prototype thats kept (Evolutionary)
no clear or formal requirements specification system is built and modified in piecemeal form and kept the final delivery is the solution system itself

Prototype that is a Throw Away


detailed requirements specification is written as the prototyping results come in, analyzed, and validated the final delivery is the requirements specification

Evolutionary is very popular when there is new technology, especially with UI. (e.g. Web applications)

Evolutionary Prototyping
Minimal Specification Build Prototype Try out the Prototype

NO

Is the Prototype adequate ? YES Deliver the Solution

Note : that there may not be any Final Specification ; but there is a lot of user interaction to perform usage verification and validation.

Pros and Cons of Evolutionary Prototyping


Advantages
delivery speed (when everything goes well because the skipping of the formal specifications and reviews are removed) heavy user involvement throughout the development of the solution (increments of prototype are utilized -or tested- as soon as they are implemented)

Disadvantages
Not suited for large, complex projects where documentation is needed, more formal reviews are needed, and tighter management control is needed (when something goes wrong, there are not enough information for management to deal with). Continual modifications and changes, which may be unspecified, in the prototype make maintenance by others (even original authors) extremely difficult High possibility of scope creep which can cause increase in cost and time, forcing most of the work performed be charged under time and material basis. (This makes fixed bid a dangerous route.)

Move Towards Incremental Development Process


Define Major Requirements Develop a High Level Design Specify an Increment
NO

Develop an Increment

No

Integrate Increments

Yes

Increment Adequate ?

Use the Increment

System & Increment Adequate ?


Yes

Use the Increment as Part of System

Deliver the Solution

* The key here is that there is an architecture or high level design to provide a general structure.

Throw-Away Prototyping

Requirements Outline

Develop Prototype

Evaluate Prototype

Requirements Specification

If more clarification needed

Feeds into Design

Throw-Away Prototype
Main purpose is to clarify requirements Advantages:
provides an early check, clarification, and validation of requirements provide an early assessment of risks non-code form (e.g. UI) may be quick and cheap

Disadvantages:
the prototype many not have many reusable code may be pressured to keep and deliver the prototype code (e.g. technology prototype may not be user friendly or the code written is not easily maintainable))

Tools for Rapid Prototyping Visual Program Development


Visual Java, Visual Basic, Visual C++ which allows
screen display UI and processing function prototyping

Special Functional and Logic : Lisp and Prolog Database Centered Application Development
Progress and Forte class of 4GL development environment
some relational database reports, query, etc. processing

Database vendor development environment


Oracle application development (e.g. Oracle Forms, Oracle 9i)

Web Based Application Development


Active Server Page, Java Server Page, WebSphere, etc.

Reusing Components in Prototypes


Integrating a complete application into the prototype
a spreadsheet or a word processor application a database such as Access or SQL a complete legacy application

Integrating individual components within some standard framework


JavaBeans or MS DCOMs (e.g. read mail, save text, etc.) CORBA based application components

S-ar putea să vă placă și