Featured

    Featured Posts

The concept of Software Process and Iterative enhancement model.

Software Process :

       The software process is the set of activities and associated results that produce a software product.  Software engineers mostly carry out these activities.
       The following are the fundamental process activities that are common to all software processes :

  • Software Specification : The functionality of the software and constraints on its operation must be defined.
  • Software Development : The software must be developed that meets the specifications.
  • Software Validation : The software must be validated to ensure that it performs what the customer needs.
  • Software Evolution : The software must evolve to meet changing customer requirements.
      The following are the software process characteristics :

  • Understand-ability : To what extent is the process explicitly defined and how easy is it to understand the process definition ?
  • Visibility : Do the process activities culminate in clear results so that the progress of the process is extremely visible?
  • Robustness : Can the process continue in spite of unexpected problems ?
  • Reliability : Is the process designed in such a way that process errors are avoided or trapped before they result in product errors ?
  • Acceptability : Is the defined process acceptable to and usable by the engineers responsible for producing the software product ?
  • Maintainability : Can the process evolve to reflect changing organizational requirements or identified process improvements ?
  • Rapidity : How fast can the process of delivering a system from a given specification be competed.
  • Supportability :  To what extent can CASE tools support the process activities ?

(b) Iterative enhancement model : 

The iterative enhancement life cycle model counters the third limitation of the waterfall model and tries to combine the benefits of both prototyping and the waterfall model.  The basic idea is that the software should be developed in increments, where each increment adds some functional capability to the system until the full system is implemented.  At each step extensions and design modifications can be made.
      An advantage of this approach is that it can result in better testing, since testing each increment is likely to be easier than testing entire system like in the waterfall model.  Furthermore, as in prototyping, the increments provide feedback to the client which is useful for determining the final requirements of the system.
     An iterative life cycle model is that consists of repeating the following four phases in sequence, see the figure below

figure :


  • A Requirement phase, in which the requirements for the software are gathered and analysed.  Iteration should eventually result in a requirements phase that produces a complete and final specification of requirements.
  • A Design phase, in which a software solution to meet the requirements is designed.  This may be a new design, or an extension of an earlier design.
  • An Implementation and test phase, when the software is coded, integrated and tested.
  • A Review phase, in which the software is evaluated, the current requirements are reviewed, and changes and additions to the requirements proposed.


For each cycle of the model, a decision has to be made to whether the software produced by the cycle will be discarded, or kept as a starting point for the next cycle (sometimes referred to as incremental prototyping).  Eventually a point will be reached where the requirements are complete and the software can be delivered, or it becomes impossible to enhance the software as required, and a fresh start has to be made.  The iterative life cycle model can be likened to produce software by successive approximation.  Drawing an analogy with mathematical methods that use successive approximation to arrive at a final solution, the benefit of such methods depends on how rapidly they converge on a solution. The key to successful use of an iterative software development life cycle is rigorous validation of requirements, and verification of each version of the software against those requirements within each cycle of the model.

       Each cycle of the model produces software that requires testing at the unit level, for software integration, for system integration and for acceptance.  As the software evolves through successive cycles, tests have to be repeated and executed to verify each version of the software.
      Example : Iterative development process model used by IBM Owego, New York.  With the purpose of building a system by evolving an architectural prototype through a series of executable versions, with each successive iteration incorporating experience and more system functionality, the example implementation contains eight major steps. The steps are:

  • Domain analysis
  • Requirements definition
  • Software architecture
  • Risk analysis
  • Prototype
  • Test suite and environment development
  • Integration with previous iterations
  • Release of iteration

 

Post a Comment

www.CodeNirvana.in

www.posthatke.com. Powered by Blogger.

Google+ Followers

Copyright © www.posthatke.com | Blogger Templates | Designed By posthatke.com