Software Requirements

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.

Characteristics of a Good Software Requirements
Specification (SRS)
An SRS should be:

Correct:
An SRS is correct if, and only if, every requirement stated therein is one
that the software shall meet. Traceability makes this procedure easier and
less prone to error.

Unambiguous:
An SRS is unambiguous if, and only if, every requirement stated therein
has only one interpretation. As a minimum, this requires that each
characteristic of the final product be described using a single unique term.

Complete:
An SRS is complete if, and only if, it includes the following elements:
 All significant requirements, whether relating to functionality, performance, design
constraints, attributes, or external interfaces. In particular any external requirements
imposed by a system specification should be acknowledged and treated.
 Definition of the responses of the software to all realizable classes of input data in all
realizable classes of situations. Note that it is important to specify the responses to both
valid and invalid input values.
 Full labels and references to all figures, tables, and diagrams in the SRS and definition of
all terms and units of measure.

Consistent:
Consistency refers to internal consistency. If an SRS does not agree with
some higher-level document, such as a system requirements specification,
then it is not correct. An SRS is internally consistent if, and only if, no
subset of individual requirements described in it conflict.

Ranked for importance and/or stability:

An SRS is ranked for importance and/or stability if each requirement in it
has an identifier to indicate either the importance or stability of that
particular requirement. Typically, all of the requirements that relate to a
software product are not equally important. Some requirements may be
essential, especially for life-critical applications, while others may be
 desirable. Each requirement in the SRS should be identified to make these
differences clear and explicit.

Verifiable:
An SRS is verifiable if, and only if, every requirement stated therein is
verifiable. A requirement is verifiable if, and only if, there exists some finite
cost-effective process with which a person or machine can check that the
software product meets the requirement.
Nonverifiable requirements include statements such as "works well", "good
human interface", and "shall usually happen". These requirements cannot
be verified because it is impossible to define the terms "good", "well", or
"usually".

Modifiable:
An SRS is modifiable if, and only if, its structure and style are such that
any changes to the requirements can be made easily, completely, and
consistently while retaining the structure and style. Modifiability generally
requires an SRS to
 Have a coherent and easy-to-use organization with a table of contents, an index, and
explicit cross-referencing;
 Not be redundant (i.e., the same requirement should not appear in more than one place in
the SRS);
 Express each requirement separately, rather than intermixed with other requirements.

Traceable:
An SRS is traceable if the origin of each of its requirements is clear and if
it facilitates the referencing of each requirement in future development or
enhancement documentation. The following two types of traceability are
recommended:
 Backward traceability (i.e., to previous stages of development). This depends upon each
requirement explicitly referencing its source in earlier documents.
 Forward traceability (i.e., to all documents spawned by the SRS). This depends upon each
requirement in the SRS having a unique name or reference number.