Module-2_Requirement Engineering
Module-2_Requirement Engineering
Requirements Engineering
● Domain requirements reflect the environment in which the system operates so, when
we talk about an application domain we mean environments such as train operation,
medical records, e-commerce etc.
● We typically start by gathering the requirements, this could be done through a general
discussion or interviews with your stakeholders, also it may involve some graphical
notation.
● Then you organize the related requirements into sub-components and prioritize them,
and finally, you refine them by removing any ambiguous requirements that may arise
from some conflicts.
● That’s because stakeholders may not know what exactly they want the software to do,
or they may give unrealistic requirements.
● They may give different requirements, which will result in conflict between the
requirements, so we have to discover and resolve these conflicts.
● Also, there might be some factors that influence the stakeholder’s decision, like, for
example, managers at a company or professors at the university want to take full control
over the management system.
Prepared & Compiled by: Prof. Bhupendra Panchal
Requirements Elicitation and Analysis
2. Requirements Classification & Organization
● It’s very important to organize the overall structure of the system.
● Putting related requirements together, and decomposing the system into sub-
components of related requirements.
● Then, we define the relationship between these components.
● What we do here will help us in the decision of identifying the most suitable
architectural design patterns.
User Requirements
● The user requirements for a system should describe the functional and non-functional
requirements so that they are understandable by users who don’t have technical
knowledge.
● You should write user requirements in natural language supplied by simple tables, forms,
and intuitive diagrams.
● The requirement document shouldn’t include details of the system design, and you
shouldn’t use any software jargon or formal notations.
Functional Requirements:
● These are the requirements that the end user specifically demands as basic facilities
that the system should offer.
● All these functionalities need to be necessarily incorporated into the system as a part
of the contract.
● These are represented or stated in the form of input to be given to the system, the
operation performed and the output expected.
● They are basically the requirements stated by the user which one can see directly in the
final product, unlike the non-functional requirements.
Non-Functional Requirements:
● These are basically the quality constraints that the system must satisfy according to the
project contract.
● The priority or extent to which these factors are implemented varies from one project
to another. They are also called non-behavioral requirements. They basically deal with
issues like:
● Portability ● Scalability
● Security ● Performance
● Maintainability ● Reusability
● Reliability ● Flexibility
Prepared & Compiled by: Prof. Bhupendra Panchal
Functional vs Non-Functional Requirements
Functional Requirements Non-Functional Requirements
A functional requirement defines a system or its A non-functional requirement defines the quality
components. attribute of a software system.
It places constraints on “How should the software
It specifies “What should the software system do?”
system fulfil the functional requirements?”
Non-functional requirement is specified by technical
Functional requirement is specified by User. peoples e.g. Architect, Technical leaders and
software developers.
It is mandatory. It is not mandatory.
It is captured in use case. It is captured as a quality attribute.
Helps you to verify the functionality of the software. Helps you to verify the performance of the software.
Functional Testing like System, Integration, End to End, Non-Functional Testing like Performance, Stress,
API testing, etc are done. Prepared & Compiled by: Prof.Usability,
Bhupendra Security
Panchal testing, etc are done.
Functional vs Non-Functional Requirements
Functional Requirements Non-Functional Requirements
Usually easy to define. Usually more difficult to define.
Example Example
1) Authentication of the user whenever he/she logs into 1) Emails should be sent with a latency of no greater
the system. than 12 hours from such an activity.
2) System shutdown in case of a cyber attack. 2) The processing of each request should be done
3) A Verification email is sent to the user whenever within 10 seconds
he/she registers for the first time on some software 3) The site should load in 3 seconds when the
system. number of simultaneous users are > 10000
System Requirements
● The system requirements on the other hand are an expanded version of the user
requirements that are used by software engineers as the starting point for the system
design.
● They add detail and explain how the user requirements should be provided by the
system. They shouldn’t be concerned with how the system should be implemented or
designed.
● The system requirements may also be written in natural language but other ways based
on structured forms, or graphical notations are usually used.
● The two methods create entirely various situations and establish different
purposes for the document altogether.
● The first case, SRS, is used to define the needs and expectations of the users.
The second case, SRS, is written for various purposes and serves as a contract
document between customer and developer.
Prepared & Compiled by: Prof. Bhupendra Panchal
What is an SRS?
1. Correctness: User review is used to provide the accuracy of requirements stated in the SRS. SRS is
said to be perfect if it covers all the needs that are truly expected from the system.
2. Completeness: The SRS is complete if, and only if, it includes the following elements:
(1). All essential requirements, whether relating to functionality, performance, design, constraints, attributes,
or external interfaces.
(2). Full labels and references to all figures, tables, and diagrams in the SRS and definitions of all terms and
units of measure.
3. Consistency: The SRS is consistent if, and only if, no subset of individual requirements described in its
conflict. There are three types of possible conflict in the SRS:
(1). The specified characteristics of real-world objects may conflicts.
(2). There may be a reasonable or temporal conflict between the two specified actions.
(3). Two or more requirements may define the same real-world object but use different terms for that object.
Prepared & Compiled by: Prof. Bhupendra Panchal
Characteristics of good SRS
4. Unambiguousness: SRS is unambiguous when every fixed requirement has only one interpretation. This
suggests that each element is uniquely interpreted.
5. Ranking for importance and stability: The SRS is ranked for importance and stability if each
requirement in it has an identifier to indicate either the significance or stability of that particular requirement.
6. Modifiability: SRS should be made as modifiable as likely and should be capable of quickly obtain
changes to the system to some extent. Modifications should be perfectly indexed and cross-referenced.
7. Verifiability: SRS is correct when the specified requirements can be verified with a cost-effective system
to check whether the final software meets those requirements. The requirements are verified with the help of
reviews.
8. Traceability: The SRS is traceable if the origin of each of the requirements is clear and if it facilitates the
referencing of each condition in future development or enhancement documentation.
Prepared & Compiled by: Prof. Bhupendra Panchal
Essential properties of a good SRS
• Concise: The SRS report should be concise and at the same time, unambiguous, consistent, and
complete.
• Black-box view: It should only define what the system should do and refrain from stating how to do
these. This means that the SRS document should define the external behavior of the system and not
discuss the implementation issues.
• Conceptual integrity: It should show conceptual integrity so that the reader can merely understand it.
Response to undesired events: It should characterize acceptable responses to unwanted events.
• Verifiable: All requirements of the system, as documented in the SRS document, should be correct. This
means that it should be possible to decide whether or not requirements have been met in an
implementation.
Prepared & Compiled by: Prof. Bhupendra Panchal
Prepared & Compiled by: Prof. Bhupendra Panchal
Module-2
Software Measurement
2. External metrics: External metrics are used for measuring properties that are viewed to be of
greater importance to the users, e.g., portability, reliability, functionality, usability, etc.
3. Hybrid metrics: Hybrid metrics combine product, process, and resource metrics. For example, cost
per FP where FP stands for Function Point Metric.
4. Project metrics: Project metrics are used by the project manager to check the project's progress.
Data from the past projects arePrepared
used &toCompiled
collect various metrics, like time and cost.
by: Prof. Bhupendra Panchal
Classification of Software Metrics
1. Product Metrics
2. Process Metrics
3. Project Metrics
• Effective software project estimation is one of the most challenging and important
activities in software development. Proper project planning and control is not
possible without a sound and reliable estimate.
• Estimation is the process of finding an estimate, or approximation, which is a value
that can be used for some purpose even if input data may be incomplete, uncertain,
or unstable.
• Software development estimation revolves around predicting the project’s time,
effort, cost, and resources; all this information is necessary for the planning
stage and to ensure the project’s success.
• 3. Embedded – A software project requiring the highest level of complexity, creativity, and
experience requirement fall under this category. Such software requires a larger team size
than the other two models and also the developers need to be sufficiently experienced and
creative to develop such complex models.
Prepared & Compiled by: Prof. Bhupendra Panchal
Prepared & Compiled by: Prof. Bhupendra Panchal
Prepared & Compiled by: Prof. Bhupendra Panchal
2. Intermediate Model –
• 2. Intermediate Model – The basic Cocomo model assumes that the effort is only a function
of the number of lines of code and some constants evaluated according to the different
software systems. However, in reality, no system’s effort and schedule can be solely
calculated on the basis of Lines of Code.
• For that, various other factors such as reliability, experience, and Capability. These factors
are known as Cost Drivers and the Intermediate Model utilizes 15 such drivers for cost
estimation.
• Provides a systematic way to estimate the cost and effort of a software project.
• Can be used to estimate the cost and effort of a software project at different stages of the
development process.
• Helps in identifying the factors that have the greatest impact on the cost and effort of a
software project.
• Can be used to evaluate the feasibility of a software project by estimating the cost and
effort required to complete it.
• Assumes that the size of the software is the main factor that determines the cost and effort
of a software project, which may not always be the case.
• Does not take into account the specific characteristics of the development team, which can
have a significant impact on the cost and effort of a software project.
• Does not provide a precise estimate of the cost and effort of a software project, as it is
based on assumptions and averages.