Software Process(part 1)

Introduction

A software process is the set of activities and associated results that produce a software product. Its goal is development or evolution of software. These activities may involve the development of software from a standard programming language like C, C++or Java. Increasingly, however, new software is developed by extending and modifying existing systems and by configuring and integrating off-the-shelf software or system components.(Sommerville SE_book)

There are four fundamental activities which are common to all software process. They are:

• Software Specification: here, customers and engineers define the software to be produced and the constraints on its operation.
• Software Development: here, software is designed and programmed.
• Software Validation: here, software is checked to ensure that the software is the one customer wants.
• Software Evolution: here, the software is modified according to changing customer needs, and changing market and environment.

Software Process Model

A software process model is an abstract representation of a process.Each process model represents a process from a particular perspective and thus, provides only partial information about that process.A process model for software engineering is chosen based on the nature of the project and application, the methods and tools to be used, and the controls and deliverables that are required.(Sommerville SE_book)

WaterFall Model, Evolutionary development, and Reuse-based development models are generic. Generic as well as other software process models are explained below:

WaterFall Model

This model is the first published software process model by Royce in 1970s and also called as sequential model.Because of the cascade from one phase to another, this model is known as waterfall/software life cycle .(Bharatbhusan awarga_lbook) Different phases of waterfall model are explained below:

1. Requirements Definition: The system’s service, constraints and goals are established by consultation with system users. They are often defined in detail and serve as a system specification.
2. System and Software Design:The system design process partitions the requirements to either hardware or software systems. It establishes overall system architecture. Software design involves identifying and describing the fundamental software system abstractions and their relationship.(megaslides)
3. Implementing and Unit Testing:During this stage, the software design is realised as set of programs and program units. Unit testing involves verifying that each unit meets its specification.
4. Integration and System Testing:The individual program units or programs are integrated and tested as a complete system to ensure that the software requirements have been met.(Lucienne T.M. Blessing) After testing, the software system is delivered to the customer.
5. Operation and Maintenace:This is the longest life-cycle phase. The system is installed and put into practical use. Maintenance involves correcting errors which were not discovered earlier stages of the life-cycle, improving the implementation of system units and enhancing the system’s services as new requirements are discovered.(slideshare)

Advantages:

• Easy to understand even by non-technical person, i.e customers.
• Easy to use as software development proceeds,
• Each phase has well-defined inputs and outputs.
• Each stage has well-defined deliverables.
• Helps the project manager in proper planning of the project.

Disadvantages:

• Difficulty of accommodating change after the process is underway because of sequential nature.
• Inflexible partitioning of the project into distinct stages.
• This makes it difficult to respond to changing customer requirements.

Evolutionary Development Model

Evolutionary development is based on the idea of developing an initial implementation, exposing this to user comment and refining it through many versions until an adequate system has been developed.Evolutionary models are iterative. They are characterized in a manner that enables software engineers to develop increasingly more complete versions of the software.Specification, development and validation activities (shown in a figure below) are interleaved rather than separate, with rapid feedback across activities.(Sommerville SE_book)

There are two types of evolutionary development model. They are:

1. Exploratory Development:the objective of the process is to work with the customer to explore their requirements and deliver a final system. The development starts with the parts of the system that are understood. The system evolves by adding new features proposed by the customer.(Sommerville SE_book)
2. Throw-away Prototyping:the objective of the evolutionary development process is to understand the customer’s requirements and hence develop a better requirements definition for the system. The prototype concentrates on experimenting with the customer requirements that are poorly understood.(Sommerville SE_book)

Advantages:

• Often more effective than waterfall approaches in producing systems that meet the immediate needs of customers.
• Specification can be developed incrementally.
• As users develop a better understanding of their problem, this can be reflected in the software system.(slideshare)

Disadvantages:

• The process is not visible: Managers need regular deliverables to measure progress. If systems are developed quickly, it is not cost-effective to produce documents that reflect every version of the system.
• Systems are often poorly structured: Continual change tends to corrupt the software structure.(coursehero) Incorporating software changes becomes increasingly difficult and costly.

Reuse-based Development Model

In the majority of software projects, there is some software reuse. This usually happens informally when people working on the project know of designs or code which is similar to that required. They look for these, modify them as needed and incorporate them into their system. This reuse-oriented approach relies on a large base of reusable software components and some integrating framework for these components.

While the initial requirements specification stage and the validation stage are comparable with other processes, the intermediate stages in a reuse-oriented process are different.(Sommerville SE_book) These intermediate stages are explained below:

1. Requirement Specification:This stage is concerned with the requirement definition and fulfilling it based on the customers needs.
2. Component analysis: Given the requirements specification, a search is made for components to implement that specification. Usually, there is no exact match, and the components that may be used only provide some of the functionality required.(Sommerville SE_book)
3. Requirements modification: During this stage, the requirements are analysed using information about the components that have been discovered. They are then modified to reflect the available components. Where modifications are impossible, the component analysis activity may be re-entered to search for alternative solutions.(slideshare)
4. System design with reuse: During this phase, the framework of the system is designed or an existing framework is reused. The designers take into account the components that are reused and organise the framework to cater to this. Some new software may have to be designed if reusable components are not available.(coursehero)
5. Development and integration: Software that cannot be externally procured is developed, and the components and COTS (commercial off-the-shelf) systems are integrated to create the new system. System integration, in this model, may be part of the development process rather than a separate activity.(Sommerville SE_book)
6. System Validation: This final stage ensures whether the developed software fulfills the both functional and nonfunctional requirements of the customer or not.

Advantages:

• cost effective
• saves time

Disadvantages:

• difficult to turn over
• difficult to design totally new system

Process Iteration

The software process is not a one-off process; rather, the process activities are regularly repeated as the system is reworked in response to change requests.(slideplayer)System requirements always evolve in the course of a project so process iteration where earlier stages are reworked is always part of the process for large systems or software. There are two types of process iteration: Incremental development and spiral development.

Incremental Development

In this iterative process, the software specification, design and implementation are broken down into a series of increments that are each developed in turn.(coursehero)

fi fig.incremental development

In this process, which of the services are most important and which are least important are identified. A number of delivery increments are then defined, with each increment providing a subset of the system functionality. The allocation of services to increments depends on the service priority with the highest priority services delivered first.(Sommerville SE_book)

Once the system increments have been identified, the requirements for the services to be delivered in the first increment are defined in detail, and that increment is developed.

Once increment is completed and delivered, customers can put it into services>they can experiment with the system that helps to clarify their requirements for later increments and for later versions of the current increment. As new increments are completed, they are integrated with existing increments so that the system functionality improves each delivered increment.(coursehero)

(In incremental model, rather than deliver the system as a single delivery, the development and delivery is broken down into increments with each increment delivering part of the required functionality.User requirements are prioritised and the highest priority requirements are included in early increments.Once the development of an increment is started, the requirements are frozen though requirements for later increments can continue to evolve.)(coursehero)

Advantages:

• Customer value can be delivered with each increment so system functionality is available earlier.
• Early increments act as a prototype to help elicit requirements for later increments.
• Lower risk of overall project failure.
• The highest priority system services tend to receive the most testing.

Disadvantages:

• As product is delivered in parts, total development cost is higher.
• Well defined interfaces are required to connect modules developed with each phase.
• Testing of modules also results into overhead and increased cost.

Spiral Development

The spiral model was originally proposed by Boehm in 1988.In this model, process is represented as a spiral rather than as a sequence of activities with backtracking from one activity to another. Each loop in the spiral represents a phase in the process. Risks are explicitly assessed and resolved throughout the process.(slideshare)

Spiral model sectors are explained below:

1. Objective setting: (Specific objectives for the phase are identified)
   In this sector, specific objectives are defined. Constraints on the process and product are identified and a detailed management plan is drawn up. Project risks are identified. Alternative strategies, depending on these risks, may be planned.(slideshare)
2. Risk assessment and reduction: (Risks are assessed and activities put in place to reduce the key risks)
   For each of the identified project risks, a detailed analysis is carried out. Steps are taken to reduce the risk. For example, if there is risk that requirement are inappropriate, a prototype system may be developed.(Sommerville SE_book)
3. Development and validation:
   After risk evaluation, a development model for the system is chosen which can be any generic model. For example. the waterfall model may be the most appropriate development model if the main identified risk is sub-system integration.(Sommerville SE_book)
4. Planning: (The project is reviewed and the next phase of the spiral is planned)
   The project is reviewed and a decision made whether to continue with a further loop of the spiral. If it is decided to continue, plans are drawn up for the next phase of the project.(coursehero)

Advantages:

• The model tries to resolve all possible risks involved in the project starting with the highest risk.
• End users get a chance to see the product early in life cycle.
• With each phase as product is refined after customer feedback, the model ensures a good quality product.
• The model makes use of techniques like reuse, prototyping and component based design.

Disadvantages:

• The model requires expertise in risk management and excellent management skills.
• This model is not suitable for small projects as cost of risk analysis may exceed the actual cost of the project.
• Different persons involved in the project may find it complex to use.

Reference:

• Bharatbhusan awarga_lbook. <https://books.google.com.np/books?id=79Hq5WbyAzkC&pg=PA28&lpg=PA28&dq="of+the+cascade+from+one+phase+to+another,+this+model+is"&source=bl&ots=i5xuUeU46R&sig=6StWsoq_lc8rLkTOX00EOB0FRO4&hl=en&sa=X&redir_esc=y#v=onepage&q="of the cascade from >.</li> <li><u>coursehero.</u> <https://www.coursehero.com/file/11487611/Chapter1-Introduction-to-Software-Engineering-cs/>.</li> <li>Lucienne T.M. Blessing, Amaresh Chakrabarti. "books.google.com.np." <https://books.google.com.np/books?id=KdR4OmWtQdIC&pg=PA285&lpg=PA285&dq="Integration+and+System+Testing:The+individual+program+units"&source=bl&ots=Ods5MNNhK1&sig=yc8bwPui5zz4R9VFmsGhwd5JAI0&hl=en&sa=X&redir_esc=y#v=onepage&q="Integration and Sy>.
• megaslides. <http://megaslides.com/doc/4085310/-process-models->.
• slideplayer. <http://slideplayer.com/slide/3890762/>.
• slideshare. <http://www.slideshare.net/raheelaslam9237/software-engineering-process>.
• Sommerville, Ian. Software engineering. eight edition. Newyork: pearson, 2007.