Software Development Life Cycle

The Systems Development Life Cycle (SDLC), or Software Development Life Cycle in
systems engineering, information systems and software engineering, is the process of creating or
altering systems, and the models and methodologies use to develop these systems.

Requirement Analysis and Design

Analysis gathers the requirements for the system. This stage includes a detailed study
of the business needs of the organization. Options for changing the business process may be
considered. Design focuses on high level design like, what programs are needed and how are
they going to interact, low-level design (how the individual programs are going to work),
interface design (what are the interfaces going to look like) and data design (what data will be
required). During these phases, the software's overall structure is defined. Analysis and Design
are very crucial in the whole development cycle. Any glitch in the design phase could be very
expensive to solve in the later stage of the software development. Much care is taken during this
phase. The logical system of the product is developed in this phase.

Implementation

In this phase the designs are translated into code. Computer programs are written using a
conventional programming language or an application generator. Programming tools like
Compilers, Interpreters, and Debuggers are used to generate the code. Different high level
programming languages like C, C++, Pascal, Java, .Net are used for coding. With respect to the
type of application, the right programming language is chosen.

Testing

In this phase the system is tested. Normally programs are written as a series of individual
modules, this subject to separate and detailed test. The system is then tested as a whole. The
separate modules are brought together and tested as a complete system. The system is tested to
ensure that interfaces between modules work (integration testing), the system works on the
intended platform and with the expected volume of data (volume testing) and that the system
does what the user requires (acceptance/beta testing).

Maintenance

Inevitably the system will need maintenance. Software will definitely undergo change once it is
delivered to the customer. There are many reasons for the change. Change could happen because
of some unexpected input values into the system. In addition, the changes in the system could
directly affect the software operations. The software should be developed to accommodate
changes that could happen during the post implementation period.

SDLC METHDOLOGIES

This document play a vital role in the development of life cycle (SDLC) as it describes
the complete requirement of the system. It means for use by developers and will be the basic
during testing phase. Any changes made to the requirements in the future will have to go
through formal change approval process.

SPIRAL MODEL was defined by Barry Boehm in his 1988 article, “A spiral Model of
Software Development and Enhancement. This model was not the first model to discuss
iterative development, but it was the first model to explain why the iteration models.

As originally envisioned, the iterations were typically 6 months to 2 years long. Each
phase starts with a design goal and ends with a client reviewing the progress thus far.
Analysis and engineering efforts are applied at each phase of the project, with an eye toward
the end goal of the project.

The following diagram shows how a spiral model acts like:

The steps for Spiral Model can be generalized as follows:

 A preliminary design is created for the new system.

 A first prototype of the new system is constructed from the preliminary design. This
is usually a scaled-down system, and represents an approximation of the
characteristics of the final product.

 A second prototype is evolved by a fourfold procedure:

1. Evaluating the first prototype in terms of its strengths, weakness, and risks.

2. Defining the requirements of the second prototype.

3. Planning an designing the second prototype.

4. Constructing and testing the second prototype.

 At the customer option, the entire project can be aborted if the risk is deemed too
great. Risk factors might involved development cost overruns, operating-cost
miscalculation, or any other factor that could, in the customer’s judgment, result in a
less-than-satisfactory final product.

 The existing prototype is evaluated in the same manner as was the previous prototype,
and if necessary, another prototype is developed from it according to the fourfold
procedure outlined above.

 The preceding steps are iterated until the customer is satisfied that the refined
prototype represents the final product desired.

 The final system is constructed, based on the refined prototype.

 The final system is thoroughly evaluated and tested. Routine maintenance is carried
on a continuing basis to prevent large scale failures and to minimize down time.