Pailan College of Management & Technology

B.Tech Division (College Code-156)

----------------------------------------------------------------------------------------------------------------------------------------
CA-II Examinations
(REPORT WRITING)
(Full Marks=25)
Student Name Bishwadeep Bose
University Roll 15600123041
No
Subject Name Software Engineering
Subject Code ESC - 501
Semester 5th semester
Department Computer Science Engineering
Instructions:
1. Please don’t change the formatting and font.
2. Topics should be selected which were done in the class.
3. Convert the word into PDF before submission.
Module/ Topic Software Development Life Cycle (SDLC)
Explanation :
Introduction
The Software Development Life Cycle (SDLC) is a
structured approach to software development, ensuring
that a software product is delivered in a systematic and
organized manner. SDLC defines the stages and
processes involved in creating high-quality software,
from planning and designing to deployment and
maintenance. Different models of SDLC are used
depending on the project requirements, complexity, and
stakeholder needs. This report explores various SDLC
models and provides real-world examples illustrating
how they are applied in software engineering.

1. Phases of SDLC
1.1. Planning and Requirement Analysis
• Objective: This is the most critical phase where
project goals are established, and the feasibility of
the project is evaluated.

• Activities:
o Requirement gathering from stakeholders

(clients, end-users, managers).

 o Conducting a feasibility study to assess the
technical, operational, and financial viability of
the project.
o Identifying risks and developing a risk
mitigation plan.

1.2. Defining Requirements

• Objective: Define the functional and non-
functional requirements that the software must
meet.
• Activities:
o Documenting software requirements in a

Software Requirement Specification (SRS)

document.
o Ensuring clear understanding among

stakeholders regarding the software’s scope,

functionalities, and limitations.

1.3. System Design

• Objective: Translate the software requirements
into a blueprint for the software.
• Activities:
o Creating detailed designs (architecture,

database, UI/UX).
o Defining software modules, data flow, and

interface designs.
 o Preparing technical documentation to guide
developers during coding.

1.4. Implementation (Coding)

• Objective: Actual coding of the software based on
the design documents.
• Activities:
o Developers write the code using a specific

programming language.
o Code is broken down into small, manageable

components or modules.
o Integration of modules once individual

components are completed.

1.5. Testing
• Objective: Identify and fix bugs or defects in the
software to ensure it meets the required standards.
• Activities:
o Different levels of testing, including unit

testing, integration testing, system testing,

and user acceptance testing (UAT).
o Ensuring the software functions correctly in

different environments.
o Verification that the software fulfills all

functional and non-functional requirements.

1.6. Deployment
 • Objective: Release the software to the production
environment where it will be available for end-
users.
• Activities:
o Installation and configuration of the software

in the production environment.

o Data migration (if necessary) and user

training.
o Providing post-deployment support for any

issues encountered by end-users.

1.7. Maintenance
• Objective: Ensure the software remains functional,
secure, and relevant over time.
• Activities:
o Bug fixes and performance improvements.

o Implementing minor updates and patches.

o Handling any changes or new requirements

from users (adaptive maintenance).

2. SDLC Models
Different SDLC models are used based on the project
requirements, complexity, and goals. Here are a few
common models:
2.1. Waterfall Model
• Description: A linear, sequential approach where
each phase must be completed before the next one
begins.
 • Advantages: Simple, easy to manage, and suitable
for small projects with well-defined requirements.
• Disadvantages: Inflexible; difficult to make
changes once the project is in later stages.
2.2. Agile Model
• Description: An iterative and incremental
approach that promotes flexibility and customer
collaboration. Development is done in sprints
(short cycles).
• Advantages: Flexible, allows for frequent changes
and client feedback, and promotes rapid delivery.
• Disadvantages: Can be challenging to manage
without clear documentation, and scope creep is
possible.
2.3. Spiral Model
• Description: Combines elements of both iterative
and Waterfall models. It focuses on risk analysis
and evolves through multiple iterations (spirals).
• Advantages: Risk management is prioritized, and
the model is suitable for large, complex projects.
• Disadvantages: Expensive due to ongoing risk
assessments and frequent changes.

2.4. V-Model (Verification and Validation Model)

• Description: Similar to the Waterfall model but
with a focus on testing at each stage of
development.
 • Advantages: High quality is ensured due to
continuous validation and verification at every
phase.
• Disadvantages: Like the Waterfall model, it is
rigid and not suited for projects with changing
requirements.

2.5. DevOps Model

• Description: Integrates development and
operations teams to improve collaboration, with a
focus on continuous integration, delivery, and
deployment.
• Advantages: Rapid delivery, increased efficiency,
and enhanced collaboration between teams.
• Disadvantages: Requires a high level of
automation and can be complex to implement.

4. Importance of SDLC

• Ensures Project Success: SDLC provides a

roadmap that helps ensure the software is
developed on time and within budget, meeting the
user’s requirements.
• Risk Management: Each phase allows for the
identification and management of risks early in the
development process.
 • Improves Quality: Following a structured SDLC
ensures that the software is of high quality, with
fewer defects or vulnerabilities.
• Reduces Costs: By catching issues early and
preventing scope creep, SDLC helps control the
overall cost of development.
• Customer Satisfaction: An SDLC that involves
continuous feedback (like Agile or DevOps) helps
align the final product with customer needs,
ensuring higher satisfaction.

4. Challenges in SDLC
• Changing Requirements: Projects with unclear or
frequently changing requirements can be difficult
to manage.
• Time and Resource Constraints: Tight deadlines
or insufficient resources may compromise the
quality of the final product.
• Complexity in Large Projects: Managing large-
scale projects with multiple interdependent
modules can be challenging, especially in models
like Waterfall.

1. Waterfall Model
The Waterfall Model is one of the earliest SDLC
models and follows a linear and sequential approach.
Each phase in the development process must be
completed before the next one begins, and there is little
to no overlap between phases. This model is best suited
for projects with well-defined requirements that are
unlikely to change.
Example: Traditional Banking System
A traditional banking system upgrade or development
project could be an ideal use case for the Waterfall
model. The requirements for such systems are
generally well-understood and stable. The bank would
define clear objectives (such as automating certain
banking processes), and the Waterfall model's strict
phase-by-phase approach ensures that every feature is
thoroughly designed, implemented, and tested before
moving forward.
Phases:
1. Requirements Gathering: Defining detailed
system requirements such as transaction handling,
account management, and security features.
2. System Design: Architects design the overall
system structure, database schema, and software
architecture.
3. Implementation: Developers write the code for
the system following the design.
4. Testing: The system undergoes comprehensive
testing to identify and fix bugs.
5. Deployment: Once testing is complete, the
software is deployed into the banking environment.
 6. Maintenance: Ongoing support is provided to
handle any issues or changes that arise post-
deployment.

2. Agile Model
The Agile Model is an iterative and flexible approach
to software development. Instead of delivering a
complete system at once, development is broken into
smaller cycles called sprints. Agile encourages
collaboration with customers and adapts to changes in
requirements throughout the development process.
Example: Mobile App Development
Agile is commonly used in the development of mobile
applications, where customer feedback and frequent
updates are vital. A team developing a social media app
may use Agile to release minimum viable products
(MVPs) in iterations, gathering user feedback and
adding features in subsequent sprints.
Phases (in each sprint):
1. Planning: The team works with stakeholders to
prioritize tasks for the sprint, such as adding a new
messaging feature.
2. Design: Designers and developers collaborate to
sketch out the feature design.
3. Development: The team develops the feature
within the sprint, ensuring that code is
continuously integrated.
 4. Testing: The feature is tested for bugs and
performance issues within the sprint.
5. Review and Feedback: Stakeholders review the
completed feature, provide feedback, and decide on
new priorities for the next sprint.
Agile allows the app to be deployed quickly, with
iterative improvements based on user feedback, making
it ideal for dynamic and evolving projects.

3. V-Model (Verification and Validation Model)

The V-Model is an extension of the Waterfall model,

with a focus on validation and verification at each stage.
Every development phase has a corresponding testing
phase, ensuring that issues are caught and corrected
early. This model is particularly useful for projects
requiring rigorous testing, such as medical software or
embedded systems.
Example: Medical Device Software
In the development of software for medical devices,
such as patient monitoring systems, the V-Model
ensures that the software meets strict regulatory
requirements and functions reliably.
Phases:
1. Requirements Specification: Requirements are
collected and analyzed, such as accuracy in data
collection and alarm triggering.
o Testing: Requirements validation ensures that

specifications align with healthcare standards.

2. System Design: A detailed design plan is created
for the medical device software.
o Testing: Design validation confirms that the

system's architecture can meet functional and

safety requirements.
3. Module Design: Developers design individual
software modules.
o Testing: Unit testing ensures that each

module functions as intended.

4. Implementation: Developers code the software
modules.
o Testing: Integration testing confirms that the

modules work together correctly.

5. Deployment and Maintenance: After system
testing, the software is deployed to medical devices.
The V-Model’s emphasis on testing ensures that
medical software is thoroughly verified and validated at
each stage, reducing the risk of critical issues in the
final product.

4. Iterative Model
The Iterative Model focuses on delivering software in
small, incremental builds, with each iteration improving
upon the previous one. Instead of starting with the full
set of requirements, the development team starts with a
basic version and gradually adds features in subsequent
iterations.
Example: Video Game Development
Video game development often follows the iterative
model due to the complexity of gameplay mechanics,
user interface design, and graphics.
Phases (for each iteration):
1. Initial Planning: The development team builds a
prototype or a simplified version of the game with
basic gameplay mechanics.
2. Design and Development: Developers and artists
collaborate to implement and refine game features,
such as character movement or level design.
3. Testing: Each iteration undergoes testing for bugs
and player feedback.
4. Feedback and Improvement: Based on user
feedback, the team refines the game, adding new
features or improving gameplay mechanics in
subsequent iterations.
The iterative model allows game developers to test
ideas quickly and refine the game based on player
experience and market feedback.
5. Spiral Model
The Spiral Model combines elements of both the
iterative and Waterfall models, focusing on risk
assessment at each iteration. It is especially useful for
large, complex projects where risk management is
critical.
Example: Large-Scale Enterprise Software
For large enterprise resource planning (ERP) software,
the Spiral Model helps manage risks such as cost
overruns, changing requirements, or integration
challenges.
Phases:
1. Planning: Initial requirements are gathered, such
as inventory management or payroll processing for
the ERP system.
2. Risk Analysis: Each requirement or feature is
assessed for potential risks, such as integration
challenges with existing systems or data security
concerns.
3. Engineering: The ERP system is developed
incrementally, with high-risk features tackled first.
4. Evaluation: After each iteration, stakeholders
review the system and decide on the next set of
features to develop based on risks and priorities.
The Spiral Model’s emphasis on risk analysis makes it
well-suited for large, mission-critical projects where
failing to identify risks early can lead to costly delays or
failures.

6. DevOps Model
The DevOps Model integrates development (Dev) and
operations (Ops) to ensure continuous delivery and
integration. It emphasizes automation, collaboration,
and monitoring throughout the software development
and deployment process.
Example: Cloud-Based Applications
A cloud-based platform, such as an e-commerce website,
can leverage DevOps to ensure continuous updates,
high availability, and scalability.
Phases:
1. Development: Developers continuously write and
commit code to a shared repository.
2. Continuous Integration (CI): Automated tools
compile and test the code after every commit,
ensuring that the build is stable.
3. Continuous Deployment (CD): The code is
automatically deployed to production once it passes
all tests, reducing downtime.
4. Monitoring: The live application is monitored for
performance and user feedback, which feeds into
the next development cycle.
In the case of a cloud-based e-commerce platform,
DevOps ensures that the website remains available
24/7, and new features or bug fixes can be rolled out
quickly without disrupting service.

7. Big Bang Model

The Big Bang Model is an unconventional and high-
risk approach where the development process starts
with little to no planning, and all resources are directed
towards coding and development. This model is
typically used in small projects with undefined
requirements.
Example: Prototype Development for Startups
In some startup environments, a quick-and-dirty
prototype may be built using the Big Bang model to
demonstrate the viability of a new idea. There’s no
formal design or planning phase; developers focus on
building something quickly for immediate feedback.
Phases:
1. Development: The team rapidly codes a working
prototype without detailed specifications.
2. Testing: Testing is often informal, relying on user
feedback rather than structured testing processes.
3. Feedback: Based on feedback, the prototype is
either refined or scrapped.
The Big Bang model is only effective for projects where
flexibility is high and the risks associated with lack of
planning are acceptable.
Conclusion
The Software Development Life Cycle (SDLC) is vital
for delivering reliable and high-quality software
solutions. Different models of SDLC are suited for
different types of projects, depending on factors such as
complexity, risk, and time constraints. From the
structured Waterfall Model to the flexible Agile Model,
the examples outlined in this report highlight the
importance of selecting the right SDLC model to
ensure the success of software engineering projects.