1|Page © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

Unit – II
Software Requirements Engineering and
Analysis
1. Modeling
Modeling in software engineering is the process of creating abstract representations of a
software system to understand, analyze, design, and communicate its structure and behavior
before actual development. These models help in visualizing the system from different
perspectives and ensure that all stakeholders have a clear understanding of the system.

1.1 Requirements Engineering

Requirements Engineering (RE) is the process of gathering, analyzing, documenting, and

managing the requirements of a software or system to ensure it meets stakeholders' needs. It
is a crucial phase in software development that helps avoid project failures due to unclear or
incomplete requirements.

Requirement

A requirement is a documented need, condition, or capability that a system, software, or

product must meet to fulfill stakeholder expectations. It serves as a guideline for development,
ensuring that the final product works as intended.

Types of Requirements

1. Functional Requirements – Define specific functions or features the system must have
(e.g., user authentication, data processing).

2. Non-Functional Requirements – Specify system qualities like performance, security,

usability, and scalability.

3. Business Requirements – Describe high-level needs and goals from a business

perspective.

4. User Requirements – Define what users need from the system in terms of interaction and
experience.
2|Page © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

5. System Requirements – Detail the technical specifications for hardware, software, and
infrastructure.

6. Performance Requirements – Set benchmarks for speed, responsiveness, and efficiency.

7. Security Requirements – Outline data protection, authentication, and access control

measures.

8. Regulatory & Compliance Requirements – Ensure adherence to legal and industry

standards.

Importance of Requirement Engineering

1. Clear Understanding: Ensures a clear and shared understanding of project goals among
stakeholders.

2. Reduces Risks: Identifies potential issues early, minimizing project risks and failures.

3. Cost Efficiency: Prevents costly changes and rework by defining requirements upfront.

4. Improves Quality: Ensures the final product meets user needs and expectations.

5. Enhances Communication: Bridges the gap between stakeholders and development

teams.

6. Guides Development: Provides a roadmap for design, development, and testing.

7. Ensures Compliance: Helps meet regulatory and business standards.

8. Facilitates Scalability: Allows for future growth and adaptability of the system.

9. Boosts User Satisfaction: Delivers a product that aligns with user needs and expectations.

10. Supports Decision-Making: Provides a basis for prioritizing features and resources.

1.2 Requirements Engineering Tasks

1. Inception: This is the initial phase where the need for a software system is identified, and
key stakeholders (clients, users, developers) are recognized.

Key Activities:

 Identifying project stakeholders (who will use or be affected by the system).

 Understanding the problem domain.

3|Page © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

 Discussing the high-level goals and objectives of the software.

 Defining preliminary system boundaries.

 Assessing the feasibility of the project.

Example: A company wants to develop an e-learning app. In this stage, they identify teachers,
students, and administrators as stakeholders and define the goal of creating an interactive
learning platform.

2. Elicitation: The process of gathering requirements from stakeholders using various

techniques.

Key Activities:

 Conducting interviews with users, clients, and domain experts.

 Using questionnaires and surveys to collect feedback.

 Observing current systems and workflows.

 Conducting brainstorming sessions.

 Reviewing similar existing systems.

 Performing Joint Application Development (JAD) sessions.

Example: Developers interview teachers to understand what features they need in the e-
learning app, such as quizzes, live sessions, and progress tracking.

3. Elaboration: This phase refines and expands the gathered requirements to make them more
detailed and structured.

Key Activities:

 Developing models (Use Case Diagrams, Data Flow Diagrams, etc.).

 Identifying functional and non-functional requirements.

 Creating detailed descriptions of system behavior.

 Establishing relationships between different requirements.

Example: After discussing with teachers, developers create detailed use case diagrams for user
roles like "Student," "Teacher," and "Admin," showing how they interact with the system.
4|Page © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

4. Negotiation

Since different stakeholders may have conflicting requirements, this phase ensures a balanced
and mutually agreeable solution.

Key Activities:

 Identifying conflicting requirements.

 Prioritizing critical features based on business value and feasibility.

 Resolving disagreements through discussions and trade-offs.

 Documenting accepted requirements.

Example: Teachers want real-time video streaming, but developers say it increases server costs.
They negotiate and agree to include pre-recorded video lectures as a cost-effective alternative.

5. Specification

The process of formally documenting the agreed-upon requirements in a structured manner.

Key Activities:

 Writing a Software Requirement Specification (SRS) document.

 Using structured formats (text, diagrams, models).

 Defining functional, non-functional, and business requirements.

Example: Developers create an SRS document specifying that the system should support
"student login, course enrollment, and progress tracking" with detailed functionality
descriptions.

6. Validation

Ensures that the documented requirements are correct, complete, and feasible before
development begins.

Key Activities:

 Conducting requirement reviews with stakeholders.

 Using prototyping to validate requirements.

 Performing test case generation to check requirement clarity.

5|Page © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

 Identifying inconsistencies, ambiguities, or missing requirements.

Example: Developers create a prototype of the e-learning app’s login and course dashboard.
Teachers and students test it and suggest improvements before finalizing the requirements.

7. Requirements Management

This phase deals with tracking, controlling, and updating requirements throughout the project
lifecycle.

Key Activities:

 Maintaining a requirements database or repository.

 Handling changes in requirements systematically.

 Ensuring traceability (linking requirements to design and testing).

 Version control for requirements documentation.

Example: After launching the app, users request a "dark mode" feature. This change is
evaluated, documented, and integrated into future updates while keeping track of
modifications.

1.1 Establishing the Groundwork

Establishing the Groundwork in Software Engineering refers to the initial phase of a project
where the foundation is laid for successful development. This phase involves defining the
project's scope, objectives, and constraints, as well as identifying stakeholders and
understanding their needs. It sets the stage for all subsequent activities and ensures that the
team has a clear direction and shared understanding of what needs to be achieved.

Example Scenario:

A company wants to develop a mobile app for online food delivery. During the "Establishing
the Groundwork" phase:

 The problem statement is defined: "Create an app to connect customers with local
restaurants for food delivery."

 Stakeholders include customers, restaurant owners, delivery personnel, and the

development team.
6|Page © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

 Objectives are set: "Provide a user-friendly interface, real-time order tracking, and
secure payment options."

 The scope is determined: "The app will handle order placement and tracking but will
not manage restaurant inventory."

 Feasibility studies confirm the project is viable within the budget and timeline.

 A vision document is created to guide the team and stakeholders.

1.1 Identifying Stakeholders

Identifying stakeholders in software engineering is the process of recognizing all individuals,

groups, or entities that have an interest in or are affected by the software development project.
Stakeholders play a crucial role in defining requirements, setting expectations, and influencing
project decisions.

Types of Stakeholders in Software Engineering

1. Primary Stakeholders (Directly affected by the system)

o Clients – The organization or individuals funding the project.

o End-Users – The people who will use the software (customers, employees, students,
etc.).

o Project Managers – Oversee project timelines, budgets, and deliverables.

2. Secondary Stakeholders (Indirectly affected by the system)

o Software Developers – Design, implement, and test the software.

o UI/UX Designers – Ensure the system is user-friendly.

o Quality Assurance (QA) Testers – Validate that the software meets requirements.

o System Administrators – Manage deployment, maintenance, and security.

3. Regulatory & Compliance Stakeholders

o Legal and Compliance Teams – Ensure adherence to laws, security standards, and
industry regulations.

o Government or Industry Regulators – Provide guidelines for software development

in regulated industries (e.g., healthcare, finance).
7|Page © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

4. External Stakeholders

o Suppliers & Vendors – Provide third-party services, tools, or software integrations.

o Investors – Fund the project and expect business returns.

How to Identify Stakeholders?

 Brainstorming Sessions – Discuss potential stakeholders with the project team.

 Interviews & Surveys – Gather insights from business owners, end-users, and domain
experts.

 Stakeholder Analysis Matrix – Classify stakeholders based on their level of influence

and interest.

 Reviewing Documentation – Analyze contracts, business plans, or previous project

reports.

1.1 Recognizing Multiple Viewpoints

Recognizing Multiple Viewpoints in Software Engineering refers to the process of

understanding and addressing the diverse perspectives, needs, and expectations of different
stakeholders involved in a project. Since stakeholders often have varying roles, interests, and
priorities, their viewpoints on the system's requirements and functionality may differ.
Recognizing and reconciling these multiple viewpoints is essential for creating a system that
satisfies all stakeholders and avoids conflicts.

Why Are Multiple Viewpoints Important?

1. Diverse Stakeholder Needs:

o Different stakeholders (e.g., users, developers, managers, regulators) have unique

requirements and expectations.

o Example: Users may prioritize ease of use, while developers focus on technical
feasibility.

2. Avoiding Conflicts:

o Conflicting viewpoints can lead to misunderstandings, delays, or project failure if not

addressed early.
8|Page © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

3. Comprehensive Solutions:

o Incorporating multiple perspectives ensures the system is well-rounded and meets a

wider range of needs.

4. Improved Collaboration:

o Encourages stakeholders to work together, fostering a sense of ownership and

cooperation.

5. Better Decision-Making:

o Considering multiple viewpoints leads to more informed and balanced decisions.

Steps to Recognize and Manage Multiple Viewpoints:

1. Identify Stakeholders:

o List all individuals or groups with an interest in the project (e.g., end users, clients,
developers, regulators).

2. Gather Viewpoints:

o Use techniques like interviews, surveys, workshops, or focus groups to collect

stakeholder perspectives.

o Example: Ask users about their pain points and ask developers about technical
constraints.

3. Analyze Viewpoints:

o Compare and contrast the different viewpoints to identify commonalities and conflicts.

o Example: Users may want a feature that developers consider technically challenging.

4. Categorize Viewpoints:

o Group similar viewpoints to simplify analysis and prioritization.

o Example: Group all usability-related requirements from different user roles.

5. Reconcile Conflicts:

o Facilitate discussions to resolve conflicts and find compromises.

9|Page © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

o Example: Balance user demands for features with development constraints by

prioritizing must-have features.

6. Document Viewpoints:

o Record all viewpoints and decisions in a structured format (e.g., requirements

document).

o Ensure transparency and traceability.

7. Validate Viewpoints:

o Confirm with stakeholders that their viewpoints have been accurately understood and
addressed.

o Use prototypes or mockups to demonstrate how their needs will be met.

1.1 Working Toward Collaboration

Working toward collaboration in software engineering refers to the process of fostering

teamwork and effective communication among all stakeholders—developers, designers,
testers, clients, and end-users—to ensure the successful development of a software project.
Since software development is a complex and iterative process, collaboration helps align goals,
resolve conflicts, and improve efficiency.

Key Aspects of Effective Collaboration

1. Clear Communication

o Use structured documentation and meetings to align expectations.

o Maintain transparency in decisions and project progress.

2. Cross-Functional Teamwork

o Developers, designers, testers, and business analysts should work together rather than in
isolation.

o Encourage knowledge sharing between different roles.

3. Agile Methodology

o Use Agile practices like Scrum or Kanban to promote iterative development and
continuous collaboration.
10 | P a g e © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

o Conduct daily stand-up meetings to discuss progress and roadblocks.

4. Version Control & Code Collaboration

o Use Git, GitHub, or GitLab for managing code versions and enabling multiple
developers to work on the same project.

o Conduct code reviews and pair programming to maintain code quality.

5. Requirement Gathering with Stakeholders

o Involve clients, users, and business analysts in requirement discussions.

o Use techniques like brainstorming, interviews, and prototyping to align needs.

6. Feedback & Iteration

o Encourage frequent feedback loops through testing, prototyping, and usability

evaluations.

o Implement continuous integration/continuous deployment (CI/CD) to streamline

updates.

7. Conflict Resolution & Team Bonding

o Address conflicts constructively by encouraging open discussions.

o Build a positive work culture with mutual respect and accountability.

1.1 Asking the First Questions

1.1 Eliciting Requirements

1.1 Collaborative Requirements Gathering

1.1 Usage Scenarios

a
11 | P a g e © Haris Chaus | ALL RIGHTS ARE RESERVED as per copyright act.

1.1 Elicitation Work Products

1.1 Developing Use Cases

1.1 Building the Requirements Model

1.1 Elements of the Requirements Model

1.1 Negotiating Requirements

1.1 Validating Requirements