SOFTWARE DEVELOPMENT LIFE CYCLE

Software Development Life Cycle (SDLC) is a well-defined, structured sequence of stages in

software engineering to develop the intended software product. A software life cycle model (also
called process model) is a descriptive and diagrammatic representation of the software life cycle.
A life cycle model represents all the activities required to make a software product transit through
its life cycle phases. It also captures the order in which these activities are to be undertaken. In
other words, a life cycle model maps the different activities performed on a software product from
its inception to retirement. Different life cycle models may map the basic development activities
to phases in different ways. Thus, no matter which life cycle model is followed, the basic
activities are included in all life cycle models though the activities may be carried out in different
orders in different life cycle models. During any life cycle phase, more than one activity may also
be carried out.
Point to note
Note: SDLC is a framework or methodology that defines the various stages involved in software
development. It's the overarching concept that covers the different approaches (including Classical
Waterfall) to guide the development process. SDLC is thus the overall process that governs how
software is developed, and Waterfall is just one specific model under SDLC. Waterfall is linear,
while SDLC includes other models like Agile, Spiral, V-Model, etc.

Different software life cycle models

Many life cycle models have been proposed so far. Each of them has some advantages as well as
some disadvantages. A few important and commonly used life cycle models are as follows:
 Classical Waterfall Model

 Iterative Waterfall Model

 Prototyping Model
 Evolutionary Model
 Spiral Model

SDLC ACTIVITIES
SDLC provides a series of steps to be followed to design and develop a software product
efficiently. SDLC framework includes the following steps:
 Fig 1: SDLC framework
Communication
This is the first step where the user initiates the request for a desired software product. He
contacts the service provider and tries to negotiate the terms. He submits his request to the
service providing organization in writing.

Requirement Gathering
This step onwards the software development team works to carry out the project. The team
holds discussions with various stakeholders from problem domain and tries to bring out as
much information as possible on their requirements. The requirements are contemplated and
segregated into user requirements, system requirements and functional requirements. The
requirements are collected using a number of practices as given -

 studying the existing or obsolete system and software

 conducting interviews of users and developers
 referring to the database
 collecting answers from the questionnaires.
Feasibility Study
After requirement gathering, the team comes up with a rough plan of software process. At this
step the team analyzes if the software can be made to fulfill all requirements of the user and if
there is any possibility of the software being no more useful. If the project is financially,
practically and technologically feasible for the organization to take up, they take up the project
else they let it go.

System Analysis

At this step the developers decide a roadmap of their plan and try to bring up the best software
model suitable for the project. System analysis includes understanding of software product
limitations, learning system related problems or changes to be done in existing systems
beforehand, identifying and addressing the impact of project on organization and personnel etc.
The project team analyzes the scope of the project and plans the schedule and resources
accordingly.

Software Design
Next step is to bring down whole knowledge of requirements and analysis on the desk and
design the software product. The inputs from users and information gathered in requirement
gathering phase are the inputs of this step. The output of this step comes in the form of two
designs; logical design and physical design. Engineers produce meta-data and data dictionaries,
logical diagrams, data-flow diagrams and in some cases pseudo codes.

Coding
This step is also known as programming phase. The implementation of software design starts in
terms of writing program code in the suitable programming language and developing error-free
executable programs efficiently.

Testing
An estimate says that 50% of whole software development process should be tested. Errors may
ruin the software from critical level to its own removal. Software testing is done while coding
by the developers and thorough testing is conducted by testing experts at various levels of code
such as module testing, program testing, product testing, in-house testing and testing the
product at user’s end. Early discovery of errors and their remedy is the key to reliable software.

Integration
Software may need to be integrated with the libraries, databases and other program(s). This
stage of SDLC is involved in the integration of software with outer world entities.

Implementation
This means installing the software on user machines. At times, software needs post-installation
configurations at user end. Software is tested for portability and adaptability and integration
related issues are solved during implementation.
Operation and Maintenance
This phase confirms the software operation in terms of more efficiency and less errors. If
required, the users are trained on, or aided with the documentation on how to operate the
software and how to keep the software operational. The software is maintained timely by
updating the code according to the changes taking place in user end environment or technology.
This phase may face challenges from hidden bugs and real-world unidentified problems.

Disposition
As time elapses, the software may decline on the performance front. It may go completely
obsolete or may need intense up gradation. Hence a pressing need to eliminate a major portion
of the system arises. This phase includes archiving data and required software components,
closing down the system, planning disposition activity and terminating system at appropriate
end-of-system time.

The Need for a Software Life Cycle Model

A Software Development Life Cycle (SDLC) model is essential for guiding the systematic
development of software from the initial concept to its deployment and ongoing maintenance.
Below are several reasons why a life cycle model is crucial in software engineering:

1. Structured Development Process

 Organized Approach: The SDLC provides a structured framework for software

development, breaking down the complex task of software creation into manageable
phases. Each phase focuses on a specific set of activities, such as requirements gathering,
design, coding, testing, and maintenance.

 Clarity and Focus: With distinct phases, each team knows what tasks to focus on,
ensuring that resources are allocated efficiently and no critical steps are missed.

2. Project Planning and Management

 Timeline and Milestones: The SDLC model helps project managers create clear timelines
and define project milestones. This helps teams stick to deadlines and track the progress of
the project, ensuring timely delivery.

 Budget Management: With a well-defined model, it is easier to estimate costs at each

phase, manage the budget effectively, and avoid overruns.

 Risk Management: A structured life cycle helps in identifying and addressing potential
risks early in the development process, reducing the likelihood of costly surprises later on.

3. Improved Quality of Software

  Systematic Testing: Most SDLC models incorporate various forms of testing at different
stages, ensuring that errors and defects are identified and fixed early. This leads to higher-
quality software and reduces the chance of critical failures in later stages.

 Continuous Feedback: Models like Agile, Iterative, and Prototyping incorporate

feedback loops, allowing developers to refine the product based on user feedback and
testing results throughout the process.

4. Better Requirement Management

 Clear Understanding of Requirements: The early stages of most SDLC models (like the
Waterfall model’s requirements phase or Agile's sprint planning) focus on gathering,
analyzing, and validating the software’s requirements. This ensures that the final product
meets user needs and expectations.

 Handling Changing Requirements: Iterative models like Agile or the Spiral model allow
for flexibility, making it easier to incorporate changes in requirements during the
development process.

5. Improved Communication and Collaboration

 Defined Roles and Responsibilities: Each phase of the SDLC model involves different
teams (e.g., developers, testers, business analysts), making it clear who is responsible for
what. This reduces confusion and encourages collaboration across teams.

 Customer Involvement: Many models, like Agile or Prototyping, emphasize continuous

customer feedback, improving communication between the developers and the end-users
and ensuring that the product meets expectations.

6. Risk Management and Mitigation

 Early Risk Identification: Models like the Spiral SDLC are specifically designed to
address risks throughout the software development process. By identifying potential risks
(technical, financial, or operational) in early stages, they help reduce the chances of major
failures.

 Phased Development: Breaking the project into smaller phases helps in risk mitigation, as
issues in earlier stages can be resolved without impacting the entire project.

7. Efficient Resource Allocation

 Team Coordination: The SDLC model provides a roadmap for development, allowing
resources such as personnel, time, and tools to be allocated according to the needs of each
phase.
  Avoiding Bottlenecks: With clear roles and milestones, resources are better managed,
reducing the likelihood of bottlenecks in production that can delay progress.

8. Maintenance and Support

 Systematic Maintenance: After deployment, many SDLC models have built-in processes
for maintenance and support, ensuring that any bugs, updates, or new features can be
addressed efficiently.

 Ongoing Evolution: Models like Agile and Evolutionary support the continuous evolution
of the software, adapting to new business needs or technology changes.

9. Adaptability to Project Size and Complexity

 Scalability: Different SDLC models are suitable for projects of varying sizes and
complexities. For example, the Classical Waterfall model might work well for small,
straightforward projects, while more flexible models like Agile are better suited for large,
dynamic projects.

 Handling Complexity: A life cycle model helps break down complex projects into
smaller, manageable parts, making it easier to track progress, manage changes, and ensure
success.

10. Consistency and Repeatability

 Standardization: A defined SDLC model establishes best practices and processes that can
be reused across multiple projects. This helps ensure consistency in how software is
developed, reducing variability and improving quality across the organization.

 Repeatable Processes: When a successful model is used consistently, it creates repeatable

processes that can be applied to future projects, making the development process more
predictable and reliable.

11. Ensuring Systematic and Disciplined Development

 Prevents Chaos and Ensures Coordination: A software life cycle model provides a
structured approach for team members, ensuring that everyone works in harmony. Without
such a model, team members may follow inconsistent approaches—one might start with
coding, another with testing, and another with design—leading to confusion and ultimately
project failure.

 Clear Task Assignment and Understanding: When a life cycle model is followed, each
phase has clear entry and exit criteria. This allows all team members to understand when
they should start and finish their tasks, ensuring smooth transitions between phases.
 12. Entry and Exit Criteria

 Definition of Phase Boundaries: Each phase in a life cycle model has specific entry and
exit criteria that must be satisfied before moving to the next phase. This enforces
discipline and ensures that no phase is skipped or started prematurely, reducing the
chances of errors propagating through the development process.

 Quality Assurance: The well-defined boundaries ensure that phases such as design,
coding, and testing are completed with the necessary checks, which improves the overall
quality of the product and avoids rework later.

The need for an SDLC model arises from the desire to bring structure, organization, and
predictability to the software development process. A well-defined life cycle model enhances
project management, improves communication, ensures quality, mitigates risks, and enables
adaptability, ultimately leading to the successful delivery of high-quality software. Without a
software life cycle model, the development process would lack discipline, coordination, and
structure. By providing a clear roadmap, setting defined criteria for phases, and enabling effective
progress monitoring, the SDLC model ensures that the project stays on track and meets its goals
in a systematic and efficient manner. This ultimately leads to a higher chance of success for
software projects.

SOFTWARE DEVELOPMENT METHODOLOGY PARADIGM

The software development paradigm helps developer to select a strategy to develop the
software. A software development paradigm has its own set of tools, methods and procedures,
which are expressed clearly and defines software development life cycle. A few of software
development paradigms or process models are defined as follows:

CLASSICAL WATERFALL MODEL

Classical waterfall model is the simplest model of software development paradigm. It says the
all the phases of SDLC will function one after another in linear manner. That is, when the first
phase is finished then only the second phase will start and so on. The model is called “waterfall”
because the flow is strictly downward through the phases of the project.

Fig 2: Waterfall Model

This model assumes that everything is carried out and taken place perfectly as planned in the
previous stage and there is no need to think about the past issues that may arise in the next
phase. This model does not work smoothly if there are some issues left at the previous step. The
sequential nature of model does not allow us go back and undo or redo our actions.

This model is best suited when developers already have designed and developed similar
software in the past and is aware of all its domains.
 Advantages:
 Simple to understand and use.
 Works well for small projects with well-defined requirements.
 Easy to manage due to its linear structure.
 Disadvantages:
 Inflexible; difficult to accommodate changes once the project is underway.
 No feedback or revisions possible once a phase is completed.
 Delayed testing and late discovery of issues since testing occurs only after the
implementation phase.

ITERATIVE WATERFALL MODEL

This model leads the software development process in iterations. It is a variation of the
Classical Waterfall, allowing for feedback loops between phases. It projects the process of
development in cyclic manner repeating every step after every cycle of SDLC process. This
means that after completing one phase, you can return to previous phases if changes are needed.
However, it still follows a largely sequential flow. Stages: Same as the Classical Waterfall but
with feedback loops.
 Fig 3: Iterative Model
The software is first developed on very small scale and all the steps are followed which are
taken into consideration. Then, on every next iteration, more features and modules are designed,
coded, tested and added to the software. Every cycle produces a software, which is complete in
itself and has more features and capabilities than that of the previous one.
After each iteration, the management team can do work on risk management and prepare for the
next iteration. Because a cycle includes small portion of whole software process, it is easier to
manage the development process but it consumes more resources.
 Advantages
 More flexible than the Classical Waterfall model, allowing for minor adjustments and
corrections after each phase.
 Reduces risk by allowing revisions at certain stages before moving forward.
 Disadvantages
 Still somewhat rigid; large-scale changes are difficult to implement.
 Iterations can increase time and cost if too many revisions are needed.

PROTOTYPING MODEL

A prototype is a toy implementation of the system. A prototype usually exhibits limited

functional capabilities, low reliability, and inefficient performance compared to the actual
software. A prototype is usually built using several shortcuts. The shortcuts might involve using
inefficient, inaccurate, or dummy functions. The shortcut implementation of a function, for
example, may produce the desired results by using a table look-up instead of performing the
actual computations. A prototype usually turns out to be a very crude version of the actual
system.

Following is the stepwise approach to design a software prototype:

1. Basic Requirement Identification: This step involves understanding the very basic
product requirements, especially in terms of user interface. The more intricate details of
the internal design and external aspects like performance and security can be ignored at
 this stage.
2. Developing the initial Prototype: The initial Prototype is developed in this stage, where
the very basic requirements are showcased and user interfaces are provided. These
features may not exactly work in the sam0 e manner internally in the actual software
developed and the workarounds are used to give the same look and feel to the customer in
the prototype developed.
3. Review of the Prototype: The prototype developed is then presented to the customer and
the other important stakeholders in the project. The feedback is collected in an organized
manner and used for further enhancements in the product under development.
4. Revise and enhance the Prototype: The feedback and the review comments are discussed
during this stage and some negotiations happen with the customer based on factors like,
time and budget constraints and technical feasibility of actual implementation. The
changes accepted are again incorporated in the new Prototype developed and the cycle
repeats until customer expectations are met.
5. Final Product

Fig 4: Prototype Model

 Advantages:
 Helps clarify vague or incomplete requirements by showing users a working model
early on.
 Encourages early user involvement and feedback.
 Reduces misunderstandings between developers and users.
 Disadvantages:
 Building prototypes can be time-consuming and costly.
 There’s a risk that the prototype might be mistaken for the final product, leading to
incomplete features or quality issues.
 Changes made after feedback can lead to scope creep.

EVOLUTIONARY MODEL
It is also called successive versions model or incremental model. At first, a simple working model is
built. Subsequently it undergoes functional improvements & we keep on adding new functions till the
desired system is built.
Applications:
 Large projects where you can easily find modules for incremental implementation. Often used
when the customer wants to start using the core features rather than waiting for the full
software.
 Also used in object oriented software development because the system can be easily portioned
into units in terms of objects.

Advantages:
 User gets a chance to experiment partially developed system
 Reduce the error because the core modules get tested thoroughly.

Disadvantages:
 It is difficult to divide the problem into several versions that would be acceptable to the
customer which can be incrementally implemented & delivered.

SPIRAL MODEL

The Spiral model of software development is shown in fig.5. The diagrammatic representation of
this model appears like a spiral with many loops. The exact number of loops in the spiral is not
fixed. Each loop of the spiral represents a phase of the software process. For example, the
innermost loop might be concerned with feasibility study. The next loop with requirements
specification, the next one with design, and so on. Each phase in this model is split into four
sectors (or quadrants) as shown in the fig.5. The following activities are carried out during each
phase of a spiral model.
 Fig 5: Spiral Model

- First quadrant (Objective Setting)

• During the first quadrant, it is needed to identify the objectives of the phase.
• Examine the risks associated with these objectives.
- Second Quadrant (Risk Assessment and Reduction)
• A detailed analysis is carried out for each identified project risk.
• Steps are taken to reduce the risks. For example, if there is a risk that the requirements
are inappropriate, a prototype system may be developed.
- Third Quadrant (Development and Validation)
• Develop and validate the next level of the product after resolving the identified risks.
- Fourth Quadrant (Review and Planning)
• Review the results achieved so far with the customer and plan the next iteration around
the spiral.
• Progressively more complete version of the software gets built with each iteration
around the spiral.
Advantages
 Focus on risk assessment and management makes it ideal for large, complex projects.
 Flexibility to incorporate changes and additional features in each loop.
 Strong emphasis on early identification of risks.
Disadvantages
 Risk analysis requires specialized expertise, which may increase project costs.
 The model can be expensive and time-consuming due to multiple iterations.
 Can be difficult to manage for smaller projects.
Circumstances to use spiral model
The spiral model is called a meta model since it encompasses all other life cycle models. Risk
handling is inherently built into this model. The spiral model is suitable for development of
technically challenging software products that are prone to several kinds of risks. However, this model
is much more complex than the other models – this is probably a factor deterring its use in ordinary
projects.
AGILE MODEL
The Agile Model focuses on iterative and incremental development, prioritizing customer
collaboration, rapid delivery of functional software, and the ability to adapt to changing requirements.
Instead of delivering a final product at the end, Agile delivers small, usable increments of the product
at regular intervals (called sprints or iterations).Stages: Iterations (each including Planning,
Development, Testing, and Review) → Continuous delivery.

Advantages:
 High adaptability to changing requirements and customer needs.
 Continuous feedback and collaboration with customers ensure a product that aligns with user
needs.
 Short development cycles allow for faster delivery of functional software.
Disadvantages:
 Requires close collaboration between developers and customers, which can be resource-intensive.
 Documentation may be less detailed due to focus on rapid delivery.
 Can be difficult to scale for larger projects if not properly managed.
DEVOPS MODEL
The DevOps model integrates development (Dev) and operations (Ops) teams, emphasizing
collaboration between the two to automate and streamline the processes of software development and
IT operations. DevOps promotes continuous integration and delivery, with the goal of releasing
software faster and with higher quality. Stages: Continuous development → Continuous integration
→ Continuous testing → Continuous deployment → Continuous monitoring.
Advantages:
 Reduces time to market through automation and faster releases.
 Promotes a culture of collaboration between developers and operations teams.
 Improves software quality by ensuring that the development and operational environments are
aligned.
Disadvantages:
 May require significant changes to organizational structure and processes.
 Requires a high degree of automation, which can be costly and complex to implement.
 Not ideal for smaller teams or projects that don’t need frequent updates or releases.
V-MODEL (VERIFICATION AND VALIDATION MODEL)
The V-Model is a sequential development model that places equal emphasis on development and
testing phases. For each development phase, there is a corresponding testing phase. The model is
represented in a V shape, with the left side focusing on development and the right side on testing,
ensuring validation at every step. Stages: Requirements → Design → Coding → Testing (unit,
integration, system, and acceptance) → Maintenance.

Advantages:
 Early identification of defects due to continuous testing throughout the development lifecycle.
 Clear focus on verification and validation, ensuring higher quality.
 Each development phase has a corresponding testing phase, so issues are caught early.
Disadvantages:
 Like the Waterfall model, it is rigid and does not handle changes well.
 Inflexibility makes it less suited to projects where requirements may evolve.
 Can be time-consuming due to the emphasis on testing at every phase

REQUIREMENT ANALYSIS & SPECIFICATION

The software requirements are description of features and functionalities of the target system.
Requirements convey the expectations of users from the software product. The requirements
can be obvious or hidden, known or unknown, expected or unexpected from client’s point of
view.

Before we start to develop our software, it becomes quite essential for us to understand and
document the exact requirement of the customer. Experienced members of the development
team carry out this job. They are called as system analysts. The analyst starts requirements
gathering and analysis activity by collecting all information from the customer which could be
used to develop the requirements of the system. He then analyses the collected information to
obtain a clear and thorough understanding of the product to be developed, with a view to
remove all ambiguities and inconsistencies from the initial customer perception of the problem.
The following basic questions pertaining to the project should be clearly understood by the
analyst in order to obtain a good grasp of the problem:
• What is the problem?
• Why is it important to solve the problem?
 • What are the possible solutions to the problem?
• What exactly are the data input to the system and what exactly are the data output by the
system?
• What are the likely complexities that might arise while solving the problem?
• If there are external software or hardware with which the developed software has to
interface, then what exactly would the data interchange formats with the external system
be?
After the analyst has understood the exact customer requirements, he proceeds to identify and
resolve the various requirements problems. The most important requirements problems that the
analyst has to identify and eliminate are the problems of anomalies, inconsistencies, and
incompleteness. When the analyst detects any inconsistencies, anomalies or incompleteness in
the gathered requirements, he resolves them by carrying out further discussions with the end-
users and the customers.
Parts of a SRS document
The important parts of SRS document are:
 Functional requirements of the system
 Non-functional requirements of the system, and
 Goals of implementation
Types of Requirements
1. Functional Requirements
These define what the system should do. These are specific functionalities or services the system
must provide. Examples include: user authentication, payment processing, report generation.
2. Non-Functional Requirements
Define how the system should perform. These include attributes such as performance, usability,
security, and scalability. Examples include: system should handle 1000 transactions per second,
response time should be less than 2 seconds, the system should be available 99.9% of the time.

REQUIREMENT ENGINEERING
The process to gather the software requirements from client, analyze and document them is
known as requirement engineering. The goal of requirement engineering is to develop and
maintain sophisticated and descriptive ‘System Requirements Specification’ document.

Importance of the Requirement Engineering Process

 Improved Communication- Requirement engineering ensures that all stakeholders have a

shared understanding of the goals and expectations for the system, leading to better
communication and fewer misunderstandings.

 Reduced Project Risks - By systematically gathering and analyzing requirements, potential

risks are identified early, allowing for better planning and mitigation strategies.

 Better Resource Management - A clear understanding of requirements helps project

 managers allocate the right resources and estimate timelines more accurately.

 Increased Project Success - Well-defined and validated requirements lead to fewer

changes, minimizing rework and ensuring that the final product aligns with stakeholder
needs.

 Traceability and Accountability - Requirement traceability ensures that each feature can
be traced back to a specific requirement, making it easier to track progress and
accountability throughout the project life cycle.

 Ensures Quality - Validating requirements against stakeholder expectations guarantees that

the developed system will be of high quality and meet the necessary standards.

Challenges in Requirement Engineering

1. Changing Requirements: Stakeholders may change their needs or priorities during the
project, leading to scope creep or the need for constant adaptation.

2. Ambiguity and Incompleteness: Requirements may not always be clear or fully

understood, leading to issues in design and development phases.

3. Conflicting Requirements: Different stakeholders might have conflicting needs or visions

for the system, which can cause delays or rework if not resolved early.

4. Stakeholder Communication: It can be difficult to get all stakeholders to communicate

their requirements effectively or participate in the process consistently.

5. Technical Feasibility: Some requirements may not be technically feasible or may require
advanced solutions that are costly or time-consuming to implement.

Requirement Engineering Process

The Requirement Engineering Process (REP) is a critical phase in software development that
focuses on identifying, analyzing, specifying, and validating the needs and expectations of
stakeholders for a new or updated system. It ensures that the final software product meets its
intended purpose, is of high quality, and satisfies the requirements of the users and stakeholders.
Requirement Engineering is considered the foundation of the software development life cycle
(SDLC) because poorly defined or misunderstood requirements can lead to project failure, rework,
and cost overruns.
It is a four step process, which includes –
 Feasibility Study

 Requirement Gathering
 Software Requirement Specification
 Software Requirement Validation
Let us see the process briefly -

Feasibility study
When the client approaches the organization for getting the desired product developed, it comes
up with rough idea about what all functions the software must perform and which all features
are expected from the software. Referencing to this information, the analysts does a detailed
study about whether the desired system and its functionality are feasible to develop.

This feasibility study is focused towards goal of the organization. This study analyzes whether
the software product can be practically materialized in terms of implementation, contribution of
project to organization, cost constraints and as per values and objectives of the organization. It
explores technical aspects of the project and product such as usability, maintainability,
productivity and integration ability.

The output of this phase should be a feasibility study report that should contain adequate
comments and recommendations for the management about whether or not the project should be
undertaken.

Requirement Gathering
If the feasibility report is positive towards undertaking the project, next phase starts with
gathering requirements from the user. Analysts and engineers communicate with the client and
end-users to know their ideas on what the software should provide and which features they want
the software to include.

Software Requirement Specification

Once collected the specifications are then analyzed and are documented in a detailed, structured
format. This specification becomes the reference point for design, development, and validation.
SRS is a document created by the system analyst after the requirements are collected from
various stakeholders.

SRS defines how the intended software will interact with hardware, external interfaces, speed of
operation, response time of system, portability of software across various platforms,
maintainability, speed of recovery after crashing, Security, Quality, Limitations etc.

The requirements received from client are written in natural language. It is the responsibility of
system analyst to document the requirements in technical language so that they can be
comprehended and useful by the software development team.

SRS should come up with following outputs:

 User requirements are expressed in natural language.
 Technical requirements are expressed in structured language, which is used inside the
organization.
 Design description should be written in pseudo code.
 Format of Forms and GUI screen prints.
 Conditional and mathematical notations for DFDs etc.
  Software Requirements Specification (SRS): A formal document that details all the
functional and non-functional requirements.
 Use Cases and User Stories: Descriptions of specific actions the system must support to meet
user needs.
 Data Flow Diagrams: Illustrate how data moves through the system.
 Entity-Relationship Diagrams: Depict the data structure and relationships in the system.

Software Requirement Validation

After requirement specifications are developed, the requirements mentioned in this document
are validated. This is ensuring that the gathered and specified requirements are correct,
complete, and meet stakeholders’ needs. User might ask for illegal, impractical solution or
experts may interpret the requirements incorrectly. This results in huge increase in cost if not
nipped in the bud.
Key Techniques

 Reviews and Inspections: Peer reviews and walkthroughs of the requirements document.
 Prototyping: Revisiting prototypes to validate whether the system meets user expectations.
 Test Cases: Developing test cases based on the requirements to ensure they are testable and
achievable.
 Stakeholder Validation: Getting formal approval or sign-off from stakeholders on the
requirement document.
Requirements can be checked against following conditions -
 If they can be practically implemented

 If they are valid and as per functionality and domain of software

 If there are any ambiguities
 If they are complete
 If they can be demonstrated
KEY ACTIVITIES IN THE REQUIREMENT ENGINEERING PROCESS
1. Requirement Elicitation
This is the process of gathering requirements from stakeholders (users, customers, and other
involved parties) to understand their needs, problems, and expectations.
Requirement Elicitation Process
Requirement elicitation process can be depicted using the following diagram:

Fig 1: Requirement elicitation process

  Requirements gathering - The developers discuss with the client and the end users and
know their expectations from the software.
 Organizing Requirements - The developers prioritize and arrange the requirements in
order of importance, urgency and convenience.
 Negotiation & discussion - If the requirements are ambiguous or there are some
conflicts in the requirements of various stakeholders, it is then negotiated and discussed
with the stakeholders. Requirements may then be prioritized and reasonably
compromised.
The requirements come from various stakeholders. To remove the ambiguity and
conflicts, they are discussed for clarity and correctness. Unrealistic requirements are
compromised reasonably.
 Documentation - All formal & informal, functional and non-functional requirements are
documented and made available for next phase processing.
Requirement Elicitation Techniques
Requirements Elicitation is the process to find out the requirements for an intended software
system by communicating with client, end users, system users and others who have a stake in
the software system development.

There are various ways to discover requirements

Interviews
Interviews are strong medium to collect requirements. Organization may conduct several types
of interviews such as:

 Structured (closed) interviews, where every single information to be gathered, is decided

in advance, they follow the pattern and matter of discussion firmly.
 Non-structured (open) interviews, where information to gather is not decided in advance,
more flexible and less biased.
 Oral interviews
 Written interviews
 One-to-one interviews which are held between two persons across the table.
 Group interviews which are held between groups of participants. They help to uncover
any missing requirement as numerous people are involved.
Surveys
Organization may conduct surveys among various stakeholders by querying about their
expectation and requirements from the upcoming system.

Questionnaires
 A document with pre-defined set of objective questions and respective options is handed over to
all stakeholders to answer, which are collected and compiled.

A shortcoming of this technique is, if an option for some issue is not mentioned in the
questionnaire, the issue might be left unattended.

Task analysis
Team of engineers and developers may analyze the operation for which the new system is
required. If the client already has some software to perform certain operation, it is studied and
requirements of proposed system are collected.
Domain Analysis
Every software falls into some domain category. The expert people in the domain can be a great
help to analyze general and specific requirements.

Brainstorming
An informal debate is held among various stakeholders and all their inputs are recorded for
further requirements analysis.

Prototyping
Prototyping is building user interface without adding detail functionality for user to interpret the
features of intended software product. It helps giving better idea of requirements. If there is no
software installed at client’s end for developer’s reference and the client is not aware of its own
requirements, the developer creates a prototype based on initially mentioned requirements. The
prototype is shown to the client and the feedback is noted. The client feedback serves as an input
for requirement gathering.

Observation
Team of experts visits the client’s organization or workplace. They observe the actual working
of the existing installed systems. They observe the workflow at client’s end and how execution
problems are dealt. The team itself draws some conclusions which aid to form requirements
expected from the software.

2. Requirement Analysis

After gathering raw requirements, the next step is analyzing them to ensure they are feasible,
necessary, and unambiguous. Key Activities:

 Conflict Resolution: Addressing and resolving conflicting requirements from different

stakeholders.

 Prioritization: Ranking requirements based on importance, cost, and time constraints.

 Feasibility Study: Assessing if the requirements can be practically implemented, given

 technological and budgetary constraints.

 Modeling Requirements: Using tools like UML (Unified Modeling Language) or flowcharts
to model the system and its interactions.
Software Requirements Specification (SRS) Document

A Software Requirements Specification (SRS) document is a detailed and formal description of a

software system’s requirements, laying the groundwork for all subsequent project phases like
design, development, and testing. It serves as a communication tool between stakeholders,
including clients, users, and developers, and ensures that the final product meets both functional
and non-functional expectations.

Importance of an SRS Document

 Clear Communication: The SRS serves as a reference point for developers, clients, and testers,
ensuring everyone has a shared understanding of the system's features and limitations.
 Avoids Misunderstanding: Clearly defined requirements prevent costly misunderstandings,
rework, and potential project delays.
 Foundation for Design: Developers use the SRS to design the system architecture, components,
and interfaces.
 Basis for Testing: The SRS document outlines requirements in a manner that testers can create test
cases to validate if the system meets the expectations.
 Contractual Agreement: In many cases, an SRS serves as a formal contract between the client
and the software development team, ensuring that the final product aligns with the agreed-upon
requirements.

Properties of a good SRS document

The important properties of a good SRS document are the following:
 Concise. The SRS document should be concise and at the same time unambiguous, consistent, and
complete. Verbose and irrelevant descriptions reduce readability and also increase error possibilities.
 Structured. It should be well-structured. A well-structured document is easy to understand and modify.
In practice, the SRS document undergoes several revisions to cope up with the customer
requirements. Often, the customer requirements evolve over a period of time. Therefore, in order to
make the modifications to the SRS document easy, it is important to make the document well-
structured.
 Black-box view. It should only specify what the system should do and refrain from stating how to do
these. This means that the SRS document should specify the external behavior of the system and not
discuss the implementation issues. The SRS document should view the system to be developed as
black box, and should specify the externally visible behavior of the system. For this reason, the SRS
document is also called the black-box specification of a system.
 Conceptual integrity. It should show conceptual integrity so that the reader can easily understand it.
 Response to undesired events. It should characterize acceptable responses to undesired events. These
are called system response to exceptional conditions.
 Verifiable. All requirements of the system as documented in the SRS document should be verifiable.
This means that it should be possible to determine whether or not requirements have been met in an
implementation.

Problems of development without a SRS document

The important problems that an organization would face if it does not develop a SRS document are as
follows:
 Without developing the SRS document, the system would not be implemented according to customer
needs.
 Software developers would not know whether what they are developing is what exactly required by the
customer.
 Without SRS document, it will be very much difficult for the maintenance engineers to understand the
functionality of the system.
 It will be very much difficult for user document writers to write the users’ manuals properly without
understanding the SRS document.

Problems with an unstructured specification

• It would be very much difficult to understand that document.
• It would be very much difficult to modify that document.
• Conceptual integrity in that document would not be shown.
• The SRS document might be unambiguous and inconsistent.

SOFTWARE REQUIREMENT CHARACTERISTICS

Gathering software requirements is the foundation of the entire software development project.
Hence, they must be clear, correct and well-defined. A complete Software Requirement
Specifications must be:

 Clear
 Correct
 Consistent
 Coherent
 Comprehensible
 Modifiable
 Verifiable
 Prioritized
 Unambiguous
 Traceable
 Credible source
Software Requirements
We should try to understand what sort of requirements may arise in the requirement elicitation
phase and what kinds of requirements are expected from the software system.
Broadly software requirements should be categorized in two categories:

Functional Requirements: Requirements, which are related to functional aspect of software

fall into this category. They define functions and functionality within and from the software
system. EXAMPLES -
 Search option given to user to search from various invoices.

 User should be able to mail any report to management.

 Users can be divided into groups and groups can be given separate rights.
  Should comply business rules and administrative functions.
 Software is developed keeping downward compatibility intact.
Non-Functional Requirements: Requirements, which are not related to functional aspect of
software, fall into this category. They are implicit or expected characteristics of software, which
users make assumption of.
Non-functional requirements include -
 Security

 Logging
 Storage
 Configuration
 Performance
 Cost
 Interoperability
 Flexibility
 Disaster recovery
 Accessibility
Requirements are categorized logically as

 Must Have: Software cannot be said operational without them.

 Should have: Enhancing the functionality of software.
 Could have: Software can still properly function with these requirements.
 Wish list: These requirements do not map to any objectives of software.
While developing software, ‘Must have’ must be implemented, ‘Should have’ is a matter of
debate with stakeholders and negation, whereas ‘could have’ and ‘wish list’ can be kept for
software updates.

User Interface (UI) requirements

UI is an important part of any software or hardware or hybrid system. A software is widely
accepted if it is -

 easy to operate
 quick in response
 effectively handling operational errors
 providing simple yet consistent user interface

User acceptance majorly depends upon how user can use the software. UI is the only way for
users to perceive the system. A well performing software system must also be equipped with
attractive, clear, consistent and responsive user interface. Otherwise the functionalities of
software system cannot be used in convenient way. A system is said be good if it provides
means to use it efficiently. User interface requirements are briefly mentioned below -
 Content presentation

 Easy Navigation
 Simple interface
 Responsive
 Consistent UI elements
 Feedback mechanism
 Default settings
 Purposeful layout
 Strategically use of color and texture.
 Provide help information
 User centric approach
 Group based view settings.
Software System Analyst
System analyst in an IT organization is a person, who analyzes the requirement of proposed
system and ensures that requirements are conceived and documented properly & correctly. Role
of an analyst starts during Software Analysis Phase of SDLC. It is the responsibility of analyst
to make sure that the developed software meets the requirements of the client.
System Analysts have the following responsibilities:
 Analyzing and understanding requirements of intended software

 Understanding how the project will contribute in the organization objectives

 Identify sources of requirement
 Validation of requirement
 Develop and implement requirement management plan
 Documentation of business, technical, process and product requirements
 Coordination with clients to prioritize requirements and remove and ambiguity
 Finalizing acceptance criteria with client and other stakeholders
Software Metrics and Measures
Software Measures can be understood as a process of quantifying and symbolizing various
attributes and aspects of software. Software Metrics provide measures for various aspects of
software process and software product. Software measures are fundamental requirement of
software engineering. They not only help to control the software development process but also
 aid to keep quality of ultimate product excellent.
Some software metrics:
 Size Metrics - LOC (Lines of Code), mostly calculated in thousands of delivered source
code lines, denoted as KLOC.
Function Point Count is measure of the functionality provided by the software. Function
Point count defines the size of functional aspect of software.
 Complexity Metrics - McCabe’s Cyclomatic complexity quantifies the upper bound of
the number of independent paths in a program, which is perceived as complexity of the
program or its modules. It is represented in terms of graph theory concepts by using
control flow graph.
 Quality Metrics - Defects, their types and causes, consequence, intensity of severity and
their implications define the quality of product.
The number of defects found in development process and number of defects reported by
the client after the product is installed or delivered at client-end, define quality of
product.
 Process Metrics - In various phases of SDLC, the methods and tools used, the company
standards and the performance of development are software process metrics.
 Resource Metrics - Effort, time and various resources used, represents metrics for
resource measurement.

SOFTWARE DESIGN
Software design is a process to transform user requirements into some suitable form, which
helps the programmer in software coding and implementation. For assessing user requirements,
an SRS (Software Requirement Specification) document is created whereas for coding and
implementation, there is a need of more specific and detailed requirements in software terms.
The output of this process can directly be used into implementation in programming languages.

Software design is the first step in SDLC (Software Design Life Cycle), which moves the
concentration from problem domain to solution domain. It tries to specify how to fulfill the
requirements mentioned in SRS.

Software Design Levels

Software design yields three levels of results:

 Architectural Design - The architectural design is the highest abstract version of the
system. It identifies the software as a system with many components interacting with
each other. At this level, the designers get the idea of proposed solution domain.
 High-level Design- The high-level design breaks the ‘single entity-multiple component’
 concept of architectural design into less-abstracted view of sub-systems and modules and
depicts their interaction with each other. High-level design focuses on how the system
along with all of its components can be implemented in forms of modules. It recognizes
modular structure of each sub-system and their relation and interaction among each other.
 Detailed Design- Detailed design deals with the implementation part of what is seen as a
system and its sub-systems in the previous two designs. It is more detailed towards
modules and their implementations. It defines logical structure of each module and their
interfaces to communicate with other modules.
Modularization
Modularization is a technique to divide a software system into multiple discrete and independent
modules, which are expected to be capable of carrying out task(s) independently. These modules
may work as basic constructs for the entire software. Designers tend to design modules such that
they can be executed and/or compiled separately and independently.
Modular design unintentionally follows the rules of ‘divide and conquer’ problem-solving strategy this
is because there are many other benefits attached with the modular design of a software.
Advantage of modularization:
• Smaller components are easier to maintain
• Program can be divided based on functional aspects
• Desired level of abstraction can be brought in the program
• Components with high cohesion can be re-used again
• Concurrent execution can be made possible
• Desired from security aspect

Concurrency
Back in time, all softwares were meant to be executed sequentially. By sequential execution we mean
that the coded instruction will be executed one after another implying only one portion of program
being activated at any given time. Say, a software has multiple modules, then only one of all the
modules can be found active at any time of execution.
In software design, concurrency is implemented by splitting the software into multiple independent
units of execution, like modules and executing them in parallel. In other words, concurrency provides
capability to the software to execute more than one part of code in parallel to each other.
It is necessary for the programmers and designers to recognize those modules, which can be made
parallel execution.
Example
The spell check feature in word processor is a module of software, which runs alongside the word
processor itself.