The software requirements are description of features and functionalities of the target

system. Requirements convey the expectations of users from the software product. The
requirements can be obvious or hidden, known or unknown, expected or unexpected
from client’s point of view.

Requirement Engineering
The process to gather the software requirements from client, analyze and document
them is known as requirement engineering.
The goal of requirement engineering is to develop and maintain sophisticated and
descriptive ‘System Requirements Specification’ document.

Requirement Engineering Process

It is a four step process, which includes –

 Feasibility Study
 Requirement Gathering
 Software Requirement Specification
 Software Requirement Validation
Let us see the process briefly -

Feasibility study
When the client approaches the organization for getting the desired product developed,
it comes up with rough idea about what all functions the software must perform and which
all features are expected from the software.
Referencing to this information, the analysts does a detailed study about whether the
desired system and its functionality are feasible to develop.
This feasibility study is focused towards goal of the organization. This study analyzes
whether the software product can be practically materialized in terms of implementation,
contribution of project to organization, cost constraints and as per values and objectives
of the organization. It explores technical aspects of the project and product such as
usability, maintainability, productivity and integration ability.
The output of this phase should be a feasibility study report that should contain adequate
comments and recommendations for management about whether or not the project
should be undertaken.

Requirement Gathering
If the feasibility report is positive towards undertaking the project, next phase starts with
gathering requirements from the user. Analysts and engineers communicate with the
client and end-users to know their ideas on what the software should provide and which
features they want the software to include.

Software Requirement Specification

SRS is a document created by system analyst after the requirements are collected from
various stakeholders.
SRS defines how the intended software will interact with hardware, external interfaces,
speed of operation, response time of system, portability of software across various
platforms, maintainability, speed of recovery after crashing, Security, Quality, Limitations
etc.
The requirements received from client are written in natural language. It is the
responsibility of system analyst to document the requirements in technical language so
that they can be comprehended and useful by the software development team.
SRS should come up with following features:

 User Requirements are expressed in natural language.

 Technical requirements are expressed in structured language, which is used inside the
organization.
 Design description should be written in Pseudo code.
 Format of Forms and GUI screen prints.
 Conditional and mathematical notations for DFDs etc.

Software Requirement Validation

After requirement specifications are developed, the requirements mentioned in this
document are validated. User might ask for illegal, impractical solution or experts may
interpret the requirements incorrectly. This results in huge increase in cost if not nipped
in the bud. Requirements can be checked against following conditions -

 If they can be practically implemented

 If they are valid and as per functionality and domain of software
 If there are any ambiguities
 If they are complete
 If they can be demonstrated

Requirement Elicitation Process

Requirement elicitation process can be depicted using the folloiwng diagram:

 Requirements gathering - The developers discuss with the client and end users and know
their expectations from the software.
 Organizing Requirements - The developers prioritize and arrange the requirements in order
of importance, urgency and convenience.
 Negotiation & discussion - If requirements are ambiguous or there are some conflicts in
requirements of various stakeholders, if they are, it is then negotiated and discussed with
stakeholders. Requirements may then be prioritized and reasonably compromised.
The requirements come from various stakeholders. To remove the ambiguity and conflicts,
they are discussed for clarity and correctness. Unrealistic requirements are compromised
reasonably.

 Documentation - All formal & informal, functional and non-functional requirements are
documented and made available for next phase processing.

Requirement Elicitation Techniques

Requirements Elicitation is the process to find out the requirements for an intended
software system by communicating with client, end users, system users and others who
have a stake in the software system development.
There are various ways to discover requirements

Interviews
Interviews are strong medium to collect requirements. Organization may conduct several
types of interviews such as:

 Structured (closed) interviews, where every single information to gather is decided in

advance, they follow pattern and matter of discussion firmly.
 Non-structured (open) interviews, where information to gather is not decided in advance,
more flexible and less biased.
 Oral interviews
 Written interviews
 One-to-one interviews which are held between two persons across the table.
 Group interviews which are held between groups of participants. They help to uncover any
missing requirement as numerous people are involved.

Surveys
Organization may conduct surveys among various stakeholders by querying about their
expectation and requirements from the upcoming system.

Questionnaires
A document with pre-defined set of objective questions and respective options is handed
over to all stakeholders to answer, which are collected and compiled.
A shortcoming of this technique is, if an option for some issue is not mentioned in the
questionnaire, the issue might be left unattended.

Task analysis
Team of engineers and developers may analyze the operation for which the new system
is required. If the client already has some software to perform certain operation, it is
studied and requirements of proposed system are collected.

Domain Analysis
Every software falls into some domain category. The expert people in the domain can
be a great help to analyze general and specific requirements.

Brainstorming
An informal debate is held among various stakeholders and all their inputs are recorded
for further requirements analysis.

Prototyping
Prototyping is building user interface without adding detail functionality for user to
interpret the features of intended software product. It helps giving better idea of
requirements. If there is no software installed at client’s end for developer’s reference
and the client is not aware of its own requirements, the developer creates a prototype
based on initially mentioned requirements. The prototype is shown to the client and the
feedback is noted. The client feedback serves as an input for requirement gathering.
Observation
Team of experts visit the client’s organization or workplace. They observe the actual
working of the existing installed systems. They observe the workflow at client’s end and
how execution problems are dealt. The team itself draws some conclusions which aid to
form requirements expected from the software.

Software Requirements Characteristics

Gathering software requirements is the foundation of the entire software development
project. Hence they must be clear, correct and well-defined.
A complete Software Requirement Specifications must be:

 Clear
 Correct
 Consistent
 Coherent
 Comprehensible
 Modifiable
 Verifiable
 Prioritized
 Unambiguous
 Traceable
 Credible source

Software Requirements
We should try to understand what sort of requirements may arise in the requirement
elicitation phase and what kinds of requirements are expected from the software system.
Broadly software requirements should be categorized in two categories:

Functional Requirements
Requirements, which are related to functional aspect of software fall into this category.
They define functions and functionality within and from the software system.

Examples -

 Search option given to user to search from various invoices.

 User should be able to mail any report to management.
 Users can be divided into groups and groups can be given separate rights.
 Should comply business rules and administrative functions.
 Software is developed keeping downward compatibility intact.

Non-Functional Requirements
Requirements, which are not related to functional aspect of software, fall into this
category. They are implicit or expected characteristics of software, which users make
assumption of.
Non-functional requirements include -

 Security
  Logging
 Storage
 Configuration
 Performance
 Cost
 Interoperability
 Flexibility
 Disaster recovery
 Accessibility
Requirements are categorized logically as

 Must Have : Software cannot be said operational without them.

 Should have : Enhancing the functionality of software.
 Could have : Software can still properly function with these requirements.
 Wish list : These requirements do not map to any objectives of software.
While developing software, ‘Must have’ must be implemented, ‘Should have’ is a matter
of debate with stakeholders and negation, whereas ‘could have’ and ‘wish list’ can be
kept for software updates.

User Interface requirements

UI is an important part of any software or hardware or hybrid system. A software is widely
accepted if it is -

 easy to operate
 quick in response
 effectively handling operational errors
 providing simple yet consistent user interface
User acceptance majorly depends upon how user can use the software. UI is the only
way for users to perceive the system. A well performing software system must also be
equipped with attractive, clear, consistent and responsive user interface. Otherwise the
functionalities of software system can not be used in convenient way. A system is said
be good if it provides means to use it efficiently. User interface requirements are briefly
mentioned below -

 Content presentation
 Easy Navigation
 Simple interface
 Responsive
 Consistent UI elements
 Feedback mechanism
 Default settings
 Purposeful layout
 Strategical use of color and texture.
 Provide help information
 User centric approach
 Group based view settings.

Software System Analyst

System analyst in an IT organization is a person, who analyzes the requirement of
proposed system and ensures that requirements are conceived and documented
properly & correctly. Role of an analyst starts during Software Analysis Phase of SDLC.
It is the responsibility of analyst to make sure that the developed software meets the
requirements of the client.
System Analysts have the following responsibilities:

 Analyzing and understanding requirements of intended software

 Understanding how the project will contribute in the organization objectives
 Identify sources of requirement
 Validation of requirement
 Develop and implement requirement management plan
 Documentation of business, technical, process and product requirements
 Coordination with clients to prioritize requirements and remove and ambiguity
 Finalizing acceptance criteria with client and other stakeholders

Software Metrics and Measures

Software Measures can be understood as a process of quantifying and symbolizing
various attributes and aspects of software.
Software Metrics provide measures for various aspects of software process and software
product.
Software measures are fundamental requirement of software engineering. They not only
help to control the software development process but also aid to keep quality of ultimate
product excellent.
According to Tom DeMarco, a (Software Engineer), “You cannot control what you cannot
measure.” By his saying, it is very clear how important software measures are.
Let us see some software metrics:
 Size Metrics - LOC (Lines of Code), mostly calculated in thousands of delivered source code
lines, denoted as KLOC.
Function Point Count is measure of the functionality provided by the software. Function Point
count defines the size of functional aspect of software.

 Complexity Metrics - McCabe’s Cyclomatic complexity quantifies the upper bound of the
number of independent paths in a program, which is perceived as complexity of the program
or its modules. It is represented in terms of graph theory concepts by using control flow
graph.
 Quality Metrics - Defects, their types and causes, consequence, intensity of severity and
their implications define the quality of product.
The number of defects found in development process and number of defects reported by the
client after the product is installed or delivered at client-end, define quality of product.

 Process Metrics - In various phases of SDLC, the methods and tools used, the company
standards and the performance of development are software process metrics.
 Resource Metrics - Effort, time and various resources used, represents metrics for resource
measurement.
 In the software development process, requirement phase is the first software engineering
activity. This phase is a user-dominated phase and translates the ideas or views into a
requirements document. Note that defining and documenting the user requirements in a
concise and unambiguous manner is the first major step to achieve a high-quality product.
The requirement phase encompasses a set of tasks, which help to specify the impact of
the software on the organization, customers' needs, and how users will interact with the
developed software. The requirements are the basis of the system design. If requirements
are not correct the end product will also contain errors. Note that requirements activity
like all other software engineering activities should be adapted to the needs of the process,
the project, the product and the people involved in the activity. Also, the requirements
should be specified at different levels of detail. This is because requirements are meant
for people such as users, business managers, system engineers, and so on. For example,
business managers are interested in knowing which features can be implemented within
the allocated budget whereas end-users are interested in knowing how easy it is to use the
features of software.

What is Software Requirement?

Requirement is a condition or capability possessed by the software or system component
in order to solve a real world problem. The problems can be to automate a part of a system,
to correct shortcomings of an existing system, to control a device, and so
on. IEEE defines requirement as (1) A condition or capability needed by a user to solve a
problem or achieve an objective. (2) A condition or capability that must be met or
possessed by a system or system component to satisfy a contract, standard, specification,
or other formally imposed documents. (3) A documented representation of a condition or
capability as in (1) or (2).’
Requirements describe how a system should act, appear or perform. For this, when users
request for software, they provide an approximation of what the new system should be
capable of doing. Requirements differ from one user to another and from one business
process to another.

Guidelines for Expressing Requirements

The purpose of the requirements document is to provide a basis for the mutual
understanding between the users and the designers of the initial definition of the software
development life cycle (SDLC) including the requirements, operating environment and
development plan.
The requirements document should include the overview, the proposed methods and
procedures, a summary of improvements, a summary of impacts, security, privacy,
internal control considerations, cost considerations, and alternatives. The requirements
section should state the functions required in the software in quantitative and qualitative
terms and how these functions will satisfy the performance objectives. The requirements
document should also specify the performance requirements such as accuracy, validation,
timing, and flexibility. Inputs, outputs, and data characteristics need to be explained.
Finally, the requirements document needs to describe the operating environment and
provide (or make reference to) a development plan.
There is no standard method to express and document requirements. Requirements can
be stated efficiently by the experience of knowledgeable individuals, observing past
requirements, and by following guidelines. Guidelines act as an efficient method of
expressing requirements, which also provide a basis for software development, system
testing, and user satisfaction. The guidelines that are commonly followed to document
requirements are listed below.
1. Sentences and paragraphs should be short and written in active voice. Also, proper
grammar, spelling, and punctuation should be used.
2. Conjunctions such as 'and' and 'or' should be avoided as they indicate the combination of
several requirements in one requirement.
3. Each requirement should be stated only once so that it does not create redundancy in the
requirements specification document.

Types of Requirements
Requirements help to understand the behavior of a system, which is described by various
tasks of the system. For example, some of the tasks of a system are to provide a response
to input values, determine the state of data objects, and so on. Note that requirements are
considered prior to the development of the software. The requirements, which are
commonly considered, are classified into three categories, namely, functional
requirements, non-functional requirements, and domain requirements.

IEEE defines functional requirements as 'a function that a system or component must be
able to perform.' These requirements describe the interaction of software with its
environment and specify the inputs, outputs, external interfaces, and the functions that
should be included in the software. Also, the services provided byfunctional requirements
specify the procedure by which the software should reactto particular inputs or behave in
particular situations.
To understand functional requirements properly, let us consider the following example of
an online banking system.
1. The user of the bank should be able to search the desired services from the available ones.
2. There should be appropriate documents' for users to read. This implies that when a user
wants to open an account in the bank, the forms must be available so that the user can
open an account.
3. After registration, the user should be provided with a unique acknowledgement number
so that he can later be given an account number.
The above mentioned functional requirements describe the specific services provided by
the online banking system. These requirements indicate user requirements and specify
that functional requirements may be described at different levels of detail in an online
banking system. With the help of these functional requirements, users can easily view,
search and download registration forms and other information about the bank. On the
other hand, if requirements are not stated properly, they are misinterpreted by software
engineers and user requirements are not met.
The functional requirements should be complete and consistent. Completeness implies
that all the user requirements are defined. Consistency implies that all requirements are
specified clearly without any contradictory definition. Generally, it is observed that
completeness and consistency cannot be achieved in large software or in a complex
system due to the problems that arise while defining the functional requirements of these
systems. The different needs of stakeholders also prevent the achievement of
completeness and consistency. Due to these reasons, requirements may not be obvious
when they are,'first specified and may further lead to inconsistencies in the requirements
specification.
The non-functional requirements (also known as quality requirements) are related to
system attributes such as reliability and response time. Non-functional requirements
arise due to user requirements, budget constraints, organizational policies, and so on.
These requirements are not related directly to any particular function provided by the
system.
Non-functional requirements should be accomplished in software to make it perform
efficiently. For example, if an aeroplane is unable to fulfill reliability requirements, it is
not approved for safe operation. Similarly, if a real time control system is ineffective in
accomplishing non-functional requirements, the control functions cannot operate
correctly.
 The description of different types of non-functional requirements is listed below.
1. Product requirements: These requirements specify how software product performs.
Product requirements comprise the following.
2. Efficiency requirements: Describe the extent to which the software makes optimal
use of resources, the speed with which the system executes, and the memory it consumes
for its operation. For example, the system should be able to operate at least three times
faster than the existing system.
3. Reliability requirements: Describe the acceptable failure rate of the software. For
example, the software should be able to operate even if a hazard occurs.
4. Portability requirements: Describe the ease with which the software can be
transferred from one platform to another. For example, it should be easy to port the
software to a different operating system without the need to redesign the entire software.
5. Usability requirements: Describe the ease with which users are able to operate the
software. For example, the software should be able to provide access to functionality with
fewer keystrokes and mouse clicks.
6. Organizational requirements: These requirements are derived from the policies and
procedures of an organization. Organizational requirements comprise the following.
7. Delivery requirements: Specify when the software and its documentation are to be
delivered to the user.
8. Implementation requirements: Describe requirements such as programming
language and design method.
9. Standards requirements: Describe the process standards to be used during software
development. For example, the software should be developed using standards specified
by the ISO and IEEE standards.
10. External requirements: These requirements include all the requirements that affect
the software or its development process externally. External requirements comprise the
following.
11. Interoperability requirements: Define the way in which different computer based
systems will interact with each other in one or more organizations.
12. Ethical requirements: Specify the rules and regulations of the software so that they
are acceptable to users.
13. Legislative requirements: Ensure that the software operates within the legal
jurisdiction. For example, pirated software should not be sold.

Non-functional requirements are difficult to verify. Hence, it is essential to write non-

functional requirements quantitatively, so that they can be tested. For this, non-
functional requirements metrics are used. These metrics are listed in Table.
Metrics for Non-functional Requirements

Features Measures
 Processed transaction/ second
Speed
 User/event response time
 Screen refresh rate

 Amount of memory (KB)

Size
 Number of RAM chips.

 Training time
Ease of use
 Number of help windows

 Mean time to failure (MTTF)

Reliability
 Portability of unavailability
 Rate of failure occurrence
 Time to restart after failure

Robustness
 Percentage of events causing failure
 Probability of data corruption on
failure

 Percentage of target-dependent
Portability
statements
 Number of target systems

Requirements which are derived from the application domain of the system instead from
the needs of the users are known as domain requirements. These requirements may
be new functional requirements or specify a method to perform some particular
computations. In addition, these requirements include any constraint that may be present
in the existing functional requirements. As domain requirements reflect the fundamentals
of the application domain, it is important to understand these requirements. Also, if these
requirements are not fulfilled, it may be difficult to make .the system work as desired.
A system can include a number of domain requirements. For example, it may comprise a
design constraint that describes the user interface, which is capable of accessing all the
databases used in a system. It is important for a development team to create databases
and interface designs as per established standards. Similarly, the requirements of the user
such as copyright restrictions and security mechanism for the files and documents used
in the system are also domain requirements. When domain requirements are not
expressed clearly, it can result in the following difficulties.
Problem of understandability: When domain requirements are specified in the
language of application domain (such as mathematical expressions), it becomes difficult
for software engineers to understand them.
Problem of implicitness: When domain experts understand the domain requirements
but do not express these requirements clearly, it may create a problem (due to incomplete
information) for the development team to understand and implement the requirements
in the system.

Note: Information about requirements is stored in a database, which helps the

software development team to understand user requirements and develop the
software according to those requirements.

Requirements Engineering Process

This process is a series of activities that are performed in the requirements phase to
express requirements in the Software Requirements Specification (SRS)document. It
focuses on understanding the requirements and its type so that an appropriate technique
is determined to carry out the Requirements Engineering (RE) process. The new
software developed after collecting requirements either replaces the existing software or
enhances its features and functionality. For example, the payment mode of the existing
software can be changed from payment through hand-written cheques to electronic
payment of bills.
An RE process is shown, which comprises various steps including feasibility study,
requirements elicitation, requirements analysis, requirements specification,
requirements validation, and requirements management.

The requirements engineering process begins with feasibility study of the requirements.
Then requirements elicitation is performed, which focuses on gathering user
requirements. After the requirements are gathered, an analysis is performed, which
further leads to requirements specification. The output of this is stored in the form of
software requirements specification document. Next, the requirements are checked for
their completeness and correctness in requirements validation. Last of all, to understand
and control changes to system requirements, requirements management is performed.
Software Engineering | Classification of Software
Requirements
According to IEEE standard 729, a requirement is defined as follows:
 A condition or capability needed by a user to solve a problem or achieve an objective
 A condition or capability that must be met or possessed by a system or system component
to satisfy a contract, standard, specification or other formally imposed documents
 A documented representation of a condition or capability as in 1 and 2.
A software requirement can be of 3 types:
 Functional requirements
 Non-functional requirements
 Domain requirements

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.
For example, in a hospital management system, a doctor should be able to retrieve the
information of his patients. Each high-level functional requirement may involve several
interactions or dialogues between the system and the outside world. In order to
accurately describe the functional requirements, all scenarios must be enumerated.
There are many ways of expressing functional requirements e.g., natural language, a
structured or formatted language with no rigorous syntax and formal specification
language with proper syntax.
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 other. They are also called
non-behavioral requirements.
They basically deal with issues like:
 Portability
 Security
 Maintainability
 Reliability
 Scalability
 Performance
 Reusability
 Flexibility
NFR’s are classified into following types:
 Interface constraints
 Performance constraints: response time, security, storage space, etc.
 Operating constraints
 Life cycle constraints: mantainability, portability, etc.
 Economic constraints
The process of specifying non-functional requirements requires the knowledge of the
functionality of the system, as well as the knowledge of the context within which the
system will operate.
Domain requirements: Domain requirements are the requirements which are
characteristic of a particular category or domain of projects. The basic functions that a
system of a specific domain must necessarily exhibit come under this category. For
instance, in an academic software that maintains records of a school or college, the
functionality of being able to access the list of faculty and list of students of each grade
is a domain requirement. These requirements are therefore identified from that domain
model and are not user specific.