IT451-SOFTWARE ENGINEERING 21DIT087

ASSIGNMENT
Q-1):-You are a Senior Developer tasked with developing a software system for
a large-scale healthcare application. The client has provided a comprehensive list
of requirements, but the project has strict deadlines and evolving requirements.
Considering this, which software process model (e.g., Waterfall, Agile, Spiral)
would you choose and why? Discuss how your chosen model handles evolving
requirements and strict deadlines.

A-1):- The Agile process model is the most appropriate choice for developing a
large-scale healthcare application with strict deadlines and evolving requirements.
Healthcare systems often require constant changes due to regulatory updates,
technological advancements, and the client’s evolving business needs. Agile,
particularly Scrum, is an iterative and flexible methodology that allows developers
to build software incrementally, delivering working modules at the end of each
sprint (usually 2-4 weeks).

Agile accommodates evolving requirements by incorporating customer feedback

at the end of each sprint. This ensures that the software evolves with the user’s
needs and market conditions without disrupting the project’s flow. Moreover,
Agile's flexibility allows prioritizing certain critical features within strict deadlines
while pushing less urgent features for later sprints. This is crucial in a healthcare
project where certain functionalities (e.g., patient data management, and security)
must be fully operational within a fixed timeline.

Additionally, Agile's continuous communication between stakeholders,

developers, and testers ensures that any discrepancies or concerns are addressed
promptly. For instance, in the healthcare industry, compliance with HIPAA (Health
Insurance Portability and Accountability Act) standards can introduce unexpected
changes to requirements. Agile teams are well-suited to quickly adapt, ensuring
that strict deadlines are met without compromising the quality or security of the
system.

DEPSTAR-IT 1
IT451-SOFTWARE ENGINEERING 21DIT087

Q-2):- As a project manager, you are overseeing a software project that has just
undergone significant changes in requirements after the initial phase. Given this
shift, which Agile methodology (Scrum, Kanban, or other) would you adopt to
manage the evolving scope and why? How would you ensure your team adapts to
these changes while maintaining productivity and quality?
A-2):- In a scenario where a project undergoes significant changes in requirements
after the initial phase, Scrum is the most suitable Agile methodology. Scrum is
known for its structured yet flexible approach to managing projects where
requirements are likely to evolve.
Scrum organizes work into small, time-boxed sprints, typically lasting 2-4 weeks.
Each sprint begins with a planning session where the team, along with the product
owner, reviews the changes in the requirements and reprioritizes tasks. This helps
the team remain aligned with the project’s goals despite the evolving scope. At the
end of each sprint, the team delivers a potentially shippable product increment,
ensuring continuous progress even when requirements change.
To ensure that the team adapts to these changes while maintaining productivity and
quality, certain practices should be followed:
• Clear communication: Regular meetings (e.g., daily standups, sprint
reviews, and retrospectives) keep the team informed of any changes. The
product owner plays a key role in ensuring that the team understands the
revised requirements and business priorities.
• Backlog refinement: The product backlog should be frequently updated to
reflect the latest changes. The product owner works closely with
stakeholders to ensure that the team is working on the most important
features.
• Emphasis on quality: While the scope may change, maintaining high-quality
standards is essential. Automated testing, continuous integration, and regular
code reviews help the team ensure that the project remains on track without
sacrificing quality.
Scrum allows for adaptability and flexibility, ensuring that the team can adjust
quickly to new requirements without losing momentum. By focusing on small,
manageable goals, the team can deliver value continuously and remain responsive
to changes.

DEPSTAR-IT 2
IT451-SOFTWARE ENGINEERING 21DIT087

Q-3):- You have been assigned to manage a project for a new online banking
platform with strict security and performance requirements. Considering the high
risks involved, which software process model (e.g., RAD, Spiral, Agile) would you
choose to ensure risk management and why? Outline how you would identify,
project, and mitigate potential risks during the development cycle.
A-3):- For an online banking platform with strict security and performance
requirements, the Spiral Model is the best choice. The Spiral Model is designed for
high-risk projects and emphasizes risk management at every phase of development.
It combines iterative development with systematic risk analysis, making it ideal for
complex systems like online banking, where security, performance, and reliability
are non-negotiable.
The Spiral Model operates in four main phases: Planning, Risk Analysis,
Engineering, and Evaluation. During each iteration, risks are identified and
assessed, and mitigation strategies are developed. For example, in an online
banking platform, risks such as data breaches, system downtime, and performance
bottlenecks are critical and must be addressed early on. By prioritizing risk
analysis, the Spiral Model ensures that the project team identifies and mitigates
potential issues before they become costly problems.
Risk management strategies in the Spiral Model:
• Risk Identification: Risks related to security (e.g., vulnerability to
cyberattacks), system performance (e.g., handling peak loads), and
compliance (e.g., meeting legal regulations) are identified early.
• Risk Projection: The team assesses the likelihood and impact of each risk.
For example, a potential security breach could have severe consequences for
a banking system, so this risk would be prioritized.
• Risk Mitigation: The development team implements strategies such as
encryption, regular security audits, and load testing to mitigate these risks.
• Continuous Feedback and Adjustment: As development progresses, the team
revisits and refines the risk assessment, ensuring that any new risks are
addressed.
The Spiral Model allows flexibility in revisiting earlier phases based on feedback
and risk analysis, ensuring that the software is secure and robust without incurring
unnecessary costs.

DEPSTAR-IT 3
IT451-SOFTWARE ENGINEERING 21DIT087

Q-4):- Your team is working on a software solution for a client who has only a
vague idea of the system's requirements. As a project In charge, which process
model (e.g., Prototyping Model, Evolutionary Model) would you use to ensure
continuous feedback and refinement of the product? Discuss how you would ensure
client satisfaction while meeting the evolving project requirements.
A-4):- When working with a client who has only a vague idea of the system's
requirements, the Prototyping Model is the most appropriate process model. This
model focuses on building a working prototype of the system early in the project,
allowing the client to visualize the product and provide feedback. As a result, the
client can refine their requirements based on the working prototype, and the
development team can adjust the project accordingly.
The Prototyping Model ensures continuous feedback and refinement by allowing
the client to interact with the prototype during multiple iterations. After each
iteration, the client can provide insights about what needs to be added, removed, or
modified, and the development team incorporates these suggestions in the next
version of the prototype. This iterative process continues until the client is satisfied
with the system’s functionality and design.
To ensure client satisfaction while meeting evolving project requirements, the
following practices should be implemented:
• Regular communication and feedback: Schedule frequent meetings with the
client to review the prototype and discuss their evolving needs.
• Incorporating feedback promptly: After each review session, immediately
incorporate the client’s feedback into the next version of the prototype.
• Prioritizing features: Work with the client to prioritize features based on their
importance, so the most critical functionalities are implemented first.
This approach ensures that the final product closely aligns with the client’s
expectations, even when those expectations evolve over time.

DEPSTAR-IT 4
IT451-SOFTWARE ENGINEERING 21DIT087

Q-5):- You are leading a project that involves the development of a modular
e- commerce platform, where components can be reused across multiple
projects. Which software design approach (Function-Oriented or Object-
Oriented) and process model would you choose to handle the component-based
development and why? Explain how you would manage the design and
integration of these reusable components throughout the project.
A-5):- For the development of a modular e-commerce platform where
components can be reused across multiple projects, the Object-Oriented Design
(OOD) approach, combined with the Component-Based Development (CBD)
model, would be the most effective.
Object-Oriented Design focuses on creating reusable components (objects) that
encapsulate data and behavior. In a modular e-commerce platform, each
component (e.g., product catalog, shopping cart, payment gateway) can be
designed as an independent object, making it easier to reuse across multiple
projects. OOD also promotes code reusability, scalability, and maintainability,
which are essential for a system where components are shared among different
applications.
The Component-Based Development (CBD) model complements OOD by
focusing on assembling existing components rather than building everything
from scratch. CBD breaks down the software into functional and reusable
modules that can be integrated into various systems. This modular approach
speeds up development and improves maintainability, as each component can
be updated or replaced independently.
To manage the design and integration of reusable components, the following
strategies should be employed:
• Clear module interfaces: Define clear interfaces for each component to
ensure that they can be easily integrated into different projects.
• Version control and documentation: Maintain proper version control and
documentation for each reusable component, ensuring that any updates
or changes are tracked.
• Testing and integration: Each component should be thoroughly tested to
ensure compatibility with other modules. Integration testing should also
be conducted to ensure that all components work seamlessly together
when combined.
This combination of OOD and CBD ensures that the e-commerce platform is
flexible, scalable, and maintainable, with reusable components that can be
easily adapted for future projects.

DEPSTAR-IT 5