What is SDLC model and its Phases

Software Development Life Cycle (SDLC) is a frame work that defines activity that are
performed during software development process.
There are 6 phases in SDLC model as given below.

1. Requirement:
In this phase all the requirement are collected from customer/client. They are provided in a
document called Businessmen requirement specification (BRS) and System requirement
specification (SRS). All the detail are discuss with customer/client in detail.
2. Design:
It has two steps:

• (a). High level design (HLD): It give the architecture of software product.
• (b). Low level design (LLD): It describe how each and every feature in the product
should work and every component.
3. Implementation:
• This is the longest phase.
• This phase consists of Front end + Middle ware + Back-end
• In font end: development coding are done even SEO setting are done
• In Middle ware: They connect both font end and back end
• In back-end: database is created
4. Testing:
Testing is carried out to verify the entire system. The aim of the tester is to find out the gaps and
defects within the system and also to check whether the system is running according to the
requirement of the customer/client.
5. Deployment:
After successful testing the product is delivered/deployed to the client, even client are trained
how to use the product.
6. Maintenance:
Once the product has been delivered to the client a task of maintenance start as when the client
will come up with an error the issue should be fixed from time to time.
Attention reader! Don’t stop learning now. Get hold of all the important CS Theory concepts for
SDE interviews with the CS Theory Course at a student-friendly price and become industry
ready.

Benefits of software development life cycle :

1. It allowed the highest level of management control.
2. Everyone understands the cost and resources required.
3. To improve the application quality and monitor the application.
4. It performs at every stage of the software development life cycle.

Different types of software development life cycle models :

Waterfall model –
The waterfall model is easy to understand and simple to manage. The whole process of
software development is divided into various phases. The step of requirements analysis,
integration, maintenance.

Let us now learn about each of these phases in brief details:

Advantages of Classical Waterfall Model

• This model is very simple and is easy to understand.
• Phases in this model are processed one at a time.
• Each stage in the model is clearly defined.
• This model has very clear and well understood milestones.
• Process, actions and results are very well documented.
• Reinforces good habits: define-before- design,
design-before-code.
• This model works well for smaller projects and projects where requirements are
well
understood.
Drawbacks of Classical Waterfall Model
• No feedback path
• Difficult to accommodate change requests
• No overlapping of phases
Iterative model –
It is repetition incarnate. In short, it is breaking down the software development of large
applications into smaller pieces.
The iterative waterfall model provides feedback paths from every phase to its
preceding phases, which is the main difference from the classical waterfall model.

Feedback paths introduced by the iterative waterfall model are shown in the figure below.

Advantages of Iterative Waterfall Model

• Feedback Path
• Simple: Iterative waterfall model is very simple to understand and use. That’s why it
is one of the most widely used software development models.
Drawbacks of Iterative Waterfall Model
• Difficult to incorporate change requests: The major drawback of the iterative
waterfall model is that all the requirements must be clearly stated before starting of
the development phase.
• Incremental delivery not supported: In the iterative waterfall model, the full
software is completely developed and tested before delivery to the customer.
• Overlapping of phases not supported: Iterative waterfall model assumes that one
phase can start after completion of the previous phase, But in real projects, phases
may overlap to reduce the effort and time needed to complete the project.
• Risk handling not supported: Projects may suffer from various types of risks. But,
Iterative waterfall model has no mechanism for risk handling.
• Limited customer interactions

Incremental process
Incremental process model is also know as Successive version model.
First, a simple working system implementing only a few basic features is built and then that
is delivered to the customer. Then thereafter many successive iterations/ versions are
implemented and delivered to the customer until the desired system is released.
A, B, C are modules of Software Product that are incrementally developed and delivered.

As each successive version of the software is constructed and delivered, now the feedback
of the Customer is to be taken and these were then incorporated in the next version. Each
version of the software have more additional features over the previous ones.

After Requirements gathering and specification, requirements are then spitted into several
different versions starting with version-1, in each successive increment, next version is
constructed and then deployed at the customer site. After the last version (version n), it is
now deployed at the client site.
When to use this –
1. Funding Schedule, Risk, Program Complexity, or need for early realization of
benefits.
2. When Requirements are known up-front.

3. When Projects having lengthy developments schedules.

4. Projects with new Technology.
Advantages –
• Error Reduction (core modules are used by the customer from the
beginning of the phase and then these are tested thoroughly)
• Uses divide and conquer for breakdown of tasks.
• Lowers initial delivery cost.
• Incremental Resource Deployment.
Disadvantages –
• Requires good planning and design.
• Total cost is not lower.
• Well defined module interfaces are required.

Spiral Model
Spiral model is one of the most important Software Development Life Cycle models, which
provides support for Risk Handling. In its diagrammatic representation, it looks like a spiral
with many loops. The exact number of loops of the spiral is unknown and can vary from
project to project. Each loop of the spiral is called a Phase of the software development
process.
The below diagram shows the different phases of the Spiral Model: –

Advantages of Spiral Model:

1. Risk Handling: The projects with many unknown risks that occur as the development
proceeds, in that case, Spiral Model is the best development model to follow due to
the risk analysis and risk handling at every phase.
1. Good for large projects: It is recommended to use the Spiral Model in large and
complex projects.
2. Flexibility in Requirements: Change requests in the Requirements at later phase
can be incorporated accurately by using this model.
3. Customer Satisfaction: Customer can see the development of the product at the
early phase of the software development and thus, they habituated with the
system by using it before completion of the total product.
Disadvantages of Spiral Model:

Below are some main disadvantages of the spiral model.

1. Complex: The Spiral Model is much more complex than other SDLC models.
2. Expensive: Spiral Model is not suitable for small projects as it is expensive.
3. Too much dependability on Risk Analysis: The successful completion of the
project is very much dependent on Risk Analysis. Without very highly experienced
experts, it is going to be a failure to develop a project using this model.
4. Difficulty in time management: As the number of phases is unknown at the start
of the project, so time estimation is very difficult.

Rapid application development model (RAD)

The Rapid Application Development Model was first proposed by IBM in 1980’s. The critical
feature of this model is the use of powerful development tools and techniques.
A software project can be implemented using this model if the project can be broken down
into small modules wherein each module can be assigned independently to separate teams.
These modules can finally be combined to form the final product.
Development of each module involves the various basic steps as in waterfall model i.e
analyzing, designing, coding and then testing, etc. as shown in the figure.
Another striking feature of this model is a short time span i.e the time frame for
delivery(time-box) is generally 60-90 days.

The use of powerful developer tools such as JAVA, C++, Visual BASIC, XML, etc. is also an
integral part of the projects.
Advantages –
• Use of reusable components helps to reduce the cycle time of the project.
• Feedback from the customer is available at initial stages.
• Reduced costs as fewer developers are required.
• Use of powerful development tools results in better quality products in
comparatively shorter time spans.
• The progress and development of the project can be measured through the
various stages.
• It is easier to accommodate changing requirements due to the short iteration time
spans.

Disadvantages –
• The use of powerful and efficient tools requires highly skilled professionals.
• The absence of reusable components can lead to failure of the project.
• The team leader must work closely with the developers and customers to close the
project in time.
• The systems which cannot be modularized suitably cannot use this model.
• Customer involvement is required throughout the life cycle.
• It is not meant for small scale projects as for such cases, the cost of using
automated tools and techniques may exceed the entire budget of the project.

Agile Development Models

The Agile model was primarily designed to help a project to adapt to change requests
quickly. So, the main aim of the Agile model is to facilitate quick project completion. To
accomplish this task agility is required. Agility is achieved by fitting the pro cess to the
project, removing activities that may not be essential for a specific project. Also, anything
that is wastage of time and effort is avoided.
Advantages:
 • Working through Pair programming produce well written compact programs which
has fewer errors as compared to programmers working alone.
• It reduces total development time of the whole project.
• Customer representatives get the idea of updated software products after each
iteration. So, it is easy for him to change any requirement if needed.
Disadvantages:
• Due to lack of formal documents, it creates confusion and important decisions
taken during different phases can be misinterpreted at any time by different team
members.
• Due to the absence of proper documentation, when the project completes and the
developers are assigned to another project, maintenance of the developed project
can become a problem.
Coupling and Cohesion
Coupling: Coupling is the measure of the degree of interdependence between the
modules. A good software will have low coupling.

Types of Coupling:

• Data Coupling: If the dependency between the modules is based on the fact that
they communicate by passing only data, then the modules are said to be data
coupled. In data coupling, the components are independent to each other and
communicating through data. Module communications don’t contain tramp data.
Example-customer billing system.
• Stamp Coupling In stamp coupling, the complete data structure is passed from
one module to another module. Therefore, it involves tramp data. It may be
necessary due to efficiency factors- this choice made by the insightful designer,
not a lazy programmer.
• Control Coupling: If the modules communicate by passing control information,
then they are said to be control coupled. It can be bad if parameters indicate
completely different behavior and good if parameters allow factoring and reuse of
functionality. Example- sort function that takes comparison function as an
argument.
• External Coupling: In external coupling, the modules depend on other modules,
external to the software being developed or to a particular type of hardware. Ex-
protocol, external file, device format, etc.
• Common Coupling: The modules have shared data such as global data
structures. The changes in global data mean tracing back to all modules which
access that data to evaluate the effect of the change. So it has got disadvantages
 like difficulty in reusing modules, reduced ability to control data accesses and
reduced maintainability.
• Content Coupling: In a content coupling, one module can modify the data of
another module or control flow is passed from one module to the other module.
This is the worst form of coupling and should be avoided.
Cohesion: Cohesion is a measure of the degree to which the elements of the module are
functionally related. It is the degree to which all elements directed towards performing a
single task are contained in the component. Basically, cohesion is the internal glue that
keeps the module together. A good software design will have high cohesion.

Types of Cohesion:

• Functional Cohesion: Every essential element for a single computation is

contained in the component. A functional cohesion performs the task and
functions. It is an ideal situation.
• Sequential Cohesion: An element outputs some data that becomes the input for
other element, i.e., data flow between the parts. It occurs naturally in functional
programming languages.
• Communicational Cohesion: Two elements operate on the same input data or
contribute towards the same output data. Example- update record in the database
and send it to the printer.
• Procedural Cohesion: Elements of procedural cohesion ensure the order of
execution. Actions are still weakly connected and unlikely to be reusable. Ex-
calculate student GPA, print student record, calculate cumulative GPA, print
cumulative GPA.
• Temporal Cohesion: The elements are related by their timing involved. A module
connected with temporal cohesion all the tasks must be executed in the same
time-span. This cohesion contains the code for initializing all the parts of the
system. Lots of different activities occur, all at unit time.
• Logical Cohesion: The elements are logically related and not functionally. Ex- A
component reads inputs from tape, disk, and network. All the code for these
functions is in the same component. Operations are related, but the functions are
significantly different.
• Coincidental Cohesion: The elements are not related(unrelated). The elements
have no conceptual relationship other than location in source code. It is accidental
and the worst form of cohesion. Ex- print next line and reverse the characters of a
string in a single component.
Black box testing
Black box testing is a type of software testing in which the functionality of the software is not
known. The testing is done without the internal knowledge of the products.
White box Testing
White box testing techniques analyze the internal structures the used data structures, internal
design, code structure and the working of the software rather than just the functionality as in
black box testing. It is also called glass box testing or clear box testing or structural testing.