Unit-2

Requirement Elicitation, Analysis, and Specification:

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.

Types of requirements

BABOK, which is a recognized set of business analysis industry standards, offers the following
classification of requirements.

i)Business requirements

These include high-level statements of goals, objectives, and needs. Business requirements do
not include any details or specific features. They just state the problem and the business objective
to be achieved such as

 increased revenue/throughput/customer reach,

 reduced expenses/errors,

 improved customer service, etc.

ii)User (stakeholder) requirements

The needs of discrete stakeholder groups (top-level managers, nonmanagement staff, customers,
etc.) are specified to define what they expect from a particular solution. This group serves as a
bridge between the generalized business requirements and specific solution requirements. They
are outlined in a User Requirements Specification and can include, for example, ability to create
various reports, view order history and status, manage customer databases, etc.

iii)Solution requirements

Solution requirements describe specific characteristics that a product must have to meet the
needs of the stakeholders and the business itself. They fall into two large groups.

 Functional requirements define what a product must do, what its features and functions
are.

 Nonfunctional requirements describe the general properties of a system. They are also
known as quality attributes.
iv)Transition requirements

An additional group of requirements defines what is needed from an organization to successfully

move from its current state to its desired state with the new product. They are only necessary for
the short period of time while the transition takes place. Examples can be “users must be trained
to operate the system” or “previous data must be migrated to the cloud storage.”.

Functional vs nonfunctional requirements

Functional requirements are product features or functions that developers must implement to
enable users to accomplish their tasks. So, it’s important to make them clear both for the
development team and the stakeholders. Generally, functional requirements describe system
behavior under specific conditions. For example:

The system sends an approval request after the user enters personal information.

A search feature allows a user to hunt among various invoices if they want to credit an issued
invoice.

The system sends a confirmation email when a new user account is created.

Nonfunctional requirements, not related to the system functionality, rather define how the
system should perform. Some examples are:

The website pages should load in 3 seconds with the total number of simultaneous users <5
thousand.

The system should be able to handle 20 million users without performance deterioration.

Here’s a brief comparison and then we’ll proceed to a more in-depth explanation of each group.
Functional vs nonfunctional requirements

Types of functional requirements and their specifications

Functional requirements can be classified according to different criteria. For example, we can
group them on the basis of the functions a given feature must perform in the end product. Of
course, they would differ depending on the product being developed, but for the sake of an
example, the types of functional requirements might be

 Authentication

 Authorization levels

 Compliance to laws or regulations

 External interfaces

 Transactions processing

 Reporting

 Business rules, etc.

Requirements are usually written in text, especially for Agile-driven projects. However, they
may also be visuals. Here are the most common formats and documents:

 Software requirements specification document

 Use cases

 User stories

 Work Breakdown Structure (WBS), or functional decomposition

 Prototypes

 Models and diagrams

Let’s see what each of them is about.

Software requirements specification document

Both functional and nonfunctional requirements can be formalized in the software requirements
specification (SRS) document. To learn more about software documentation in general, read our
article on that topic. The SRS contains descriptions of functions and capabilities that the product
must provide. The document also defines constraints and assumptions. The SRS can be a single
document communicating functional requirements or it may accompany other software
documentation like user stories and use cases.
We don’t recommend composing SRS for the entire solution before the development kick-off,
but you should document the requirements for every single feature before actually building it.
Once you receive the initial user feedback, you can update the document.

SRS must include the following sections:

Purpose. Definitions, system overview, and background.

Overall description. Assumptions, constraints, business rules, and product vision.

Specific requirements. System attributes, functional requirements, and database requirements.

It’s essential to make the SRS readable for all stakeholders. You also should use templates with
visual emphasis to structure the information and aid in understanding it. If you have
requirements stored in some other document formats, provide a link to them so that readers can
find the needed information.

Example: If you’d like to see an actual document, download this SRS example created at
Michigan State University, which includes all points mentioned above in addition to presenting
use cases to illustrate parts of the product. Below is a concise list of SRS contents.
A template for a software requirements specification, source: Software Requirements by Karl
Wiegers Joy Beatty

Use cases

Use cases describe the interaction between the system and external users that leads to achieving
particular goals.

Each use case includes three main elements:

Actors. These are the external users that interact with the system.

System. The system is described by functional requirements that define an intended behavior of
the product.

Goals. The purposes of the interaction between the users and the system are outlined as goals.

There are two formats to represent use cases:

 Use case specification structured in textual format

 Use case diagram

A use case specification represents the sequence of events along with other information that
relates to this use case. A typical use case specification template includes the following
information:

 Description

 Pre- and Post- interaction condition

 Basic interaction path

 Alternative path

 Exception path

Example:
Use case specification template

A use case diagram doesn’t contain a lot of details. It shows a high-level overview of the
relationships between actors, different use cases, and the system.

The use case diagram includes the following main elements:

 Use cases. Usually drawn with ovals, use cases represent different interaction scenarios
that actors might have with the system (log in, make a purchase, view items, etc.).

 System boundaries. Boundaries are outlined by the box that groups various use cases in
a system.

 Actors. These are the figures that depict external users (people or systems) that interact
with the system.

 Associations. Associations are drawn with lines showing different types of relationships
between actors and use cases.

Example:
Use case diagram example

User stories

A user story is a documented description of a software feature seen from the end-user
perspective. The user story describes what exactly the user wants the system to do. In Agile
projects, user stories are organized in a backlog, which is an ordered list of product functions.
Currently, user stories are considered to be the best format for backlog items.

A typical user story is written like this:

As a <type of user>, I want <some goal> so that <some reason>.

Example:

As an admin, I want to add descriptions to products so that users can later view these
descriptions and compare the products.

User stories must be accompanied by acceptance criteria. These are the conditions that the
product must satisfy to be accepted by a user, stakeholders, or a product owner. Each user story
must have at least one acceptance criterion. Effective acceptance criteria must be testable,
concise, and completely understood by all team members and stakeholders. They can be written
as checklists, plain text, or by using Given/When/Then format.

Example:

Here’s an example of the acceptance criteria checklist for a user story describing a search
feature:

 A search field is available on the top-bar.

 A search is started when the user clicks Submit.

 The default placeholder is a grey text Type the name.

 The placeholder disappears when the user starts typing.

 The search language is English.

 The user can type no more than 200 symbols.

 It doesn’t support special symbols. If the user has typed a special symbol in the search
input, it displays the warning message: Search input cannot contain special symbols.

Finally, all user stories must fit the INVEST quality model:

 I – Independent

 N – Negotiable

 V – Valuable

 E – Estimable

 S – Small

 T – Testable

Independent. This means that you can schedule and implement each user story separately. This
is very helpful if you implement continuous integration processes.

Negotiable. This means that all parties agree to prioritize negotiations over specification. This
also means that details will be created constantly during development.

Valuable. A story must be valuable to the customer. You should ask yourself from the
customer’s perspective “why” you need to implement a given feature.

Estimable. A quality user story can be estimated. This will help a team schedule and prioritize
the implementation. The bigger the story is, the harder it is to estimate it.
Small. Good user stories tend to be small enough to plan for short production releases. Small
stories allow for more specific estimates.

Testable. If a story can be tested, it’s clear enough and good enough. Tested stories mean that
requirements are done and ready for use.

Functional decomposition or Work Breakdown Structures (WBS)

A functional decomposition or WBS is a visual document that illustrates how complex processes
break down into their simpler components. WBS is an effective approach to allow for an
independent analysis of each part. WBS also helps capture the full picture of the project.

We suggest the following logic of functional decomposition:

1. Find the most general function.

2. Find the closest sub function.

3. Find the next level of sub function.

4. Check your diagram.

Or the decomposition process may look like this:

High Level Function ->Sub-function -> Process -> Activity

The features should be decomposed to the point at which the lowest level parts can’t be broken
down any further.

Example:

An example of a functional decomposition

Software prototypes

Software prototype is an umbrella term for different forms of early stage deliverables that are
built to showcase how requirements must be implemented. Prototypes help bridge the vision
gaps and let stakeholders and teams clarify complicated areas of products in development.
Traditionally, prototypes represent how the solution will work and give examples of how users
will interact with it to accomplish their tasks.

Prototypes can be cheap and fast visual representations of requirements (throwaway prototypes)
or more complex ones (evolutionary prototypes). The latter can even become the early versions
of the product that already have some pieces of the final code. Effectively, evolutionary
prototypes may even turn into minimum viable products or MVPs that we’ve described in a
separate article.

Design documents and prototypes

Design requirements are usually collected and documented using three main formats that morph
into one another:

Wireframes. Wireframes are low-fidelity graphic structures of a website or an app. They help
map different product pages with sections and interactive elements.

Wireframe example
Mockups. Once wireframes are ready, they are turned into mockups, visual designs that convey
the look and feel of the final product. Eventually, mockups can become the final design of the
product.

Design prototypes. These documents contain visuals and allow for some interface interactions,
like scrolling, clicking on links, or filling in forms. Design prototypes can be built from scratch
using HTML and CSS, but most UX teams use prototyping services like InVision.

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.