Requirement Engineering in Software Engineering

Requirements engineering is a very important first step in making software. It

connects what stakeholders (like clients or users) want with what the software can
actually do, helping to plan the project's goals, time, and results. This step decides
what the software should do, how long it will take, and what the final result will
be.
This process means finding out what users need, deciding what the system should
do, and handling any limits or rules. It includes collecting, writing down, studying,
and checking these needs in an organized way. Working together with all involved
people is very important, and writing everything clearly helps developers
understand what the project is really about.
Effective requirements engineering demands iterative refinement and validation,
creating accurate and achievable project goals, while also preventing scope
changes and project failures [means improving and checking the requirements
again and again. This helps make clear and possible project goals, and also avoids
sudden changes or failure.] It is not a one-time task—it continues throughout the
software development process. Checking and updating the requirements again
and again is important for the project's success
Requirement Engineering Process
Requirement Engineering is an important part of software development. It focuses
on finding out what users and stakeholders need, writing it down clearly, checking
if it's correct, and managing any changes. This helps make sure the final software
does what users want. The process includes several steps to make sure the
software meets all needs and expectations.
1. Feasibility Study
This is the first step in requirement engineering. It checks if the software project is
possible and worth doing. The goal is to see if the project can be built, is
affordable, and will work well in the real environment.
Technical Feasibility: Can we build the system with current technology and
resources?
Economic Feasibility: Will the project be cost-effective and give good results?
Operational Feasibility: Will the system work well with the current company
processes?
2. Requirement Elicitation and Analysis
In this step, we gather and understand what the users and stakeholders want from
the system. The goal is to understand the needs of the system and translate them
into specific software requirements
Techniques used:
 Interviews: Talking directly to users.
 Surveys: Using questionnaires.
 Workshops: Group discussions to collect ideas.
 Observation: Watching how users do their work.
 Prototyping: Making a basic model to get feedback.
After gathering, we check the requirements for any conflicts or missing parts and
organize them into types:
 Functional requirements: What the system should do.
 Non-functional requirements: How the system should perform (speed,
security, etc.).
3. Software Requirement Specification (SRS)
In this phase, we write all the requirements in a proper document called
the SRS. This document guides the whole development process.
It includes:
 Functional Requirements: System features and actions.
 Non-functional Requirements: Performance, reliability, etc.
 User Interfaces: How users will interact with the system.
  Data Requirements: What data will be stored and used.

4. Requirement Validation

This step checks if the documented requirements are correct and match what
the users actually want.

Methods used:

 Reviews: Experts check the SRS for errors.

 Prototyping: Create a model to confirm the requirements.

 Simulation: Test system behavior based on the requirements.

5.Requirement Management
Requirements may change over time, so we need to manage them properly
during the whole project.
Activities include:
 Version Control: Managing different versions of the requirements
document.
 Change Control: Managing and documenting changes to requirements and
their impact.
 Traceability: Establishing links between requirements and design,
implementation, and testing.

 Prioritization: Deciding which requirements are most important.

 Communication: Ensuring stakeholders are informed about changes and
updates to requirements.

2. Challenges and Risks in the Requirement Engineering Process

There are some common problems that can happen during requirement
engineering:
• Incomplete Requirements
  Stakeholders may forget to mention some needs or give only partial
information.
 This can lead to software that doesn’t work as expected or misses
important features.
• Ambiguous Requirements
 Requirements may be written in a way that is unclear or has more than one
meaning.
 This can confuse the team, cause design mistakes, and slow down
development.
• Changing Requirements
 Stakeholders’ needs or market trends may change during the project.
 Frequent changes can increase the project size (scope creep), raise costs,
and cause delays.
• Conflicting Requirements
 Different stakeholders might want different or opposite things.
 These conflicts need discussion and compromises to find a balanced
solution.
• Poor Requirement Traceability
 It can be hard to track each requirement from start to finish.
 Without proper tracking, some requirements may be missed or not tested,
reducing software quality.
3. Tools Involved in Requirement Engineering :
Requirement Engineering is an important part of software development. It
helps in understanding, writing down, and managing what users and
stakeholders need from a software system.
To do this well, different tools are used to help collect, write, check, and organize
the requirements during the whole project.
These tools help in:
Capturing what users want, Analyzing the needs, Validating if requirements are
correct, Managing changes and updates
They make the process easier, more accurate, and help teams meet the project's
goals.
1. Document Editors and Word Processors:
Tools like MS Word, Google Docs and LaTeX are used to write requirement
documents.
2. Spreadsheet Tools
Tools like MS Excel and Google Sheets are good for making lists and tables to
organize and manage requirements.
3. Diagramming Tools
Tools like draw.io, Lucidchart, and MS Visio are used to make diagrams that
show how the system works and how data flows.
4. Requirements Management Tools
These tools help in storing, organizing, and tracking requirements.
Examples: IBM DOORS, Jama Connect, Helix RM.
5. Prototyping Tools
Tools like Balsamiq, Sketchand Axure help create simple models of the
software so users can see how it will look and work.
6. Modeling Languages
Languages like UML (Unified Modeling Language) are used to draw diagrams
that explain system structure and behavior.
7. Collaboration Tools
Tools like MS Teams, Confluence, and SharePoint help team members work
together, share documents, and give feedback.
8. Requirement Elicitation Tools
These include interviews, surveys, questionnaires, and workshops used to
collect information directly from users.
9. Validation and Verification Tools
These tools check if the requirements are correct and complete. They help find
mistakes early.
Examples: Static analysis tools, simulations, formal methods.
10. Traceability Tools
These tools connect requirements to design, code, and testing.
They make sure all requirements are followed and tested.
4. Advantages of Requirements Engineering :
Requirements Engineering (RE) offers many benefits to software development. It
helps create software that meets user needs and ensures a smooth, cost-effective
process.
1. Customer Satisfaction
Clear requirements help create software that users want, making them happy.
2. Early Issue Detection
Finding problems early avoids expensive mistakes later.
3. Cost and Time Savings
Clear requirements help save time and money by avoiding unnecessary work.
4. Effective Planning
Clear requirements help plan the project better and use resources wisely.
5. Traceability
Tracking requirements helps understand the effect of any changes.
6. Validation and Verification
Accurate requirements help check if the software works correctly.
7. Collaboration
Involving stakeholders helps everyone work together and share ideas.
 8. Scope Management
Clear requirements prevent the project from growing out of control.
9. Risk Mitigation
Good requirements help find and manage risks early on.
10. Quality Assurance
Clear requirements lead to higher-quality software and better testing.
11. Regulatory Compliance
Well-defined requirements help meet industry rules and standards.
12. Documentation and Maintenance
Good requirements serve as helpful notes for future changes.
13. User Involvement
Getting user input ensures the software meets their needs.
14. Change Management
Requirements make it easier to manage changes during the project.
15. Long-Term Benefits
Spending time on good requirements helps the software in the long run.

5. Disadvantages of Requirements Engineering

While Requirements Engineering (RE) is important, it also has some challenges
that can affect the project.
1. Ambiguity
Unclear requirements can cause confusion and mistakes.
2. Scope Creep
Adding too many requirements can slow down the project and cost more.
3. Changing Requirements
Frequent changes can delay the project and cause extra work.
4. User Involvement Challenges
Sometimes it is hard to involve users, which can cause missing important things
they need
5. Overemphasis on Documentation
Spending too much time on writing can slow down development.
6. Miscommunication
Bad communication can cause misunderstandings between stakeholders and
developers.
7. Time-Consuming Process
Collecting and analyzing requirements can take a lot of time.
8. Resistance to Change
Stakeholders might not want to change the original requirements.
9. Dependency on Tools
Relying too much on tools can be risky if they fail or become outdated.
10. Neglecting Non-Functional Requirements
Focusing only on features might ignore important things like performance and
security.
6. Compare Different Requirement Engineering Approaches
1. Waterfall Model
Steps are followed one after another, like a waterfall. Sequential and
linear approach.
Everything is planned and written before moving to the next step.
Hard to make changes once a step is done.
2. Agile Methodology
Work is done in small steps or "sprints." Iterative and incremental
approach.
Focus is on building working software, not just writing everything down.
Easy to make changes as the project goes on.
3. Prototyping
A rough version (prototype) of the system is made first.
Used to get feedback and understand unclear needs.
If not controlled, the project can keep expanding.
4. Spiral Model
Combines iterative development with risk management.
Mix of repeating steps (like Agile) and risk checking.
Each round handles risks and builds part of the system.
Good for complex and risky projects.
5. Use Case-driven Approach
Focuses on what users want to do with the system.
Describes actions and user interactions as "use cases."
Helps understand system behavior from the user's point of view.