Requirement Engineering Module

By Abenezer Fantu
Chapter one: Introduction to Requirement Engineering
1.1 What are requirements
Requirements are defined during the early stages of a system development as a
specification of what should be implemented. They are descriptions of how the system
should behave, or of a system property or attribute. They may be a constraint on the
development process of the system. Therefore, a requirement might describe:
• a user-level facility (e.g., 'the word processor must include a spell checking and
correction command'},
• a very general system property (e.g., 'the system must ensure that personal information
is never made available without authorization'),
• a specific constraint on the system (e.g., 'the sensor must be polled 10 times per
second'},
• a constraint on the development of the system (e.g., 'the system must be developed
using Ada'). Some people suggest that requirements should always be statements of what
a system should do rather than a statement of how it should do it. This is an attractive idea
but it is too simplistic in practice.
1. The readers of a document are often practical engineers who can relate to
implementation descriptions much better than they can understand very abstract problem
statements. You have to write requirements which are understandable to the likely readers
of the document.
2. In almost all cases, the system being specified is only one of several systems in an
environment. To be compatible with its environment, and to conform to standards and with
organizational concerns, you may have to specify implementation policies which constrain
the options of the system designers. Requirements therefore invariably contain a mixture
of problem information, statements of system behavior and properties and design and
manufacturing constraints.
What are the levels and types of Requirements?

Figure 1: Types of Requirements

1.2 What is the difference between Functional and Non-Functional Requirements

Very roughly, functional requirements describe what the system should do and non-
functional requirements place constraints on how these functional requirements are
implemented. A functional requirement might state that a system must provide some
facility for authenticating the8 Introduction identity of a system user; a non-functional
requirement might state that the authentication process should be completed in four
seconds or less. However, it is not always as simple as this. The same functional
authentication requirement could have a supplementary requirement which stated that a
specific signature verification system (which was known to work in less than four seconds)
should be used for authentication. This could be interpreted as either a functional
requirement or a non-functional requirement according to the above definition. High-level
non-functional requirements are often decomposed into functional system requirements.

1.3 What is Requirements Engineering

Requirements engineering is a relatively new term which has been invented to cover all of
the activities involved in discovering, documenting, and maintaining a set of requirements
for a computer-based system. The use of the term 'engineering' implies that systematic and
repeatable techniques should be used to ensure that system requirements are complete,
consistent, relevant, etc. The term 'requirements engineering' has come from a system
engineering background; if you are from a commercial systems background, you can think
of requirements engineering as more or less the same thing as systems analysis.
Most of the guidelines in the book apply to system requirements engineering. That is, they
apply to systems implemented as software, hardware, or by the people involved with the
system. However, in some cases, the guidelines only really make sense when applied to
software requirements. This is normally obvious from the guideline text.

1.4 What is a Requirements Document

The requirements document is an official statement of the system requirements for
customers, end-users and software depending on the organization, the requirements
document may have different names such as the 'functional specification', 'the
requirements definition', 'the software requirements specification (SRS)', 'the
safety/reliability plan', etc. We use the term 'requirements document' in this book to cover
all of these.
1.5 What is the best way to write a Requirements Document
There is no best way to write requirements. It depends on normal organizational practice
and the notations which are used by writers and readers of the requirements.
Requirements may be stated in a language which reflects the background of the
requirement source. If the source is an engineer, it may be written in engineering terms;
if the source is a manager, it will be written in natural language. Most requirements are
written as natural language sentences supplemented with diagrams and tables of
detailed information. We make no assumptions in this book about how you write
requirements nor are we trying to sell any particular notation for requirements
specification.
Chapter Two: Requirement Engineering Process
2.1 Process Maturity
The idea of 'process maturity' came about through the work of the US Department of Defense's
Software Engineering Institute. They developed a method of assessing ~he capabilities of
companies bidding for defense contracts and this has become known as the 'Capability
Maturity Model' (CMM). This model rates organizations on a scale from 1 to 5. The higher
the rating, the higher the maturity of the organization. The assumption is that the more mature
the process used to develop software, the better the software systems will be.
The basic idea underlying the CMM approach is that organizations should assess their
maturity then introduce process changes which will enable them to progress up the maturity
'ladder' in a five-stage process. The steps in this maturity ladder are shown in Figure 2.2. The
five levels in the SEI's capability maturity model are as follows.

1. Initial level. Organizations have an undisciplined process and it is left to individuals

to decide how to manage the process and which development techniques to use.
2. Repeatable level. Organizations have basic cost and schedule management procedures
in place. They are likely to be able to make consistent budget and schedule predictions
for projects in the same application areas.
3. Defined level. The software process for both management and engineering activities is
documented, standardized and integrated into a standard software process for the
organization.
4. Managed level. Detailed measurements of both process and product quality are
collected and used to control the process.
5. Optimizing level. The organization has a continuous process improvement strategy,
based on objective measurements, in place
At each of these levels, a set of 'Key Practices' has been defined*. Once all of the practices
at one level have been introduced in an organization, it has reached that level of maturity
and moves up to the next level. Examples of practices include requirements management
(repeatable level), configuration management (repeatable level), peer reviews (defined
level), quantitative and process management (managed level)
The SEI's Capability Maturity Model has been very influential and has spawned other
models (such as the Bootstrap model) of process maturity and process improvements.
Many organizations are assessing their processes using the CMM and have the declared
objective to move to a given level of maturity (usually either 2 or 3) within some defined
timescale. Experience has shown that moving from one level to another takes several years
in most organizations. As yet, few organizations have reached the higher levels of the
model.

2.2 Requirement Engineering Process Maturity

The CMM is focused on software development and does not cover the requirements
engineering process, so we have created a comparable model of requirements engineering
process maturity. Requirements engineering process maturity is the extent to which an
organization has a defined requirements engineering process based on good requirements
engineering practices. An organization with a mature RE process will have this process
explicitly defined. It will use appropriate methods and techniques for requirements
engineering, will have defined standards for requirements documents, requirements
descriptions, etc. The organization may use automated tools to support process activities.
It will have management policies and procedures in place to ensure that the process is
followed and may use process measurements to collect information about the process to
help assess the value of process changes.
The SEI's Capability Maturity Model is mostly concerned with the management of
software development processes and does not cover system requirements engineering. Our
requirements process maturity model is a three-level model. The first two levels are
roughly comparable to the first two levels of the SEI model. The third level encompasses
all of the higher levels in that model.
1.Level 1 - Initial level. Level 1 organizations do not have a defined requirements
engineering process and often suffer from the problems discussed above. They do not
use

Figure 2: Requirement Maturity Model

advanced methods to support their requirements engineering processes. They often fail
to produce good quality requirement documents on time and within budget. They are
dependent on the skills and experience of individual engineers for requirements
elicitation, analysis and validation.
2.Level 2 - Repeatable level. Level 2 organizations have defined standards for
requirements documents and requirements descriptions and have introduced policies
and procedures for requirements management. They may use some advanced tools and
techniques in their requirements engineering processes. Their requirements
documents are more likely to be of a consistently high quality and to be produced on
schedule. 3 Level
3. Level 3 - Defined level. Level 3 organizations have a defined requirements engineering
process model based on good practices and techniques. They have an active process
improvement programmed in place and can make objective assessments of the value
of new methods and techniques. These are rough classifications which are convenient
for discussing the guidelines which we propose. In general, level 1 organizations
should focus in introducing the basic guidelines which we suggest; level 2
organizations should have implemented most of the basic guidelines and are in a
position to implement the intermediate guidelines; level 3 organizations should have
implemented almost all basic guidelines and all appropriate intermediate guidelines.
They may improve their process by introducing the advanced guidelines which we
suggest.

The effectiveness of the particular suggestions which we make is partially dependent

on the level of process maturity. Organizations which do not have a controlled and
defined requirements engineering process may experience problems if they wish to
introduce technically advanced methods such as formal specification of systems. It is
not necessary to implement all basic and intermediate guidelines before advanced
guidelines. However, if you want to introduce advanced methods with an uncontrolled
process, you must expect this to take additional time and money; you may also find
that the payoff from these methods is less than expected.

Some organizations will find it cost-effective to try to increase their level of process
maturity; others will find it best to stay at a particular level and to improve their
processes within that level. It depends on the type, the complexity and the size of the
systems which you produce. The larger and more complex the system, the more
benefits you are likely to gain by increasing your level of process maturity.

The requirements engineering process maturity level is only one of the factors which
affects the quality of the final requirements document. Other important factors are the
abilities and experience of the people involved in the process, the novelty, difficulty
and size of the problem and the time and resources available. Immature organizations
can and do produce good quality requirements documents. However, they may not be
able to do so consistently or when working under tight deadlines. Mature organizations
should normally produce good quality documents on time and within budget. It does
not mean that they will never have requirements engineering problems. New systems,
particularly, are always likely to be difficult to specify. However, a mature
organization should have processes and procedures in place which give them the best
chance of solving unforeseen requirements problems.

2.3 Process Improvement

Making changes and introducing new techniques in an organization is always difficult.
You must always leave enough time to implement these new techniques. People who
must apply these techniques must be kept fully informed during the introduction
process. You should always try to introduce techniques where everyone involved (not
just managers) sees some benefit. Some very general suggestions for facilitating process
change are as follows
1. Find an evangelist. If you can convince someone who is involved in the process of
the value of proposed changes, he or she will be the best person to convince other
practitioners to accept the changes.
2. Try changes out on pilot projects. Do not rush headlong into change. Introduce
process changes in pilot projects Process Improvement 27 and find out the
advantages and disadvantages of the change.
3. Allow enough time to make the change. When you introduce changes, you must
accept that it will take some time to introduce the change. Do not use projects with
very tight deadlines as pilot projects.
4. Respect professional skills. Do not introduce changes which degrade professional
abilities and respect the judgement of professionals involved in requirements
engineering. Emphasize that the point of changes is to help people improve the
quality of their work.

If you want improvements to be effective, you need to introduce guidelines

incrementally and assess the impact of these guidelines before introducing more
changes. You must strike a balance between introducing too many new guidelines
at once and introducing too few new process changes which have limited effect. The
number of guidelines to be introduced at any one time obviously depends on the
guideline. For example, it is usually possible to introduce several basic guidelines at
the same time. However, you may find it is only possible to introduce intermediate
and advanced guidelines one-by-one.

The order in which improvement guidelines are introduced depends on your process
and the need for improvements which you have identified.

Of course, you will not necessarily implement all of the guidelines in these sections
before moving on to the next section. Rather, you have to make a decision about
which guidelines are likely to be the most cost-effective for you. This must be based
on:
1. knowledge of your requirements engineering process and your process maturity
level
2. your budget and timescale for improvements
3. the people involved in implementing the requirements engineering process
improvements.
Once you have implemented guidelines for these activities, you can then move onto
guidelines in other areas such as requirements elicitation, system modelling, etc.
There is no ideal ordering for these and you must use your judgement about which
guidelines are likely to be most cost-effective.
Chapter Three: Requirement Elicitation and Analysis
3.1. Elicitation and Analysis Process
Requirements elicitation is the usual name given to activities involved in discovering what
requirements the system should provide. Technical software development staff work with
customers and system end-users to find out about the application domain, the system services,
the required performance of the system, hardware constraints, and so on. This process does
not just involve asking people what they want; it requires a careful analysis of the
organization, the application domain and how the system is likely to be used.
Effective requirements elicitation is very important. If the analyst does not discover the
customer's real requirements, the delivered system may not be acceptable to customers or end-
users. The acceptability of the system depends on how well it meets the customer's needs and
supports the work to be automated. It is not always easy to assess this as there may be a wide
range of stakeholders who benefit directly or indirectly from the system and who use different
criteria to judge the system's acceptability.
The analysts involved in the requirements elicitation process must address the following
problems.

1. Stakeholders often do not really know what they want from the computer system except
in~-the most general terms. Even when they have a clear idea of what they would like
the system to do, they often find this difficult to articulate. They may make unrealistic
demands because they are unaware of the costs of their requests.
2. Customers express requirements in their own terms and with implicit knowledge of
their own work. Analysts, who may not have much experience in the customer's
domain, must understand these requirements and express them in a way that can be
understood by everyone involved in the process.
3. Different stakeholders have different requirements and they may express these in quite
different ways. Analysts have to discover all potential sources of requirements and
they must expose requirements commonalities and conflicts.
4. Organizational issues and political factors may influence the requirements of the
system. These factors may not be obvious to the system end-users. They may come
from higher management influencing the system requirements in ways that satisfy
their personal agenda. For example, they may wish to move some functions to their
department so propose requirements which integrate the support for these functions
with support for functions which they already provide.
5. The economic and business environment in which the analysis takes place is dynamic.
It inevitably changes during the elicitation process. Hence the importance of particular
requirements may change. Requirements may emerge from new stakeholders who
were not originally consulted.
To elicit system requirements, you must understand the problem to be solved, the business
processes in an organization, the ways in which the system is likely to be used and the
application domain of the system. You need to find out about the system from available
documents and discuss with stakeholders the system services which they need and the
operational constraints on the system. You must be sympathetic to the concerns of system
stakeholders and take the time to discover their real requirements
A. Asses System Feasibility
Before investing effort and incurring expense in discovering system requirements, you should
always carry out a feasibility study. This should assess whether or not the system can be
implemented given existing technology and whether or not it can be effectively integrated
with your current way of working. The feasibility study should also check that the system
should provide adequate returns for the investment in its development.
Benefits:
• A feasibility study is a low-cost way of avoiding problems. People proposing a system are
often unaware of technological limitations. They do not know the consequences of installing
the system in its actual working environment. A feasibility study may reveal that the system
is unlikely to be used effectively in which case there is little point in developing it.
• To carry out a feasibility study, you need to make the business objectives for the system
explicit. The business objectives represent the fundamental reasons for the system
development. Requirements which are discovered during the elicitation process must be
consistent with these objectives. See Guideline 3.4, Make a business case for the system.
• The study is likely to reveal initial sources of information about the system which should be
consulted during the requirements elicitation.
Implementation:
Feasibility studies consist of three phases. These are:
• decide on the information that you need
• gather that information from key information sources
• produce a feasibility report
Firstly, you must identify the critical information which you need about the system and
develop a set of questions to discover that information. Examples of these questions might be
as follows.
1.Do we really need this system?
2.What would the consequences be if we did not develop this system?
3.In what direct and indirect ways will the system contribute to our business objectives?
4.What critical processes must the system support?
5.What critical processes need n o t be supported by the system?
6.How will the system affect other systems which are already installed?
7.What are the likely technology limitations which we face?
8.Can a useful system be developed for the budget available?
The next stage involves putting these questions to key people in the organization. Using
the questions as a guide, you should identify a small number of people who can give
informed answers. These may include managers of departments where the system will be
installed, systems engineers and technical experts such as system managers who can
answer questions about the technology available.
The final stage involves collating the answers to these questions and preparing a report
for management on the system. This should discuss the advantages and disadvantages of
developing the system, make recommendation about the type of system which should be
developed and should (perhaps) establish an initial set of high-level requirements and
constraints. This report is used to decide whether or not to go further in the system
development.

Costs and Problems:

This guideline can be introduced relatively cheaply, as feasibility studies do not require
specialized training. You can limit the costs of feasibility studies by establishing a budget
for the study and collecting information until that budget is exhausted. Even a one-day
study is likely to reveal useful information and is better than nothing. In general, however,
for a completely new, medium-sized software system, you should budget for at least 6-10
days of effort to carry out the feasibility study and allow about a calendar month for it to
be completed. For systems which are intended to replace existing systems, the feasibility
study should require less effort and calendar time.
Apart from the possibility that the feasibility study will miss information and hence give
misleading results, there are two possible problems which can arise.
1.User uncertainty. The feasibility study may disturb end users of the system as they find
out about the possibility of the system but are unsure about how it will affect their
work. You need to address this problem by openness and telling people as much as
you know about the system, emphasizing its positive benefits to the organization.
2.Premature commitments. If the people involved in the feasibility study are committed
to the idea of the system, they may not be wholly objective in carrying out the study.
They may find good arguments for the system but miss problems which are likely to
arise. You can avoid this difficulty by bringing in outsiders (e.g., consultants) to
conduct the study but this will increase the expense. Not only will costs be higher but
they will have to spend time understanding your organization before the work can
begin.
B. Be Sensitive to Organizational and Political Considerations
When eliciting requirements, you must be sensitive to organizational and political
factors which influence requirements sources and which may conceal the real system
requirements from you.
Benefits:
• If you understand organizational politics, you are more likely to be able to understand the
real rationale for some requirements and to assess whether or not a proposed requirement has
been influenced by hidden organizational or political considerations.
• If you do not take organizational and political considerations into account, you may miss
important sources of information about the system requirements.
Implementation:
The successful application of this guideline is dependent on the sensitivity of the analysts
involved in the elicitation process. Some people seem to have a natural awareness of political
considerations; others have a more technical focus and find it difficult to relate to intangible
organizational politics. People who come from inside an organization are more likely to
understand these considerations than external consultants but they are also more likely to be
biased by them.
When eliciting requirements, there are a number of things you should watch for as these
suggest organizational and political influences on the requirements.
1.Conflicting goals. Do not assume that all people in the organization have common goals
or that their most significant goals are the stated business goals. Try to find out
personal goals, as these may reveal hidden agendas when requirements are proposed.
2.Loss or transfer of responsibility. Try to understand the power structure in an
organization. One reason for developing the software may be to alter this in some way
by transferring responsibilities from one part of the organization to another. Those
who will lose responsibility may suggest requirements which are impossible or very
expensive to implement.
3.The organizational culture. If there is a competitive culture in an organization with each
department competing against others, you will find that requirements from different
departments may be designed to give them some kind of competitive edge.
4.Management attitudes and the morale of the organization. If the organization has gone
through a period where jobs have been lost, people in the organization may be hostile
to management. They may be unwilling to participate in the requirements engineering
process and find excuses not to get involved.
5.Departmental differences. If you notice marked differences between one department in
an organization and most other departments, this suggests a different culture in that
department. Requirements from there are likely to be influenced by that culture.
Costs and Problems:
The costs of introducing this guideline are generally low. You may simply suggest to analysts
that they must be aware of organizational and political considerations (costing nothing), you
may organize short internal training courses or you may use external consultants who offer
courses in topics such as organizational psychology etc.
The problem with using consultants is that their advice is likely to be very general; they may
help to make people aware of the problems but are unlikely to train people how to discover
them. If possible, it is best to organize training using internal staff who have experience of
organizational influences on requirements. They can therefore base their courses on examples
which people can relate to.
The problem of applying this guideline during elicitation is that many people in the
organization will not wish to reveal their real reasons for requirements and, sometimes, may
actively work to undermine the requirements elicitation process. They deliberately conceal
political and organizational information from the analyst. Sometimes people can gain more
from system failure than success and you should not always assume that they have the same
goals as those people who are committed to the system.
C. Identify and Consult System Stockholders
A system stakeholder is anyone who benefits in a direct or indirect way from the system which
is being developed. Examples of stakeholders are end-users of the system, managers,
customers, system developers, etc. As part of the requirements elicitation process, you should
explicitly identify all potential stakeholders and consult them to discover if they have specific
requirements or if they impose specific constraints on the system.
Benefits:
If you do not consider everyone who is likely to be affected by the introduction of a system,
you are likely to miss important requirements. The system may have to be reworked to include
these at a later stage or, in the worst case, may never be used.
• If you use a viewpoint-oriented approach to structure the requirements elicitation process,
identification of stakeholders can help you discover viewpoints for structuring the system
requirements.
• Identifying stakeholders and discussing the system with them makes people feel that they
are part of the requirements elicitation process. They are more likely to be sympathetic to the
introduction of the system and to volunteer information about their requirements.
Implementation:
Stakeholders in the system may be identified using the following checklist:
1.by discovering the potential end-users of the system
2.by considering descriptions of the business processes which the system is intended to
support and the people involved in these processes
3.by initial discussions with organizational management where you ask who will be
affected by the introduction of the system
4.by considering the customers of the organization who will use the system
5.by considering engineers and maintenance staff responsible for developing and
maintaining the system
6.by considering external bodies such as regulators and certification authorities who may
wish to place requirements on the system
It does not necessarily follow that all of these will be stakeholders but your initial
stakeholder identification should consider all of them as possibilities. We recommend that
you design your documentation so that you make an explicit list of stakeholders which
includes brief reasons why their requirements are likely to be important.
The stakeholders in a system should always be explicitly identified in the requirements
document and, if appropriate, information should be maintained which links specific
requirements to the stakeholders who proposed these requirements. If a viewpoint-
oriented approach is used, stakeholders may be associated with specific viewpoints and
may be considered as sources of requirements.
Cost and Problems:
There are no significant costs in introducing this guideline. Analysts readily understand
the need for this and are unlikely to raise any objections to it. To apply the guideline, there
is a small additional cost in initially identifying and listing stakeholders. There are, of
course, costs incurred when consulting stakeholders but these should not be additional to
your current informal consultation costs.
The major problem which you are likely to encounter is identifying a complete set of
system stakeholders. The stake which people have in a system is not always obvious and
you need to consult widely in an organization to find all possible stakeholders.
D. Record Requirements Sources
The source of requirements is a link to the information on which the requirement is based.
When you document a requirement, you should record the source or sources who have
expressed the requirement. A requirements source can be any stakeholder or group who
have suggested requirements. Other possible sources are organizational quality standards,
technical documentation, incident reports, or other requirements.
Benefits:
• A major cost factor in analyzing and changing requirements is the cost of consultation
with requirements sources. This can be minimized if you do not have to spend too much
time finding out who to consult. With available source information, you know
immediately what people and documents must be consulted.
• The source information can help you understand why the requirement exists. For
example, if the source is a safety standard, you are given the clue that the requirement is
likely to be safety-related in some way.
Costs and Problems:
The costs of introducing this guideline are very low, as it simply involves defining or re-
defining your requirements collection form with a field for collecting source information.
Applying this guideline adds no significant overhead to the requirements elicitation
process as you record source information at the same time as you collect the requirements.
There are unlikely to be significant problems in implementing this guideline unless you
use an existing, inflexible database structure for requirements which does not include a
field for source details and which cannot easily be modified to include this information.
The principal problem which is likely to arise is getting analysts to remember to record
source information when it is collected. If they do not do so and they try to reconstruct the
source information later, mistakes are bound to happen
E. Define the system’s operating Environment
The operating environment of a system consists of the host computer, which is the platform
for the software which is being specified, and other hardware and software systems which
will interact with the system. During the requirements elicitation process, you should
define that environment and how it might change over the lifetime of the system.
Benefits:
• Many system installation problems arise because of unexpected interactions with other
installed systems. If you understand and define the environment in advance, you can
anticipate and avoid some of these problems.
• Defining the environment helps reveal system requirements for interaction with these
other systems or, sometimes, compatibility requirements where the new system and
existing systems have to run on the same platform.
Implementation:
When defining the operating environment of a system, you should always collect the
following information.
1. Platform information. If the system software is to run on an existing computer, you
should specify the characteristics of that machine, the operating system which will be
installed and the libraries of software which may be used. It is particularly important to
specify the versions of the operating system and libraries which will be used. Many
compatibility problems arise because assumptions made during elicitation about which
versions of software systems are installed on the operating environment are often
outdated when the system is installed.
2. Interface information. If the system interacts directly with existing systems such as
databases, you should discover and specify the interface provided by this system.
Conforming to this interface is an inter-operability requirement for the system being
specified.
3. Software dependencies. Your system may rely on other software systems to provide
functionality even although it is not directly interfaced to them. For example, you may
assume that there is some word processor system available. If specific systems are
required, you should specify which versions of these systems should be installed on the
system platform.

You may also need to collect other information, depending on the type of system which
you are specifying. An example is information on the physical layout of the place where
the system is to be installed. This may be necessary because of limited space available
for the system equipment.

The operating environment should be defined as a separate chapter in the requirements

document. This should include an environmental model showing the different systems
and their relationships, detailed descriptions of the systems and specifications of system
interfaces.
Cost and problems:
This guideline simply suggests that you should be systematic in doing something which
you must already do as part of your system development process. There should be no
significant additional costs in introducing and applying this guideline.
A major problem which you are likely to face is environmental instability. The rate of change
of hardware and software is now so high that it is likely that the operational environment of
the system will change during the development process. The environment may be changed
without considering the effects on new systems under development. Although you should try
to predict changes, it is almost certain that unpredicted changes of some type will occur.
Changes to versions of software (e.g. Windows 3.1 is replaced by Windows 95) are common.
The consequences of these changes are difficult to anticipate and they often cause tremendous
problems because of version incompatibilities. You should regularly check that your
environmental assumptions are still valid and should inform system managers of your
environmental requirements.
You can avoid change to some extent by deliberately freezing the operational environment
but this is usually only possible when the system is a stand-alone system and no other software
runs on the same platform. Even in such situations, it is possible that the interfaces of other
systems will change so there will still be some environmental instability.
F. Use Business Concerns to Drive Requirements Elicitation
Business concerns are abstract high-level goals which must be satisfied if a system is to make
a contribution to the organization which is paying for it. You should identify and write down
these goals and use them as drivers of the requirements elicitation. Business concerns are
more general than the specific business case for the system which should be included in the
requirements document.
Benefits:
• If a system is to be useful, it must contribute to the key concerns of the business. If these
concerns are identified and used as drivers of the requirements elicitation process, you can be
more confident that the system will meet real organization needs and will actually be useful.
• Making the business concerns explicit helps to focus and clarify these goals. Explicit
business concerns help people make decisions about their work and how it contributes to
overall business goals.
Implementation:
By discussions with senior management, from the business case for the system and from a
general understanding of the work of the organization, you should identify critical business
concerns such as customer service, system reliability, safety and cost. It is important not to
have too many of these concerns, We recommend that there should be five or less, otherwise
costs and information management problems can increase significantly.
Each of these concerns should then be decomposed into more detailed sub-concerns which
may then be further decomposed. Eventually, concerns should be decomposed to a set of
questions associated with the sub concern. These questions may then be put to system
stakeholders to discover requirements related to these goals and to check that their
requirements are consistent with the business concerns.
For example, say a concern was customer service. This could be decomposed into goals such
as 'faster response to customer queries', 'lower costs for customers', 'fewer complaints from
customers', etc. Eventually, you might decompose these into questions which are asked during
the requirements elicitation process. For example, if we take the concern 'faster response to
customer queries' we might get questions such as:
• what factors affect the response time to customer queries?
• is hardware/database performance a significant issue in response times?
• do particular questions require a series of interactions with the system?
• would suggested requirements have a positive/negative effect on customer response time?
The method of viewpoint-oriented requirements elicitation which we discuss in Chapter 13
uses this approach. It proposes that the requirements elicitation should be driven by a set of
concerns which are derived from key business goals. These concerns are used to generate a
checklist of questions which are put to potential sources of requirements during the elicitation
process.
If you develop safety-critical systems, the concerns can be safety and availability. Using the
concerns to derive the system requirements should simplify the production of the safety case
for the system.
Costs and Problems
The costs of introducing this guideline are the consultation costs involved in talking to senior
management about what they see as critical business goals. The costs of implementing the
guideline involve decomposing the goals to a set of questions which can be put to
requirements sources. Once you understand the business goals, it should be possible to do this
in 1 or 2 days of work (assuming that you do not have too many goals).
The problems which are likely to arise in implementing this guideline are difficulties of
decomposing concerns into practical sub-concerns and the fact that concerns may change in
response to external influences such as competition, legislation, etc. Although it is easy to
define abstract concerns such as 'cost reduction', 'quality improvement', etc., it is more
difficult to establish exactly what these mean in an organization. These difficulties are made
worse by the fact that the time of senior management is very limited and it may not be possible
to have extensive discussions with them on the business concerns. There is also a tendency
for senior management to have unrealistic expectations of the system. Using your knowledge
of what is realistically possible, you have to work with management to define their concerns.
G. Look for Domain Constraints
Domain constraints are system requirements which come from the application domain of the
system. For example, in a banking system there may be accounting regulations which must
be followed; in a train control system, the braking capabilities of a train must be taken into
account. You should study the domain and understand these constraints as part of the
requirements elicitation process.
Benefits:
• Domain constraints generate system requirements and place limitations on other
requirements. If you do not take domain considerations into account, there may be insuperable
legal, organizational or physical obstacles to implementing the proposed requirements. Many
systems have failed because they did not take real-world limitations into account.
• By recording domain constraints, you can avoid the expense of re-collecting this information
when further systems are developed.
• For legal or organizational reasons (e.g., conformance with health and safety regulations or
company security policy) you may have to demonstrate that the system meets given domain
constraints.
Implementation:
You should interview domain experts to find out what problems are likely to arise and what
must be taken into account when developing the system. This should not be a one-off process.
As you improve your understanding of the system requirements, you should discuss your
revised understanding with domain experts. This will check if your knowledge is consistent
with domain constraints and if further domain considerations must be taken into account.
Domain requirements and constraints are likely to fall into two categories.
1.Overall constraints which apply to all other requirements. You must check that other
requirements do not conflict with these constraints.
2.Specific requirements derived from domain considerations. These are likely to come
from regulations and policies such as safety legislation and company security policies.
They will result in specific requirements such as 'A log of all transactions must be
maintained'. You need a fairly flexible standard for domain information as there are
many types of domain information which may be relevant. Domain information which
you might record includes the following.
1. An informal statement of the domain knowledge. For example, you might record
that the parameters affecting the braking characteristics of trains include the brake
system specification, the train velocity and mass, the type of track on which the
train is running, weather conditions, the acceptable level of deceleration, etc.
2. More formal descriptions of the domain knowledge. For example, in the brake
system specification, you might include a formula to compute the normal braking
distance of a train.
3. The types of system where this domain knowledge is applicable and, if necessary,
exceptions.
4. Knowledge classification terms such as safety, performance, etc., which may be
used for information retrieval.
5. The sources of the domain information. Domain information is an important
organizational resource so it should not simply be considered as information which
is specific to one project. You should try to record domain information in a
standard way in a 'domain handbook' which can be used by different teams in the
organization. This handbook can be a paper document but we recommend that you
collect the information electronically and make it widely available in the
organization. A good way of doing this is to make it accessible on an Intranet
where organizational information may be accessed using Internet tools such as
Worldwide-Web browsers.
Costs and Problems:
The costs of introducing this guideline are the costs of defining a standard way of recording
domain information. We recommend that you use a simple form with fields for different types
of domain knowledge. These costs should be fairly low. When applying the guideline, you
must allow sufficient time to discover appropriate domain experts and to consult with them
about the system. If you enter domain information in a database, you must define a database
schema and there will clearly be data entry and validation costs associated with this. You will
also need to write documentation for requirements engineers which explains how to discover
and retrieve information from this database. A major problem which is likely to arise is the
unavailability of these domain experts when you need them. They are busy people and will
undoubtedly have many other things to do. You may also find that there are problems in
retrieving information which has been collected in previous projects irrespective of whether
or not this has been collected in a database.
H. Record Requirements Rationale
The rationale of a requirement is information which summarizes the reasons why that
requirement has been specified. It justifies the requirement in terms of the problem which the
system is designed to solve. The rationale is derived from a source, so it can come from a
person, a group or a document.
Benefits:
• The rationale associated with a requirement is a link between the problem and the
requirements for the proposed problem solution. The rationale makes it easier for readers to
understand the requirement and to assess the impact of changes to the requirement.
• Problem experts can use the rationale to check if the requirement is consistent with the
problem being solved. If the rationale description includes a description of alternatives and
arguments for each of them, the rationale information may predict future requirements
changes.
Implementation:
A simple model of requirements rationale can be recorded by designing your requirements
collection form so that there is a field which can record the rationale of the requirement. As
you discover requirements either from documentation, as a result of analysis of other
requirements, or from system stakeholders, you should briefly note the rationale for including
that requirement in that field. Rationale should normally be recorded as a simple natural
language explanation although, sometimes, you may need to include domain specific
notations.
If you manage your requirements in a database, you need to ensure that your database
definition makes provision for recording rationale and that the rationale information is entered
along with the requirement.
More complex approaches to rationale recording can be derived based on the use of hypertext
systems for supporting formal argumentation. We provide information about software
products of this type in the book's Web pages. This system allows requirements to be recorded
and arguments for and against these requirements to be linked to them. This may then be used
during requirements negotiation to decide whether or not a requirement is to be accepted and
if requirement changes should be made.
Cost and Problems:
Introducing this guideline is not expensive if you record rationale in an informal way. You
simply need to ensure that your requirements standard has a field for recording rationale. If
you record your requirements in a database, you need to make sure that you have a field in
your database records for rationale. The costs of applying the guideline include the costs of
the time needed to elicit the rationale from people who understand the problem and the
application domain and to understand that rationale.
The costs of introducing and using a more structured rationale model with explicit comparison
of alternatives is significantly higher. You need to invest in a hypertext system or a special-
purpose support tool for this method. There are also significant training costs. Experience in
industrial experiments has shown that many engineers find it difficult to organize their
thoughts into formal arguments.
There are two main problems which you might encounter when introducing this guideline.
1.Misleading rationale. Some requirements sources may be unwilling to reveal the true
rationale for some requirement. This is usually because they have some personal goals
for the system (e.g. 'increase the size of my department') which they are unwilling to
make public.
2.Conflicting rationale. Different requirements sources may suggest the same or similar
requirements for completely different reasons. Sometimes this reveals a
misunderstanding of the requirement but, if this is not the case, you should record both
reasons and identify the source of the requirements rationale.
I. Collect Requirements from Multiple Viewpoints
There are many different influences on the requirements for a computer-based system.
These include end-users of the system who are involved in the processes which the
system is designed to support, managers and others in the organization whose work is
indirectly affected by the system, and customers of the organization buying the system.
All of these and more are potential sources of system requirements and they have their
own viewpoint on the services that the system should provide and the ways in which it
should be provided. You should recognize this diversity and collect requirements from
these multiple viewpoints.
Benefits:
• If your requirements are collected from a single viewpoint, you are unlikely to meet the
needs of other stakeholders in the system. These will often be influential (e.g. managers)
and this failure will mean that the system is not used.
• Collecting requirements from multiple viewpoints is a useful way of prioritizing
requirements. Requirements which all viewpoints suggest should probably have a high
priority.
• You can use the identified viewpoints to help organize the process of requirements
elicitation and to structure the requirements document. Different analysts can
concurrently collect information from different viewpoints.
Implementation:
A number of viewpoint-oriented requirements elicitation and analysis methods have
been proposed. Some of these methods are suitable for requirements elicitation; others
are more suited to managing system models developed from different viewpoints.
However, a problem with these approaches is that they are difficult to introduce alongside
existing methods of requirements elicitation and systems design.
The PREview (Process and Requirements Engineering viewpoints) approach which we
describe in Chapter 13 can be introduced into existing requirements engineering
processes without radical change. You can use it with your existing notations. You can
introduce it in an incremental way alongside your existing requirements engineering
methods.
PREview is based around 3 types of viewpoint:
• interactor viewpoints associated with people or equipment which interact with the
system
• stakeholder viewpoints associated with people who benefit, in some way, from
the system and
• domain viewpoints which are associated information. with domain
You can use any type of notation to describe the requirements derived from these
viewpoints; PREview does not have its own built-in notations.
Applying this technique involves a number of steps.
1.You must identify the principal concerns of the organization for the system being
specified. Concerns reflect business goals such as faster time to delivery or the
production of safety and reliable systems.
2. You then identify viewpoints and viewpoint sources. There may be as few as two or as
many as eight or nine viewpoints. Normally, we recommend four or five viewpoints
for medium-sized systems. The association of sources with viewpoints reflects
Guideline 4.4.
3. You elicit requirements from viewpoint sources using the concerns as a driver and a
checklist for this elicitation. This reflects Guideline 4.6.
4. After requirements have been made available, you should cross-check these across
viewpoints for conflicts and inconsistencies.
5.Finally, you integrate the requirements from the different viewpoints to produce a
requirements document.
Costs and Problems:
Introducing a viewpoint-oriented approach is quite expensive. Costs include:
1.training costs for some viewpoint-oriented method
2.costs of adapting or procuring software support for the method; viewpoint-oriented
analysis tends to generate a lot of information and some automated way to manage
this information is essential
3.costs of integrating information from these different viewpoints into a single
requirements document.
Viewpoint-oriented analysis usually requires more effort and calendar time that an
unstructured, informal approach to requirements elicitation. However, we are
convinced that you will recover this time later in the system development, as rework
caused by requirements problems will be reduced.
Good requirements analysts appreciate that there are many different perspectives on a
system and they try to identify these perspectives and collect information from them.
They implicitly identify viewpoints. A viewpoint-oriented approach to elicitation,
therefore, really just involves making this an explicit process. Consequently, applying
this guideline need not necessarily involve a significant increase in requirements
engineering process costs.
We recommend that viewpoint-oriented elicitation should firstly be introduced using
a relatively small pilot project. This will help discover what viewpoints are likely to
be significant for an organization and will allow a specific elicitation process to be
developed. Possible problems which may arise when implementing this guideline are
problems of identifying the right viewpoints and collating information from these
different viewpoints. These are the same problems that you find with any method. As
requirements engineers gain experience with the approach, the problems become less
significant.

J. Prototype Poorly Understood Requirements

A prototype is a demonstration system which shows end users and system stakeholders what
facilities the system can provide. If you have vague or poorly understood requirements, you
should consider developing a prototype system which simulates the behavior of system
software and hardware. End-users can experiment with this to refine their ideas about the
system requirements.
Benefits:
• Prototyping makes the real meaning of requirements easier to understand. If stakeholders do
not fully understand the system requirements, they may agree to a requirements specification
which does not reflect their real needs. The ultimate system which is developed is likely to be
unsuitable.
• Prototyping is the only effective way of developing system user interfaces. If a prototype
has been developed as part of the requirements process, this can reduce later development
costs for the system.
• The prototype system may help establish the overall feasibility and usefulness of the system
before high development costs are incurred.
• For some types of system, which are primarily software, the final system can sometimes be
developed by modifying and adding facilities to the prototype. This means that a limited but
usable system may be available relatively quickly
Implementation:
There are three possible approaches to system prototyping:
1.paper prototyping where a mock-up of the system is developed and used for system
experiments
2.'Wizard of Oz' prototyping where a person simulates the responses of the system in
response to some user inputs
3.automated prototyping where a fourth generation language or other rapid development
environment is used to develop an executable prototype.

Paper prototyping is a cheap and surprisingly effective approach to prototype

development. It is most suitable for establishing end-user requirements for software
systems. Paper versions of the screens which might be presented to the end-user are
drawn and various usage scenarios are planned. Analysts and end-users work through
these scenarios to find users reactions to the system, the information they require and
how they would normally interact with the system.

'Wizard of Oz' prototyping is also relatively cheap as it does not require much software
to be developed. The user interacts with what appears to be the system but his or her
inputs are actually channeled to a person who simulates the responses of the system.
This approach is particularly useful when a new system has to be developed based on
an existing interface. Users are familiar with the interface and can see the interactions
between it and the system functionality simulated by the 'Wizard of Oz'.

Developing an executable prototype of the system is a more expensive option. It

involves writing software to simulate the functionality of the system to be delivered.
It is very important that the prototype should be developed quickly and this means that
you should use very high-level languages and support environments for prototype
development. Depending on the class of system you might use any of the following.

1. Fourth generation languages based around database systems. These are good for
prototyping applications which involve information management. However, they
do have restrictions which are inherent in the interaction facilities which they
provide. You must develop your prototype within these limitations and this may
mean that some facilities (e.g., navigation around a database by using a graphical
visualization of the data) may be impossible.
2. Very high-level languages such as Visual Basic or Smalltalk. These are general
purpose programming language which usually come with a powerful development
environment and access to a range of reusable objects. These allow applications to
be developed quickly and with more flexibility than is usually provided with 4GLs.
3. Internet-based prototyping solutions based on Worldwide-Web browsers and
languages such as Java. Here, you have a ready-made user interface. You add
functionality to it by associating segments of Java programs with the information
to be displayed. These segments (called applets) are executed automatically when
the page is loaded into the browser. This approach is a fast way of developing user
interface prototypes but you must accept the inherent restrictions imposed by the
browser. At the time of writing, this approach seems to have a lot of potential but
is still immature.

Prototyping interactive systems is much easier than prototyping real-time systems.

Most prototype systems are not designed for efficient hardware interaction so you
may not be able to access the sensors and actuators which will be used in the final
system.
Some requirements are practically impossible to prototype. This is particularly true
for 'whole system' requirements which reflect general objectives such as system
usability, reliability, etc. In general, because the performance, efficiency,
reliability, etc., of a prototype is quite different from a finished system, you can
only use prototypes to discover the functional requirements for a system.
Costs and Problems:
Paper prototyping is relatively cheap to apply but you must expect some costs in
introducing this approach as specialist expertise is required. Currently, there are few
organizations which can provide training and consultancy in this area. You must be
prepared to invest time and effort in experimentation and working out the best way for
your organization to use the approach. The time required to develop a paper prototype
can range from a few hours to a few days.
If you do not have a prototyping environment, there are fairly high costs involved in
introducing executable prototyping. Although the software costs are relatively low, there
are significant training costs involved for prototype developers. The development costs
for the prototype depend on the type of system. Modern prototyping facilities provide a
basic development framework such as a database, an interaction model, etc. If this can
be used as a basis for your system then it may be possible to develop a prototype for a
moderate cost. However, if the framework is inadequate and you need to develop a lot
of basic functionality before any useful experimentation is possible, then prototyping
costs will be high.
There are various problems which can arise with prototyping. You must accept that, for
the initial prototypes, the development time will be extended as developers learn the
most effective ways to use the system. If you want to employ prototyping specialists,
you may find that there is a lack of skilled people with experience in this area.
In some circumstances, the time-to-market for new systems will be increased. The final
system should be better but you may feel that this does not compensate for the delays in
system delivery. Some requirements (such as real-time requirements) are difficult or
impossible to prototype and, sometimes, a prototype gives a false picture of the final
system. This is especially true when you use the built-in facilities of some prototyping
system98 Requirements Elicitation which cannot be replicated cost-effectively in
conventional programming languages.
A 'problem' with using a prototyping approach for requirements elicitation is that you
may be pressurized by customers to continue development of the prototype to produce
the final system. There are some situations where this may be the right thing to do but,
for systems which will have a long-lifetime, delivering the prototype instead of throwing
it away and starting again can lead to increased long-term costs and system inflexibility.
The reason for this is that prototypes tend to be unstructured and rapid development is
given priority over long-term maintainability. The consequence of using a prototype
rather than re-developing a system is therefore increased system maintenance costs and
(almost certainly) a shorter overall system lifetime. Where time to market is of the
utmost priority, there may be a good case for development based on evolutionary
prototyping but we do not generally recommend this approach for large, long-lifetime
systems.
The rest are listed in the book entitled REQUIREMENTS ENGINEERING A Good
Practice Guide by lan Sommerville and Pete Sawyer Lancaster University.
Chapter Four: Requirement Specification
A software requirements specification (SRS) is a detailed description of a software
system to be developed with its functional and non-functional requirements. The SRS is
developed based the agreement between customer and contractors. It may include the
use cases of how user is going to interact with software system. The software
requirement specification document consistent of all necessary requirements required
for project development. To develop the software system, we should have clear
understanding of Software system. To achieve this, we need to continuous
communication with customers to gather all requirements.
A good SRS defines the how Software System will interact with all internal modules,
hardware, communication with other programs and human user interactions with wide
range of real-life scenarios. Using the Software requirements specification (SRS)
document on QA lead, managers create test plan. It is very important that testers must
be cleared with every detail specified in this document in order to avoid faults in test
cases and its expected results. It is highly recommended to review or test SRS documents
before start writing test cases and making any plan for testing. Let’s see how to test SRS
and the important point to keep in mind while testing it.
Following are the features of a good SRS document:
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). Definition of their responses of the software to all realizable classes of input data in
all available categories of situations. Note: It is essential to specify the responses to both
valid and invalid values.
(3). 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 conflict. For example,
(a) The format of an output report may be described in one requirement as tabular but
in another as textual.
(b) One condition may state that all lights shall be green while another states that all
lights shall be blue.
(2). There may be a reasonable or temporal conflict between the two specified actions.
For example,
(a) One requirement may determine that the program will add two inputs, and another
may determine that the program will multiply them.
(b) One condition may state that "A" must always follow "B," while other requires that
"A and B" co-occurs.
(3). Two or more requirements may define the same real-world object but use different
terms for that object. For example, a program's request for user input may be called a
"prompt" in one requirement's and a "cue" in another. The use of standard terminology
and descriptions promotes consistency.
4. Unambiguousness: SRS is unambiguous when every fixed requirement has only one
interpretation. This suggests that each element is uniquely interpreted. In case there is a
method used with multiple definitions, the requirements report should determine the
implications in the SRS so that it is clear and simple to understand.
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. Typically, all requirements are not equally important.
Some prerequisites may be essential, especially for life-critical applications, while
others may be desirable. Each element should be identified to make these differences
clear and explicit. Another way to rank requirements is to distinguish classes of items
as essential, conditional, and optional. 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
There are two types of Traceability:
1. Backward Traceability: This depends upon each requirement explicitly
referencing its source in earlier documents.
2. Forward Traceability: This depends upon each element in the SRS having a
unique name or reference number. The forward traceability of the SRS is
especially crucial when the software product enters the operation and
maintenance phase. As code and design document is modified, it is necessary
to be able to ascertain the complete set of requirements that may be concerned
by those modifications.
9. Design Independence: There should be an option to select from multiple design
alternatives for the final system. More specifically, the SRS should not contain any
implementation details. 10. Testability: An SRS should be written in such a method that
it is simple to generate test cases and test plans from the report.
11. Understandable by the customer: An end user may be an expert in his/her explicit
domain but might not be trained in computer science. Hence, the purpose of formal
notations and symbols should be avoided too as much extent as possible. The language
should be kept simple and clear.
12. The right level of abstraction: If the SRS is written for the requirements stage, the
details should be explained explicitly. Whereas, for a feasibility study, fewer analysis
can be used. Hence, the level of abstraction modifies according to the objective of the
SRS.
Properties of a good SRS document
The essential properties of a good SRS document are the following:
Concise: The SRS report should be concise and at the same time, unambiguous,
consistent, and complete. Verbose and irrelevant descriptions decrease readability and
also increase error possibilities.
Structured: It should be well-structured. A well-structured document is simple to
understand and modify. In practice, the SRS document undergoes several revisions to
cope up with the user requirements. Often, user requirements evolve over a period of
time. Therefore, to make the modifications to the SRS document easy, it is vital to make
the report well-structured.
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. The SRS report
should view the system to be developed as a black box and should define the externally
visible behavior of the system. For this reason, the SRS report is also known as the
black-box specification of a system.
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. These are called system response to exceptional conditions.
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.
In most organizations, system requirements are written as paragraphs of natural
language (English, French, Japanese, etc.), supplemented by diagrams and equations.
Natural language is the only notation that we have which is generally understandable by
all potential readers of the requirements for a system. Natural language can be
ambiguous, surprisingly opaque and is often misunderstood. Nevertheless, everyone can
read natural language, so requirements will continue to be written in this way for the
foreseeable future.
Natural language can be used to describe requirements clearly. All too often, however,
natural language requirements are difficult to understand. Common problems are that:
• the requirements are written using complex conditional clauses (if A then if B then if
C...) which are confusing
• terminology is used in a sloppy and inconsistent way
• the writers of the requirement assume that the reader has specific knowledge of the
domain or the system and they leave essential information out of the requirements
document.
These problems make it difficult to check the set of requirements for errors and
omissions. Different interpretations of the requirements may lead to contractual
disagreements between the customer and the system engineering contractor.
We do not think that these problems can be solved by introducing new languages for
writing requirements. Good writing is all that is needed to write good requirements.
Well-written requirements include all necessary information. They are succinct and are
easy to understand. They use language that is as simple as possible. Technical terms are
used in a consistent way and only when necessary.
We are convinced that, irrespective of the level of detail in your requirements
description, there are three essential things that you must bear in mind when considering
how to improve your requirements descriptions.
1. Requirements are read more often than they are written. Investing effort in writing
requirements which are easy to read and understand is almost always cost-effective.
2. Readers of requirements come from diverse backgrounds. If you are a requirements
writer, you should not assume that readers have the same background and
knowledge as you.
3. Writing clearly and concisely is not easy. If you do not allow sufficient time for
requirements descriptions to be drafted, reviewed and improved, you will inevitably
end up with poorly written specifications.

Different organizations write requirements at different levels of abstraction from

deliberately vague product specifications to detailed and precise descriptions of all
aspects of a system. You must decide for yourself on the level of detail that you
need. This depends on the type of requirements (stakeholder, system or process
requirements), customer expectations, your organizational procedures, and external
standards or regulations which you may have to follow. All we can do here is give
you general advice which can be applied irrespective of the detail of the
requirements.
A. Define Standard Templates for Describing Requirements
When you are writing detailed system requirements, you should define a set of
standard templates which you use for organizing the description of these
requirements. The template should include fields to collect the detailed information
necessary to completely specify the requirement.
Benefits:
• Standards make requirements easier to read. Once readers understand a standard,
they know what to expect when reading requirements.
• Standards make requirements easier to collect. The standard form can be used as a
checklist by analysts when collecting requirements from end-users, customers,
managers, etc.
• Standards make requirements easier to write. They reduce the chances that
important information will be forgotten and make it easier for reviewers to check if
information has been left out.
Implementation:
To ensure that natural language requirements are readable, you should define some
structure for the description of each requirement. This structure should include fields
to note the information that you wish to Define Standard Templates for associate
with the requirement. For example, if the requirement is a functional requirement,
your standard may specify that the inputs, the processing and the outputs must be
specified in the requirements definition.
A standard form or template should be defined to record requirements information.
These forms should have named fields which remind the analyst which information
is to be collected and recorded. These replace unstructured sentences which describe
the requirement. This template should be based on the type of system which you are
specifying and the specific information needs of your organization. You will need to
define several templates to cater for different types of requirements.
Within your requirements template you may wish to include fields to support other
guidelines such as the requirements reference number (Guideline 9.1, Uniquely
identify each requirement), the sources of the requirement (Guideline 4.4, Record
requirements sources} and the rationale for the requirement (Guideline 4.8, Record
requirements rationale).
You should provide word processor templates for these forms to all those who are
likely to have to collect requirements. Use your standard word processor for this
rather than any special-purpose tool. You can then be sure that the forms can be
supported on all computers in your organization.
However, you should not force analysts to fill in all fields on a form and you should
not use special-purpose software which requires the fields in a form to be completed
in a particular order. Requirements discovery is a difficult process and different
people collect information in different ways. Imposing a single approach is likely to
be resisted. Always allow for a 'get out' where analysts may simply note the
requirement in any way, they wish in some comments field of the form. Predefined
forms cannot cover everything and there needs to be some flexibility in your system.
Some readers of requirements simply want a high-level description and do not want
to read pages and pages of forms. You should allow for this by including fields on
the form which may be extracted (automatically if possible) to create a shorter
(perhaps incomplete) description of the requirement. Make sure, however, that you
maintain links from this shorter description to the complete requirements
specification in the standard template. This will then allow you to generate a new
short description when changes to the requirement are agreed.
Costs and problems:
If you do not already have standards for presenting requirements, there is a
significant cost in introducing this guideline and developing an appropriate standard
for your organization. Although you can use the suggestions here as a basis for your
standard, you need to look at your existing requirements to check how many different
styles (and hence standards) that you use and to decide what information you need
to include in a requirements description.
After designing an initial set of standards you will have to assess them and, almost
certainly, modify them after you have experience of their use. If you already have
standards, you may wish to think about whether you should modify them to
incorporate some of the advice given in this book. Once a set of standard templates
has been established, there are few additional costs involved in applying the
guideline.
A problem which you may face is resistance from requirements engineers to
standards. They may have evolved their own way of working and do not wish to be
constrained by a standard way of recording requirements. You should try to avoid
this problem by disseminating information about the standard during its development
and by involving engineers in the standard development process. They will then feel
committed to the standard and therefore more likely to use it.
B. Use Language Simply, Consistently and Concisely.
When you are writing detailed system requirements, you should define a set of
standard templates which you use for organizing the description of these
requirements. The template should include fields to collect the detailed information
necessary to completely specify the requirement.
Benefits:
• When requirements are written using simple language, they are easier to read and
understand. The principal costs of requirements engineering are the costs of paying
people to read requirements. If you can reduce the time required for requirements
reading without losing understanding, you will have an immediate cost saving in your
requirements process.
• More people can understand requirements that are written in a simple way. It takes
less time to explain the requirements to stakeholders and a wider range of people can
participate in the validation of the requirements.
Implementation:
Many people find it difficult to write clear and concise natural language. They write
long and convoluted sentences and express the requirements in an unnecessarily
verbose way. To improve requirements descriptions, we recommend that you should
write a short style guide which describes how to use language in writing requirements
in your organization.
This guide must be short and easy to read. Otherwise, people will not have the time or
the inclination to read it. Ideally, your style guide should include four or five pages
of guidelines with examples of good and bad writing drawn from your own
experience.
Some basic writing style guidelines which might be included in your guide are as
follows.
1. Keep sentences short. Because of the limitation of our short-term memory, you
often need to read long sentences more than once before you can understand
them.
2. Never express more than one requirement in a single sentence. Avoid the use of
'and' in sentences. This implies that more than one requirement or concept is
being discussed.
3. Avoid the use of jargon, abbreviations and acronyms unless you are completely
confident that they will be understood by all readers of your document. Even then
be very careful; the same acronym may have different meanings in different
domains. For example, the acronym 'ATM' is used in both banking systems and
networking application domains. In a requirements document which describes
how ATMs (Automatic Teller Machines) should be connected using ATM
(Asynchronous Transfer Mode), you can imagine the confusion which could
arise.
4. Keep paragraphs short. As a general rule, no paragraph should be made up of
more than seven sentences. Again, the reason for this is due to the limits on
people's short-term memory.
5. Use lists and tables wherever possible to present information sequences. Lists
(like this one) are much easier to understand than sequences which are presented
as a single paragraph.
6. Use terminology consistently. Do not use a term to mean one thing in one place
in the document and something different somewhere else. This is very difficult
to achieve, especially when different people are responsible for writing different
parts of the document. Using a data dictionary to define the names of system
entities can be helpful here (see Guideline 7.5, Use a data dictionary).
7. Use words such as 'shall', 'should', 'will' and 'must' in a consistent way with the
following meanings:
• 'shall' indicates that the requirement is mandatory,
• 'should' indicates that the requirement is desirable but not mandatory
• 'will' indicates something that will be externally provided
• 'must' is best avoided. If used, it should be a synonym for 'shall'.
8. Do not express requirements using nested conditional clauses (i.e. if X then if Y
then Rla else if Z then Rlb else Rlc}. These are very easy to misunderstand. If
you cannot find a convenient way of expressing a requirement in natural language
without nested conditional clauses, use a different notation such as a decision
table.
9. Use the active rather than the passive voice, particularly when describing actions
taken by people or the system. Unfortunately, most technical writing is written
impersonally and many people find it difficult to change to a more personal style.
10. Do not try to express complex relationships in a natural language description.
Diagrams are much more effective for this purpose.
11. Never use anonymous references. When you refer to other requirements, tables
or diagrams, give a brief description of what you are referring to, as well as the
reference number. If you simply use a reference number, the reader may need to
look it up specially to remind themselves what it means.
12. Pay attention to spelling and grammar. Poor spelling and grammar can obscure
your meaning. A spelling checker should always be used. The style guide should
be included as part of your standard for specifying requirements. When you
organize requirements reviews, you should ask reviewers to comment on the
writing style used and to highlight requirements which are particularly difficult
to understand.
Costs and problems:

The principal costs of introducing this guideline are the writing of a style guide
and, if necessary, short training sessions for all involved in the RE process. These
should introduce them to the style guide and clear writing style. There is also a
slightly increased review cost but this is minimal so long as your style guide is
not too long.

Initially, you will probably find that it is quite expensive to introduce this
guideline into your requirements engineering process. Surprisingly, perhaps, it
takes longer to write requirements simply than in a more complex way. However,
as people gain experience with clear writing style, these costs will rapidly decline.

The problem that you are likely to face is that many people from a technical
background find it very difficult to write clearly and concisely. Introducing a style
guide is all very well but we have a long tradition of writing requirements in an
opaque and obscure way and this cannot be changed overnight. Although reviews
can highlight significant deviations from the style guides, this will not remove all
obscure writing.

C. Use Diagrams Appropriately

You should use diagrams in a requirements description wherever it is necessary
to show structural information or to show relationships between information in
the requirements description. Diagrams may also be used to summarize numeric
information and to describe sequences of events or activities.

Benefits:

• Diagrams are far more effective than text for presenting relationships between
items of information. Most people find diagrams easier to understand than textual
descriptions of structure or relationships.
• Diagrams break up sections of text into smaller, more readable fragments. This
means that you get a double bonus from the diagram. Information is presented
more comprehensibly and the surrounding text is easier to understand.
• Diagrams from a requirements document may be reused when making
requirements presentations to customers.
Implementation:

As part of your document style guide, we recommend including a section which

describes the circumstances where diagrams are most likely to be helpful. These
include the following.
1. Where something (a system, a document, etc.) is made up of a number of
modules or components and you wish to illustrate relationships between these
components. An example of this is where you use a block diagram to
illustrate the overall structure of a system.
2. Where you need to show a set of activities where each activity has a number
of inputs and outputs. Diagrams can be used to show the activity sequence
and where activities can be carried out in parallel.
3. Where you need to illustrate spatial organization, for example, of a control
panel.
4. Where you wish to show some decomposition structure such as an
organization chart.

A good general rule for drawing diagrams is to keep them as simple as

possible. Complex diagrams are often worse than no diagram at all. You
should use simple labelled boxes and lines to show structure and
relationships. Diagrams should fit onto a single page and should not have
'connectors' to other diagrams. Diagrams should always be labelled with a
figure number and a title. The figure number should always be used to refer
to the diagram.

You should avoid the use of icons which do not have an obvious meaning.
Many people find the commercial 'clip art' pictures provided with word
processing packages to be trite and irritating. Unless these are particularly
appropriate, these are also best avoided.

If color or shading is used, it should be used to distinguish different parts of

the diagram or for emphasis. Color should be used sparingly. You should not
associate meaning with specific colors as people from different backgrounds
may interpret color in different ways. For example, red may mean 'hot' in
some application domains and 'danger' in other domains. You should also
remember that about 10% of men are color-blind.

Some people think that diagrams are always easier to understand than textual
presentation. They therefore introduce diagrams everywhere even when the
same information could be presented more clearly using a list or a table. You
should not introduce diagrams unless they provide meaningful information
about structure or relationships. They should not be over-used or used to
present information which could be more clearly expressed in some other
way.
Costs and problems:

The costs of introducing this guideline are minimal. Diagrams can be drawn
using facilities which are now embedded in most word-processing systems.
More complex drawing packages can be used but these are designed for
professional illustrators and sometimes encourage the production of over-
complex diagrams. There may be some training costs for people to use the
drawing facilities but most packages are intuitive and can be self-taught with
little effort. The costs of applying the guideline are the costs of drawing
diagrams. These should not usually take much more time than textual
requirements description.

While you are unlikely to encounter any user resistance to this guideline, you
will probably find that some people are much better than others at expressing
their ideas in diagrams. This seems to reflect fundamental differences in
thinking and there is not much you can do about this. Some people think in
pictures, but people who do not think this way often prefer textual
descriptions to diagrams.
D. Supplement Natural Languages with Other Descriptions of Requirements.
Some requirements are best described using specialized notations, such as
mathematical formulae, decision tables, design notations or programming
languages, rather than natural language. Although you will almost always want
to have some description in natural language, you should supplement this, where
appropriate, with more precise descriptions in an appropriate notation.

Benefits:

• Specialized notations allow for descriptions whose meaning is less likely to be

misinterpreted than a natural language description. The description is often more
concise than a corresponding natural language description.
• If the notation used is familiar to application domain experts, they are less likely
to make mistakes when specifying their requirements and more likely to find any
errors which have been made.

Implementation:

Customers and systems engineers have different needs. Customers need to be

able to understand the requirements for the system. They need to make an
assessment of how this will contribute to their overall organizational objectives,
fit into existing working processes and integrate with other systems which are
used. Systems engineers need a detailed and unambiguous statement of
requirements on which their system design should be based. It should be possible
to trace from the requirements to the design through to the system
implementation.
It is often hard to meet these conflicting objectives if you only use natural
language. You should therefore supplement this with other notations such as the
following.
• Decision tables where actions have to be taken depending on a complex set of
conditions. Text which includes many conditional clauses is often ambiguous. It
is notoriously difficult to read and understand.
• Programming languages or program design languages which may be used
where you wish to describe a number of actions which must take place in
sequence and where some of these actions are conditional or may be repeated.
You may also use language descriptions for detailed interface specification.
• Algebra when you wish to describe how particular numeric values must be
transformed by an operation or particular values should be computed.
• Data-flow diagrams where you need to define a sequence of transformations
which take place during some end-to-end processing of data.
• Timing diagrams to illustrate time-critical system actions.
• System models such as object models, entity-relation models or finite state
models where you need to describe detailed system requirements.

The additional information provided by these notations is usually necessary when

the requirements must define detailed information such as a sequence of events
which must take place, the interfaces between sub-systems, etc. They are
therefore most likely to be used when your requirements document is a detailed
functional specification of the system to be implemented.

We do not know of any book where all these notations are described but many
of them are covered in Software Engineering, 5th edition by Ian Sommerville
(Addison Wesley, 1996).

Costs and problems:

In most cases, introducing this guideline does not require engineers to learn new
notations but to use techniques which they already know. In such cases, there are
no introductory costs for this guideline. We advise against introducing new
unfamiliar notations as these are likely to cause more problems than they solve.
There are obviously some costs in applying the guideline as tables, models, etc.,
have to be created. Like diagrams, however, these should not normally cost much
more than writing the equivalent technical description.

A possible problem may arise if mathematical or unfamiliar notations such as

decision tables are used. Some readers of the requirements may think that a
requirement is harder to understand because they do not know the notation. They
may therefore oppose the use of these notations. This is a particular problem
when the people against the idea of specialized notation are managers who can
decide whether or not they should be used. To overcome this resistance, you may
find it helpful to demonstrate that the more concise notations can be paraphrased
in natural language.
For further contents on the topic please refer a book entitled REQUIREMENTS
ENGINEERING A Good Practice Guide by lan Sommerville and Pete Sawyer
Lancaster University
Chapter Five: Requirement Validation
The objectives of requirements validation are to check the set of requirements which
have been defined and to discover possible problems with these requirements. The
process should involve system stakeholders, requirements engineers and system
designers. Requirements problems might be:
• lack of conformance to quality standards
• poorly worded requirements which are ambiguous
• requirements conflicts which were not detected during the analysis process.
These problems must be solved before the requirements document is approved. To fix
these problems, you usually have to re-enter the earlier process stages of requirements
elicitation, analysis and negotiation.
In this book, we make a distinction between requirements analysis and requirements
validation and cover them in separate chapters. These activities have much in common,
as they involve finding omissions in and conflicts between the system requirements.
However, there is an important difference between them.
1. Requirements analysis is concerned with 'raw' requirements as elicited from system
stakeholders. The requirements are usually incomplete and are expressed in an
informal and unstructured way. There will probably be a mixture of notations to
describe the requirements.
2. Requirements validation is concerned with checking a final draft of a requirements
document which includes all system requirements and where known incompleteness
and inconsistency has been removed. The document and the requirements should
follow defined quality standards.

The main problem of requirements validation is that there is nothing against which
the system can be validated. A design or a program may be validated using the
specification. However, there is no way to demonstrate that a requirements
specification is correct. The validation process can only increase your confidence
that the specification represents a system which will meet the real needs of the
system customer. Specification validation, therefore, really means ensuring that the
requirements document represents a clear description of the system for design and
implementation. It is your last chance before entering the system development
process to check that the requirements are acceptable to all system stakeholders.

Discovering and fixing requirements problems can avoid a lot of expensive reworks
of the system design and implementation. If you can catch errors and problems at
this stage, you can save a lot of money later. A number of studies have shown that
errors in delivered software systems which are a consequence of requirements errors
may cost up to 100 times as much to repair as programming errors.

Requirements validation is a prolonged process as it involves people reading and

thinking about a lengthy document. Meetings may have to be arranged and
experiments carried out with prototype systems. There is always a natural tendency
to rush the validation process so that system development can begin. However, if
you do not allow sufficient time for validation, you will almost certainly end up with
requirements problems. You may have to start on the system development, but you
must be prepared for rework when these requirements problems emerge.
A. Check that the Requirements Document Meets Your Standards
Before distributing the requirements document for general review, one person
should carry out quick standards check to ensure that the document structure and the
defined requirements are consistent with whatever standards have been defined.
Benefits:
• This is a cheap way to check standards conformance as you only need one person
to carry out this type of check. The requirements document should conform to the
defined standard but it is not worth everyone involved in the review process checking
the document against the standard and all reporting the same standards deviations.
• Checking against a standard can quickly reveal problems with the requirements. If
a requirements document does not conform to defined standards, it may indicate
largescale problems with the requirements specification which require management
intervention for their solution.
Implementation:
An analyst or an engineer who is familiar with the requirements standards but who
has not been involved in the system requirements specification should be responsible
for this initial standard check. It is not necessary for the document checker to
understand the requirements in detail.
The checker should compare the structure of the requirement document to the
defined standard and should highlight missing or incomplete sections. The search
and outline facilities provided with most word processing systems may be used to
find parts of the document and display the document structure. If you have a standard
for individual requirements, the checker should also check each requirement for
compliance with that standard.
This initial check should also check that all pages in the document are numbered,
that all diagrams and figures are labelled, that there are no requirements which are
unfinished or labelled 'To be completed' and that all required appendices in the
document have been completed.
After this process has been completed, there are two possible options if deviations
from the standard are found.
1. Return the document to the requirements engineering team to correct deviations
from the standards. This option should be chosen if there is enough time to allow
for a re-issue of the document.
2. Note the deviations from the standards and distribute this to document
reviewers. This saves the time and cost of creating a new version of the
requirements document. However, the deviations from standards may increase
the difficulty of the requirements review process. This option should be chosen
when there is a tight deadline for the requirements review or when the deviations
from the standard are minor, easily correctable and don't affect the
understandability of the document.
Costs and problems:
The costs of introducing and applying this guideline are low. Once you have defined
standards, the only introductory costs are where the checker is not familiar with the
standard and has to spend some time understanding this.
This is a very cheap guideline to implement and the return on investment in terms
of saved reviewing time is likely to be immediate. Unless the requirements
document is very large, this initial check should not take longer than one day. There
should be no problems in introducing this practice into the requirements engineering
process.
While it is unlikely that you will encounter any problems introducing this guideline,
there may be some problems applying the guideline, particularly in small
organizations. It may be difficult to find an independent checker to review the
document (independence is important because people who know the document read
what they think is there not what is actually there) and some people may not be
convinced of the value of this type of check
B. Organize Formal Requirements Inspections
The system requirements should be validated by a group of people who
systematically check the requirements, meet to discuss problems with the
requirements and agree on how these problems should be fixed.
Benefits:
• Formal inspections are a cost-effective way of discovering problems in
requirements documents, user documentation, software designs and
programs.
• The inspection is a neutral meeting for problem resolution where there
should be no blame attached to any problems discovered. Conflicts may
therefore be resolved during the inspection without confrontations between
stakeholders.
Implementation:
• The requirements inspection is a formal meeting. It should be chaired by
someone who has not been involved in producing the requirements which
are being validated. During the meeting, requirements engineer presents each
requirement in turn for comment by the group and identified problems are
recorded for later discussion. One member of the group should be assigned
the role of scribe to note the identified requirements problems.

A formal requirements inspection should involve a team of inspectors from

different backgrounds (see Guideline 8.3) who read the requirements
document and record problems with the system requirements. The document
reviewers may use a checklist. to help focus their attention on particular
aspects of the requirements and the requirements document.

Unlike program inspections where errors are simply reported to the program
author for correction, requirements inspections involve the group making
some decisions on actions to be taken to correct the identified problems.
Actions which might be decided for each problem are as follows.

1. Requirements clarification. The requirement may be badly expressed or

may have accidentally omitted information which has been collected
during requirements elicitation. The author should improve the
requirement by rewriting it.
2. Missing information. Some information is missing from the requirements
document. It is the responsibility of the requirements engineers who are
revising the document to discover this information from system
stakeholders or other requirements sources.
3. Requirements conflict. There is a significant conflict between
requirements and the stakeholders involved must negotiate to resolve the
conflict.
4. Unrealistic requirement. The requirement does not appear to be
implementable with the technology available or given other constraints
on the system. Stakeholders must be consulted to decide whether the
requirement should be deleted or modified to make it more realistic.
mostly concerned with program inspections, most of the advice is equally
applicable to requirements validation.
Costs and problems:
Introducing requirements inspections involves establishing checklists which can
drive the inspection and training people in inspection techniques. External
consultants will usually need to be involved in this Organize training. If you do not
have previous experience with inspections as part of your normal validation process,
you should introduce requirements inspections in a pilot project. This should run
alongside your normal validation process so will involve significant start-up costs.
The pilot project will help you assess whether this approach is cost-effective for your
organization and help you judge the best way to run these formal reviews.
Applying the guidelines involves moderate costs but will result in significant
downstream effort saving as rework is reduced. The time taken for an inspection
obviously depends on the size of the requirements document. There are published
figures available for program inspections (about 125 lines of code per hour can be
inspected, with the same time required for preparation) but not for requirements
inspections. Our guess is that probably about 40 requirements per hour could be
inspected with the same time required for preparation. Therefore, a document with
400 requirements would require a total of 50 person-hours of effort to inspect if a 4-
person team were involved.
Inspections require a group of people with different skills and responsibilities to read
documents and get together in the same place at the same time to carry out the
inspection. As the people involved may work for different organizations or different
parts of the same organization this can be very difficult. It is practically impossible
to define participation in requirements inspections as part of their job. You must,
initially at least, rely on their goodwill and the goodwill of their managers for
inspection participation. Of course, once the value of inspections has been
demonstrated, participation is less of a problem but, inevitably, people will have
problems fitting inspections into already busy schedules.
C. Use Multi-Disciplinary Teams to Review Requirements
The requirements document should be reviewed by a multi-disciplinary team drawn
from people with different backgrounds. This should include a system end-user or
end-user representative, a customer representative, one or more domain experts, one
or more engineers who will be responsible for system design and implementation
and one or more requirements engineers. This should apply whether you use formal
requirements inspections or a less structured review process.
Benefits:
• People from different backgrounds bring different skills, knowledge and
experience to the review. It is therefore more probable that requirements problems
will be discovered.
• If system stakeholders from different backgrounds are involved in the review
process, they feel involved ~in the requirements engineering process and develop an
understanding of the needs of other stakeholders. They are therefore more likely to
be sympathetic to changes which affect them, as they will know why these are
necessary.
Implementation:
You should choose the multi-disciplinary team from the different stakeholders who
have been involved in the requirements elicitation. Ideally, you should have
customer managers, one or more end-users, application domain experts, members of
the requirements engineering team and system developers in the validation team.
If this is not possible, try to ensure that you have at least one domain expert and one
possible end-user involved in the process. System developers should get involved at
this stage as they may find requirements which are particularly difficult to
implement. Spotting these and modifying them before design and implementation
can save a lot of effort and expense.
Costs and problems:
There should be no additional costs involved in introducing and applying this
guideline unless you use external consultants to bring specialized expertise into the
review. The major problem is ensuring a broad spectrum of involvement as some
people may be unable to take time from their other work to participate in the
requirements review. They may already have moved on to other projects. This is
particularly likely to be the case for domain experts and customer managers.
D. Define Validation Checklists
You should define a checklist or checklists which help to focus the attention of
requirements validators on critical attributes of the requirements document. These
checklists should identify what readers should look for when they are validating the
system requirements.
Benefits:
• Checklists add structure to the validation process. It is therefore less likely that
readers will forget to check some aspects of the requirements document.
• Checklists help in the introduction of people who are new to requirements
validation. The checklist gives them hints about what they should be looking
for so that they feel more able to participate in the process. This is particularly
important for customer management and end-users who may not have
requirements validation experience.
Implementation:
Use checklists for requirements analysis, and similar checklists may also be used in
the validation process. These checklists are oriented towards individual
requirements; validation checklists should also be concerned with the quality
properties of the requirements document as a whole and with the relationships
between individual requirements. This cannot be checked during requirements
analysis, as the requirements document is unfinished at that stage.
Questions which might be included in such a checklist should be based on the
following general issues.
1. Are the requirements complete, that is, does the checker know of any missing
requirements or is there any information missing from individual requirement
descriptions?
2. Are the requirements consistent, that is, do the descriptions of different
requirements include contradictions?
3. Are the requirements comprehensible, that is, can readers of the document
understand what the requirements mean?
4. Are the requirements ambiguous, that is, are there different possible
interpretations of the requirements?
5. Is the requirements document structured, that is, are the descriptions of
requirements organized so that related requirements are grouped? Would an
alternative structure be easier to understand?
6. Are the requirements traceable, that is, are requirements unambiguously
identified, do they include links to related requirements and to the reasons why
these requirements have been included? See Chapter 9 for guidelines on
traceability.
7. Does the requirements document as a whole and do individual requirements
conform to defined standards?
Checklists should be expressed in a fairly general way and should be understandable
by people such as end users who are not system experts. As a general rule, checklists
should not be too long. Checklists should not normally have more than ten items. If
you have more than this, checkers cannot remember all items and must continually
re-consult the checklist.
The danger, of course, is that checklist becomes too vague and it is impossible to
answer the checklist questions in any useful way. You have to find the right balance
between generality and detail. Unlike program inspections, low-level checklists
concerned with very specific faults are not so good for requirements inspections
because of the differences between the requirements for different types of system.
Checklists can be distributed and simply used as a reminder of what people should
look for when reading the requirements document. Alternatively, they can be used
more systematically where, for each requirement, an indication is given that the
checklist item has been considered. This may be done on paper or you can manage
this type of checklist completion by using a simple database or a spreadsheet. The
checklist items are shown along the horizontal axis and the requirements along the
vertical axis. The checker should fill in each cell with an appropriate comment. You
should not force checkers to use an automated approach, as people may read the
document in places and at times when they do not have computer access.
Costs and problems:
This is not an expensive guideline to implement if you use a fairly general checklist
with questions like those listed above. To introduce the guideline, you need to draw
up an initial checklist based on the experience of people who have been involved in
requirements validation.
If a checklist is simply used as a memory aid, there are no costs involved in applying
the guideline. If checkers of the requirements must mark each requirement against
the checklists, clearly some additional time is required. This should not be more than
one or two minutes per requirement.
In principle, there should be few problems in applying the guideline so long as you
have a fairly flexible process which allows people to ignore inappropriate checklist
entries. In practice, some requirements analysts may resent the introduction of
checklists as they see them as de-skilling the process. You have to emphasize that
the checklists are designed to help them and point out that professional judgement
must still be used
Chapter 6: Requirement Management
During the processes of requirements engineering, system development and operation,
new requirements emerge and existing requirements change. These changing
requirements must be managed to ensure that the quality of the requirements is
maintained. The impact of requirements changes must be understood and requirements
changes implemented in a timely and cost-effective way. It is also important to ensure
that the requirements keep in step with the operational system. System changes must be
reflected as requirements changes and vice-versa.
Requirements management is, therefore, a process which supports other requirements
engineering activities and is carried out in parallel with them. A recent European survey
of 4000 companies found that the management of customer requirements was one of the
principal problem areas in software development and production. These problems were
not confined to the management of requirements for external clients. There were also
problems of managing requirements change where the system was being specified and
developed in the same organization.
Problems with requirements management often mean that systems whose requirements
do not satisfy the customer are delivered. Systems development schedules may be
extended and high costs incurred for rework of the design and implementation to
accommodate requirements changes. The costs of these problems in the long-term
usually outweigh the short-term costs of introducing good requirements management
practice.
The principal concerns of requirements management are:
1. managing changes to agreed requirements
2. managing the relationships between requirements
3. managing dependencies between the requirements document and other documents
produced during the systems and software engineering process.
Requirements changes may be due to errors and misunderstandings in the requirements
engineering process, design or implementation problems. New requirements may
emerge as stakeholders develop a deeper understanding of the system. Most commonly,
however, requirements change is a result of changing external circumstances. The
strategy or priorities of the business buying the system may change as a result of
changing economic circumstances or new competitors in its market. New information
about the system's environment may become available, e.g. new digital maps for a
geographic information system. New laws or regulations may be introduced which
require system change.
To manage requirements, you need to maintain requirements traceability information.
A requirement is traceable if you can discover who suggested the requirement, why the
requirement exists, what requirements are related to it and how that requirement relates
to other information such as systems designs, implementations and user documentation.
Traceability information helps you discover what other requirements might be affected
by requirements changes.
Good requirements management practices such as maintaining dependencies between
requirements have long term benefits. These are better customer satisfaction and lower
system development costs. These returns are not immediate so requirements
management may appear to developers as an overhead. It makes it more difficult for
them to make changes to the system on time and within budget. In these circumstances,
you must persevere; experience has shown that investment in good requirements
management processes is always cost-effective.
A. Uniquely Identify Each Requirements
Each requirement should be assigned a unique identifier or reference number which
may be used to refer to that requirement in other parts of the requirements document or
in other system documentation.
Benefits:
• Unique identifiers may be used to make references to related requirements and to
construct traceability tables.
• If you store your requirements in a database, the requirement identifier may serve as
a primary key which uniquely identifies the requirement in the database. References
from one requirement to another in the database may use this primary key.
• Requirements inevitably evolve and you may wish to manage this evolution by using
a configuration management system. The requirement reference number can be the
basis for linking versions of the requirements which have evolved from the same
starting point.
Implementation:
The most commonly used approach to requirements identification is to assign numbers
depending on the chapter and section of the requirements document where the
requirement is included.
There are two difficulties with this style of requirements identification. Firstly, when
you collect a requirement, you do not know where it will appear in the document so
you cannot assign it a number until a version of the requirements document is issued.
This means that it is difficult to refer to it in other requirements. Secondly, assigning
an identifier based on chapter and section numbers positions the requirement in a
classification structure. It suggests that the requirement is most closely related to other
requirements with similar identifiers. Document readers may be misled into thinking
that there are no other important relationships between that requirement and other
requirements elsewhere in the document.
You can address this problem in two ways.
• Some word-processing systems allow for automatic renumbering of paragraphs and
the inclusion of cross references. You can therefore assign a number to a requirement
at any time. As you re-organise your document and add new requirements, the system
keeps track of the cross-reference and automatically renumbers your requirement
depending on its chapter, section and position within the section. This is the solution
we recommend if you have the right kind of word processor facilities.
• You can assign an interim identifier to each requirement then replace it with some
number when you produce your final document. Rather than a number, you are best to
use some mnemonic derived from the contents of the requirement e.g. EFF-1, EFF-2,
EFF-3 for requirements which concern the efficiency of the system.
These schemes apply to requirements expressed as text. System models should also be
assigned a unique identifier. Parts of a system model such as entities in a diagram do
not need to have a globally unique identifier but their names should be unique within
the model. They may be referenced by giving the model identifier then the entity name.
Costs and problems:
Introducing and implementing this guideline is very cheap. To introduce it, the only
costs are the costs of defining a numbering convention. People sometimes like to argue
over numbering schemes but reaching agreement on a numbering scheme should not
be a significant problem in most organizations. The costs of applying the guideline are
the costs of renumbering requirements when changes are made. These are negligible if
some automatic renumbering system is available.
B. Define Policies for Requirements Management
Requirements management policies define goals for requirements management, the
procedures which should be followed and the standards which should be used. These
policies should be explicitly defined as part of your quality management system.
Benefits:
• Explicit policies tell people involved in the process what they are expected to do and
why it should be done. Projects generally manage their requirements in comparable
ways so, with explicit policies, there is less dependence on individual knowledge and
expertise.
• In order to define policies, you must understand your existing processes for
requirements management. This is likely to reveal problem areas which may become
the focus of process improvements.
Implementation:
Requirements management policies are a basis for the quality management of the
system requirements. Policies are not the same as standards but are clearly related to
them. Policies, loosely, set out what should be done; standards describe how the policy
should be implemented in a particular situation. Some policies may be reflected in
organizational standards but individual project is sometimes the best judge of how
policies should be implemented.
Organizations should define a general set of requirements management policies. For
each project, you must look at this general set of policies and select those which are
relevant to that project. They may be amended in some ways to suit the specific needs
of the project.
General requirements management policies should include:
1. a set of objectives for the requirements management process and rationale
associated with each of these objectives
2. the reports which should be produced to make the requirements engineering process
visible and the activities which are expected to produce these reports as deliverables
3. the standards for requirements document and requirements descriptions which
should be used.
4. change management and control policies for requirements (see Guideline 9.6)
5. requirements review and validation policies
6. relationships between requirements management and other system engineering and
project planning activities
7. traceability policies which define what information on dependencies between
requirements should be maintained and how this information should be used and
managed.
8. criteria when these policies can be ignored; in these situations, managers use their
own judgement on how to implement requirements change.
Of course, it is unrealistic to expect to define and introduce all of these policies at the
same time. They should be developed incrementally and updated after you have
practical experience of their application in requirements management.
You must build some flexibility into your policies otherwise they will be unworkable.
There is sometimes such an urgent need for system change, that it is impossible to
follow through a systematic requirements management policy before implementing
that change. You must have some mechanism for managing these exceptions. It should
suggest how you maintain the information which can eventually be used to update the
requirements which are being managed.
Costs and problems:
It may take several months of effort and at least a year of calendar time to establish a
coherent set of requirements management policies. You must consult with those
involved in the requirements engineering process, propose, review and amend policies
then introduce a dissemination and training programmed to ensure that people are
aware of the policies and know how to apply them.
When policies have been defined, you must check that the procedures and standards
implementing these policies are being followed. The costs of applying this guideline
are therefore part of your quality assurance costs.
In principle, people will always be supportive of requirements management policies.
In practice, however, you may find that they do not give the creation of these policies
a high priority. This is particularly likely for those who are not directly involved in
requirements engineering. They may feel that this is not their responsibility. However,
you must try to involve these people. If you do not, they will, at best, complain that
they were not consulted; at worst, they will refuse to accept the policies which have
been proposed.
C. Define Traceability Policies
As part of your requirements management policy, you should define what traceability
information should be maintained and how this should be represented. Traceability
information is information which allows you to find dependencies between
requirements, and between the requirements and the system design, components and
documentation.
Benefits:
• Traceability information is standardized. Those responsible for assessing
requirements changes therefore know what information is likely to be available and
how it will be represented.
• Traceability policies are a basis for cost and quality control. Collecting and managing
traceability information is expensive. Traceability policies mean that you can control
these costs by collecting essential traceability information and not collecting large
amounts of information which you cannot maintain.
• It may be possible to provide some software support for your defined policies.

Implementation:
Traceability policies are written policies which should define the following.
• The traceability information which should be maintained. This is described in more
detail below.
• The techniques which may be used for maintaining traceability. This is described in
more detail below.
• A description of when the traceability information should be collected during the
requirements engineering and system development processes. You should also define
the roles of the people, such as the traceability manager, who are responsible for
maintaining the traceability information.
• A description of how to handle and document policy exceptions, that is, when time
constraints make it impossible to implement the normal traceability policy.
Realistically, there will always be occasions where you have to make changes to the
requirements or the system without first assessing all change impacts and maintaining
traceability information. The policy exceptions should define how these changes
should be sanctioned. The traceability policies should also define the process used to
ensure that the traceability information is updated after the change has been made.
Traceability policies should be written so that they are independent of any particular
system. As part of your quality planning process, you should select the most relevant
traceability policies and tailor them to the specific needs of the system which is being
specified. These should then be defined in the system traceability manual.
Maintaining traceability information is expensive because it involves managing large
volumes of information. Requirements changes may involve making changes to this
traceability information in several places to record new or changed dependencies. You
must be realistic in defining your traceability policies and you should not make them
too bureaucratic. It is better to have lightweight policies which are followed rather than
more comprehensive traceability policies which are ignored by project managers.
This guideline may be implemented by organizations at any level of requirements
engineering process maturity. Simple traceability of requirements to their sources and
other requirements may be implemented by organizations at the basic level in the
requirements engineering process maturity model. As organizational maturity
increases, more complex traceability policies may be introduced.
Traceability information:
There are different types of traceability information which you might want to maintain.
There are three basic techniques which may be used to maintain traceability
information. These are as follows.
1. Traceability tables. A cross-reference matrix is produced where the entries in the
table indicate some kind of traceability link between the items in the rows and the
items in the columns.
2. Traceability lists. Each requirement has a list of associated traceability information
3. Automated traceability links. The requirements are maintained in a database and
traceability links are included as fields in the database record.
Costs and problems:
The cost of introducing this guideline into your requirements engineering process are
comparable with the costs of defining any other significant quality management
procedure. Several months of calendar time may be needed for consultation, and
significant effort is required to ensure that high-quality policies are defined and
reviewed. Once these procedures have been agreed, there are some maintenance costs
as you introduce changes based on experience with them. Making these changes should
not normally be an expensive process.
The costs of implementing traceability depends on the specific traceability policies and
on the number of requirements for your system. Unfortunately, the costs of traceability
increase disproportionately as the number of requirements increase. Therefore, while
the costs of implementing fairly comprehensive traceability policies may be moderate
for a small system, the same policies may be impractically expensive for large systems.
The main problem that you are likely to encounter is doubts about the value of
procedures which do not provide an immediate benefit (see the discussion in the
introduction) and some resistance, perhaps, to implementing these procedures. People
may have had previous experience with traceability problems and the difficulties posed
by managing large volumes of traceability information. You must be realistic about
what traceability" information can be maintained; you should not ask analysts to record
information which will never be used. You must also stress the long-term benefits of
traceability and convince people (by example if possible) of the benefits of maintaining
this information.
D. Use a Database to Manage Requirements
Benefits:
Rather than maintaining requirements in text documents, establish a requirements
database and store the individual requirements as entries in this database.
• Managing requirements in a database makes it easier to maintain links between
individual requirements and to search for and abstract related groups of requirements.
• If the database is a general-purpose repository for system information, links from the
requirements to design and implementation information may be maintained.
• If the database supports concurrent working, it allows for different groups to work on
the requirements specification at the same time without generating requirements
inconsistencies. Database facilities for data backup, integrity and security mean that
requirements engineers need not be concerned with these issues.
• The requirements may be automatically processed to extract particular types of
information. For example, it may be possible to generate traceability tables and lists
automatically from information in the requirements database.

Implementation:
The most appropriate way to implement this guideline depends on the type and the
number of requirements which must be managed and the particular ways of working in
your organization. Issues which influence design choices are as follows.
1. How are requirements expressed? Do you use natural language, graphical models,
mathematical expressions, etc.? Do you need to store additional information such
as photographs as part of the requirements rationale? If you need to store more than
just simple text, you may need to use a database with multi-media capabilities.
2. How many requirements do you typically need to manage? Is it tens, hundreds,
thousands or tens of thousands? The requirements for a small to medium sized
system can be managed using commercial PC databases. Larger systems usually
need a server-based system and a database, such as ORACLE, which is designed to
manage a very large volume of data.
3. Are the requirements always developed and managed by teams which work
together at the same site and which use the same types of computers or do you need
to access the requirements database from different sites? If you need multi-site
access from different types of equipment, you should use an Intranet-based solution
which provides access to the requirements database through a WWW browsing
system.
4. Do you already use a database for software engineering support? Do you have a
company policy on database use? What types of computers do you use? These
factors obviously constrain the type of database which you can use.
5. What in-house database expertise do you have available? Will requirements
engineers be responsible for database administration or will this be a separate
responsibility? Database management costs can be high and a solution which
requires a specialist database administrator may not be cost-effective.
If you maintain your requirements in a database, you can design the requirements
database to include traceability information. With each requirement in the database,
you should include at least two fields for traceability information. These should be
filled in with references to other requirements which the requirement depends on
and with references to requirements which are dependent on that requirement.
Obviously, if you wish to maintain other types of traceability information such as
requirements-architecture links, you must include database fields to record
information about each different type of relationship.

Using the database system has the advantage that the database itself usually
includes facilities for browsing and report generation. You can browse the
requirements in the database then move immediately to related requirements. You
may also write simple scripts which scan the database and generate the specific
traceability information which you require.

Relational databases are now the most commonly used type of database. Relational
databases were designed for storing and managing large numbers of records which
have the same structure and minimal links between them. A requirements database,
however, may have relatively few records (hundreds rather than hundreds of
thousands) each of which includes many links such as links to documents, text files
and other requirements. Maintaining these links is possible with a relational
database. However, it is inefficient as it requires operations on several different
tables. For very large numbers of requirements, you may find that this type of
database is too slow.

To use a relational database, you may have to keep the text of the requirements in
a separate file or files and access these files through the database. The database
tables (which use the requirements identifiers as keys) are used to index
requirements and to store links between related requirements. You find linked
requirements using the relational join operation.

Object-oriented databases have been developed relatively recently and are

structurally more suited to requirements management. They allow different types
of information to be maintained in different objects and managing links between
objects is fairly straightforward. However, this type of database is still immature
and low-cost object-oriented databases are not widely available. They are also
probably more expensive to manage than relational databases.

If you have a very large number of requirements, you will need to use a powerful
database management system such as ORACLE. This might be organized as a
database server on a workstation with access through other client workstations or
PCs. This is an expensive approach but the power of these systems allows for fast
database manipulation. They also usually have excellent report generation tools
which can be used to create skeletal requirements documents from the requirements
database. These databases can support many simultaneous users and provide good
facilities for backup and recovery in the event of system failure.
Lower-cost approaches are possible using simpler PC database systems. Modern
PC databases include facilities for managing multimedia information such as
diagrams and photographs. Some of them can use object sharing facilities (such as
OLE) to link directly to word processor files where the requirements text is stored.
Their support for simultaneous access may be limited to locking the whole database
when it is in use and they have limited facilities for error recovery. The
requirements database must provide shared access and access control to the
requirements.

Whatever database you use, some data administration will be required. The data
administrator must set up and manage the database schema. He or she should also
be responsible for executing backup and recovery procedures and providing support
to database users. Database administration can take up quite a lot of time; a large
requirements database may need several hours per week of a professional database
administrator's time.

If you require access to your requirements database from remote sites and using a
variety of different computers, you might consider using WWW-based information
system as a front-end for a requirements database server. At the time of writing,
various off-the-shelf solutions of this type have just become available. We do not
know of any experience reports of using this type of information system for
requirements management but it is an interesting development which has
significant future potential.

A requirements database may be used in conjunction with special-purpose CASE

tools for requirements management. There are now several of these tools on the
market, ranging from simple PC systems to large and complex workstation-based
tools intended to manage large requirements databases. These tools provide built-
in traceability support and some of them support the automatic creation of
requirements databases from a natural language requirements document. We do not
endorse any specific tool but include details of tool suppliers in the book's WWW
pages.

Costs and problems:

There is a significant cost involved in setting up a requirements database and

putting procedures in place to ensure that it is used. Using special-purpose tools
obviously incurs some capital costs and training costs to put these systems into use.
It is unlikely that you will recover all of these costs from improved requirements
management in a single project. The benefits of this guideline will only emerge
after the database is used in several projects.

The costs of applying the guideline include the costs of database administration
and, obviously, data entry costs for entering the requirements in the database. These
costs are proportional to the number of requirements to be managed.
One of the major problems with a requirements database is linking the database to
the requirements document. Readers of the requirements document will not be
prepared to use the database directly so you must have procedures which will
automatically create the requirements document from information in the database.
This is becoming much easier as it is possible in some databases to link directly to
word processor files. In other cases, the database information may be processed to
generate the requirements in a standard word processor format such as Microsoft's
RTF format or in HTML, the formatting language for WWW documents.

If you are planning to use a database for requirements management, adding

traceability links is relatively inexpensive. If you already have a database and you
have not designed these into the database schema, it may be very expensive to
retrofit them. A problem which you may encounter is that many database systems
do not allow you to create fields which include more than one reference to other
database records. Most requirements, however, will include dependencies on
several other requirements, so you must get round this limitation in some way.
E. Define Change Management Policies
You should define policies for managing changes to requirements which set out how
changes are formally proposed, analyzed, and reviewed. Accepted changes are then
implemented to create a new version of the requirements document.
Benefits:
• Change management policies allow overall costs to be controlled by ensuring that the
whole life-cycle impact of requirements changes is taken into account.
• As requirements changes are proposed, there is a need to keep track of the status of
these changes and to be able to produce reports on requirements evolution.
• Change management policies give stakeholders a formal mechanism for proposing
changes to requirements which does not favor any specific group of stakeholders.
Implementation:
Change management policies are concerned with the procedures, processes and
standards which are used to manage changes to system requirements. Change
management policies mean that similar information is collected for each proposed
change and that overall judgements are made about the costs and benefits of proposed
changes. Without change management policies, you cannot be sure that proposed
changes to the requirements add to the general services provided by the system and
help support business goals.
The change management policies which you establish should define the following.
1. The change request process and the information required to process each change
request.
2. The process used to analyze the impact and costs of change and the associated
traceability information.
3. The membership of the body which formally considers change requests.
4. The software support (if any) for the change control process. We recommend that
you develop a change management database where you store all change requests.
Within this database, you should maintain information about the change request,
its status and how it has been implemented.
Stakeholders should submit proposals for requirements changes using a pre-defined
form. This should include fields to collect information about the change and the impact
of the change on other requirements, the system implementation and other system
documentation. After initial filtering to remove changes which are a result of
stakeholder misunderstanding, the impact and the costs of the change are assessed. The
change and its associated costs are then considered by some formal group (in military
projects, this is called a change control board) who decide whether or not the change
to the requirements should be accepted.
If possible, the change management process should be supported by software. There
are now several systems available which claim to support change management. Most
of these are oriented towards software change control and some are tightly integrated
with commercial configuration management systems.
Of course, you can use a general-purpose database to store change requests, associated
status information and links to the requirements themselves. You can also use email
for information distribution and circulation. However, you have to transfer information
manually from the e-mail system to the change management system and this is a
potential source of error and delay.
Ideally, you should integrate a change control system with a requirements database.
This should let you keep track of the different versions of requirements and link the
proposed changes with the initial requirement and any revision of that requirement.
Unfortunately, CASE tools for version and configuration management are mostly
geared towards managing files of information (such as source programs) rather than
relatively short, individual requirements in a database. To manage this information,
you need a version management system which can deal with 'fine-grain' objects.
However, you can certainly use a conventional version management system to manage
revisions of the requirements document.
You can find out more about change management and more general aspects of
configuration management in Chapter 33 of Software Engineering (Ian Sommerville,
Addison Wesley, 1996). This includes an example of a change request form which
may be used. We have also included information about some commercial
configuration management systems on the book's WWW pages.
Costs and problems:
Defining and implementing change control policies is fairly expensive. You must
allow several months for the change management policies to be defined and brought
into use. After it has been introduced, the costs of running the system are the costs of
assessing the impact of changes and ensuring that this information is recorded in the
change management system.
If you have managed requirements changes in an informal way where stakeholders
discuss changes directly with requirements engineers and software developers, you
may find resistance to the scheme from both of these groups. They may perceive
change management policies as an unnecessary overhead which increases the time
needed to implement changes. To counter this, you must make clear that, in the long-
term, uncontrolled change cost a great deal. They are likely to lead to a 'requirements
drift' where the system evolves towards the needs of those who are most able to
influence the engineers responsible for system evolution.
If you don't automate the change management process, you will probably have
information management problems. These are not just due to the volume of
information which must be processed but also due to the fact that change proposals
must be analyzed by different people. It is very easy to lose track of where each change
request is in the process.
F. Identify Volatile Requirements
You should maintain a list of the most volatile requirements, that is, those requirements
which are most likely to change. If possible, you should predict likely changes to these
requirements.
Benefits:
• System developers may be able to design the system so that volatile requirements are
implemented in modules which are loosely coupled to the rest of the system. This
means that software changes to accommodate requirements change will be easier to
implement.
• Planning for change is easier if likely changes are predicted. You will find it easier to
manage the evolution of the requirements document and to plan the development of the
system.
Implementation:
All system requirements may change but it is generally the case that some requirements
change more frequently than other, more stable, requirements. To implement this
guideline, experienced requirements engineers should examine all of the system
requirements and identify those which are likely to be particularly volatile. We
recommend that you should identify these requirements during the requirements
validation process or when your initial set of traceability information is created.
We have suggested that this guideline is an advanced guideline because you will not
really get any benefits from it until you have requirements management and change
management policies in place.
There are different types of volatile requirements.
1. Mutable requirements. These are requirements which change because of changes
to the environment in which the system is operating. For example, the requirements
for a system which computes tax deductions evolve as the tax laws are changed.
2. Emergent requirements. These are requirements which cannot be completely
defined when the system is specified but which emerge as the system is designed
and implemented. For example, it may not be possible to specify, in advance, the
details of how information should be presented. As stakeholders see examples of
possible presentations, they may think of new presentations that would be useful to
them.
3. Consequential requirements. These are requirements which are based on
assumptions on how the system will be used. When the system is put into use, you
will find that some of these assumptions will be wrong. You will also find that users
will adapt to the system and find new ways to use its functionality. This will result
in demands from users for system changes and modifications.
4. Compatibility requirements. These are requirements which depend on other
equipment or processes. As this change, these requirements also evolve. For
example, an instrument control system may have to be modified when a new
display is added.
To identify volatile requirements, you must involve application domain specialists who
will know which domain information is fairly stable and which is variable. If you can
assign requirements to one of the above classes, that is also an indicator of volatility. It
may also be helpful to discuss possible organizational change with senior management.
However, they may not be completely candid here as they do not want people to know
of the organizational impact of planned changes.
You will not get change prediction 100% right and you will not be able to identify all
volatile requirements. Identify all Volatile Requirement Unexpected changes will
always occur. You should update your list of volatile requirements as you gain
experience; you may find that some of the requirements which you thought were
volatile are fairly stable.
To identify volatile requirements in a database, you should add a field to the
requirements record whose value indicates the estimated volatility of the requirement.
We suggest a three-point volatility scale where 1 means fairly stable, 2 means subject
to medium term change and 3 means that the requirement is likely to change in the
short-term.

Costs and problems:

There are no significant costs involved in introducing this guideline. Applying the
guideline is not expensive if you have experienced engineers available who can make
judgements about requirements volatility during the requirements validation process.
At that stage, you should have a stable and complete set of requirements so it should
be possible to identify those requirements which are likely to change. Maintaining
information about volatile requirements is a form of traceability information. As with
all traceability information, the major problem with this guideline is ensuring that the
information about volatility and predicted change is kept up-to-date as the requirements
change.
Chapter 7: Requirement Engineering tools
Estelle finally got her SRS document completed and approved. Now James wants to
add a requirement, but it messes up the numbering scheme, incrementing the labels for
requirements that follow it in that section of the document. Estelle hopes that changing
the requirement identifiers won’t cause problems for anyone already working from
those requirements. Sean requests to delete a requirement. Estelle suspects that the
requirement might come back into scope in the future, so she wonders where to put it
and how to keep the developers from working on it now. Antonio asked Estelle
yesterday why a specific requirement was included, but she didn’t have any way to
answer that question.
One of the developers, Rahm, asked for a list of all the requirements that he was
responsible for on the next release, but Estelle doesn’t have any easy way to generate
such a list. In fact, it’s not easy to keep track of which requirements are scheduled for
which release, because they are all stored in the same document. Estelle would like to
know the status of requirements that are already under development, but she doesn’t
have an easy way to find that information either.
Estelle’s document-based requirements approach is falling short of her requirements
management needs. She needs a tool.
In earlier chapters, we discussed the creation of a natural-language software
requirements specification to contain the functional and nonfunctional requirements, as
well as documents that contain the business requirements and user requirements. We
pointed out that these deliverables are just containers for sets of requirements
information; they need not be traditional word-processing documents. Although still
widely used, a document-based approach to developing and managing requirements
has numerous limitations, including the following:
• It’s difficult to keep the documents current and synchronized.
• Communicating changes to all affected team members is a manual process.
• It’s not easy to store supplementary information—attributes—about each
requirement.
• It’s hard to define links between requirements and other system elements.
• Tracking the status of both individual requirements and the entire set of
requirements is cumbersome.
• Concurrently managing sets of requirements that are planned for different
releases or for related products is tricky. When a requirement is deferred from
one release to a later one, a BA needs to manually move it from one
requirements specification to another.
• Reusing a requirement generally means that the business analyst must copy the
text from the original document into another document for each other system
or product where the requirement is to be used.
• It’s difficult for multiple project participants to modify the requirements,
particularly if the participants are geographically separated.
• There’s no convenient place to store proposed requirements that were
considered but rejected and requirements that were deleted from a baseline.
• It’s hard to create, trace, and track edits to analysis models in the same location
as requirements.
• Identifying missing, duplicate, and unnecessary requirements is difficult.
Requirements development (RD) tools and requirements management (RM) tools
provide solutions to all of these limitations. RD tools can help you elicit the right
requirements for your project and judge whether those requirements are well-written.
RM tools help you manage changes to those requirements, track status, and trace
requirements to other project deliverables.
A team working on a small project might be able to get away without using any
requirements tools, instead using documents, spreadsheets, or simple databases to
manage their requirements. Teams working on large projects will benefit from
commercial requirements engineering tools. None of these tools replaces a defined
process that your team members follow to develop and manage their requirements. Use
a tool when you already have an approach that works but that requires greater
efficiency. Don’t expect a tool to compensate for a lack of business analysis and
requirements engineering process, training, discipline, or experience.
This chapter presents several benefits of using requirements tools and identifies some
general capabilities you can expect to find in such products. Dozens of commercial
requirements tools are available. This chapter doesn’t contain a feature-by-feature tool
comparison, because the products are constantly evolving and their capabilities (and
sometimes their vendors) change with each release. RD and RM tools often aren’t
cheap, but the high cost of requirements-related problems can justify your investment
in them. Recognize that the cost of a tool is not simply what you pay for the initial
license. The cost also includes annual maintenance fees and periodic upgrades,
software installation and configuration, administration, vendor support and consulting,
and training for users. Cloud-based solutions eliminate some of these additional support
activities and costs. Your cost-benefit analysis should take into account all of the
expenses before you make a purchase decision.

A. Requirement Development Tools

Requirements development (RD) tools are used by business analysts to work with
stakeholders to elicit and document requirements more effectively and more efficiently
than with manual methods. Stakeholders will vary in how they best consume and share
information: textually, visually, or audibly. RD tools can improve stakeholder
collaboration by accommodating a variety of communication methods (Frye 2009).
This section subdivides the development tools into elicitation, prototyping, and
modeling tools. Some of the tools in the RD category provide all of these services.
Some of them also offer requirements management capabilities. In general, RD tools
are not as mature as RM tools, and their overall impact on projects is typically less than
that of RM tools.
Elicitation tools:
Elicitation tools include those used for recording notes during elicitation sessions.
These enable the BA to quickly organize ideas and to annotate follow-up questions,
action items, core terms, and the like. Mind-mapping tools facilitate brainstorming as
well as organizing the information produced. Audio pens and other recording tools
allow playback of conversations or provide visual reminders of what happened during
an elicitation session. Some recording devices also tie the audio directly to the text that
was written at the same time, enabling you to hear specific portions of the audio
conversation as needed. Tools that support quality checks, such as scanning a
requirements document for vague and ambiguous words, help a BA write clearer
requirements. Some elicitation tools convert requirements from text to auto-generated
diagrams. Certain tools also enable collaborative voting to help a team prioritize
requirements.
Prototyping tools:
Prototyping tools facilitate the creation of work products that range from electronic
mock-ups to full application simulations. Simple prototyping tools come with basic
shapes and designs to create low-fidelity wireframes (Garmahis 2009). Common
applications such as Microsoft PowerPoint can be used to quickly mock up screens and
the navigations between them or to annotate existing screen shots. Sophisticated tools
might enable mocked-up functionality that a user can click through to see just how the
application would work. Some prototyping tools support version control, feedback
management, requirements linking, and code generation. If you use a tool to create
high-fidelity prototypes, make it clear to customers that the prototypes are just possible
models and that the final product might be different. Some prototyping tools can show
screen mock-ups in a “hand-drawn” style to help manage customer expectations.
Modeling tools:
Requirements modeling tools support the use of standard shapes, notations, and syntax
for drawing diagrams according to established conventions. They might provide
templates as starting points and examples to help the BA learn more about each model.
Often these tools automatically connect shapes in diagrams to accelerate the drawing
process and to help ensure that the diagrams are drawn correctly. They also enable you
to create diagrams that look cleaner and more consistent than if you draw them
manually. Specialized software modeling tools facilitate iteration by dragging along
connected arrows and labels whenever you move a symbol in the diagram; general-
purpose drawing tools might not provide that capability.
Many requirements management tools also provide some modeling capability. The
most sophisticated tools allow you to trace individual requirements to models or even
to specific elements of models. For example, analysts can create swim lane diagrams
in the tool, and then after they write requirements, they can trace those requirements
back to specific steps in the diagrams.
Keep in mind that no tool will be able to tell you if a requirement or a model element
is missing, logically incorrect, or unnecessary. These tools enable BAs to represent
information in multiple ways and to spot certain types of errors and omissions, but they
don’t eliminate the need for thinking and peer review.
Requirements management tools:
An RM tool that stores information in a multiuser database provides a robust solution
to the limitations of storing requirements in documents. Small project teams can get
away with just entering the requirements text and several attributes of each
requirement. Larger project teams will benefit from letting users import requirements
from source documents, define attribute values, filter and display the database contents,
export requirements in various formats, define traceability links, and connect
requirements to items stored in other software development tools.
Requirements management tools have been available for many years. They are both
more plentiful and more mature than requirements development tools. To be fair, the
problem they solve is more tractable. It’s easier to create a database in which to store
requirements and provide some capabilities to manipulate them than to help a BA
discover new knowledge, craft that knowledge into precise requirement statements and
diagrams, and ensure that the resulting information representations are correct. Some
tools combine both RD and RM capabilities into a powerful solution aid.
Benefits of using an RM tool:
Even if you do a magnificent job of eliciting and specifying your project’s
requirements, you can lose control of them as development progresses. An RM tool
becomes most valuable as time passes and the team members’ memories of the
requirements details fade. The following sections describe some of the tasks such a tool
can help you perform.
Manage versions and changes Your project should define one or more requirements
baselines, each identifying a specific collection of requirements allocated to a particular
release or iteration. Some RM tools provide baselining functions. The tools also
maintain a history of the changes made to each requirement. You can record the
rationale behind each change decision and revert to a previous version of a requirement
if necessary. Some tools contain a change-proposal system that links change requests
directly to the affected requirements.
Store requirements attributes Everyone working on the project must be able to view
the attributes, and selected individuals will be permitted to update attribute values. RM
tools generate several system-defined attributes, such as the date a requirement was
created and its current version number, and they let you define additional attributes of
various data types. Thoughtful definition of attributes allows stakeholders to select
subsets of the requirements based on specific combinations of attribute values. A
Release Number attribute is one way to keep track of the requirements allocated to
various releases.
Facilitate impact analysis RM tools enable requirements tracing by letting you define
links between different types of requirements, between requirements in different
subsystems, and between individual requirements and related system components (for
example, designs, code modules, tests, and user documentation). These links help you
analyze the impact that a proposed change to a specific requirement will have on other
system elements. It’s also a good idea to trace each functional requirement back to its
origin or parent so that you know where it came from. For instance, you might ask to
see a list of all the requirements originating from a specific business rule so that you
can judge the consequences of a change in that rule.
Identify missing and extraneous requirements The tracing functionality in RM tools
helps stakeholders identify requirements that are missing, such as user requirements
that have no mapped functional requirements. Similarly, they can reveal requirements
that cannot be traced back to a reasonable origin, raising the question of whether those
requirements are necessary. If a business requirement is cut from scope, then all the
requirements that trace from it can also be cut quickly.
Track requirements status Collecting requirements in a database lets you know how
many discrete requirements you’ve specified for the product. Tracking the status of
each requirement during development supports the overall status tracking of the
project.
Control access RM tools let you define access permissions for individuals or groups
of users and share information with a geographically dispersed team through a web
interface to the database. Some tools permit multiple users to update the database
contents concurrently.
Communicate with stakeholders An RM tool serves as a master repository so that all
stakeholders work from the same set of requirements. Some tools permit team members
to discuss requirements issues electronically through threaded conversations.
Automatically triggered email messages notify affected individuals when a new
discussion entry is made or when a specific requirement is modified. This is a
convenient method for visibly tracking decisions made about requirements. Making the
requirements accessible online can minimize document proliferation and version
confusion.
Reuse requirements Storing requirements in a database facilitates the reuse of them
in multiple projects or subprojects. Requirements that logically fit into multiple parts
of the product description can be stored once and referenced whenever necessary, to
avoid duplicating requirements. “Requirements reuse,” describes important concepts
regarding effectively reusing requirements.
Track issue status Some RM tools have functionality for tracking open issues and
linking each issue to its related requirements. As issues are resolved, it’s easy to
determine whether any requirements must be updated. You can also quickly find a
history of the issue and its resolution. Tracking issues in a tool enables automatic
reporting on the status of the issues.
Generate tailored subsets RM tools allow you to extract and view a set of
requirements that fits a particular purpose. For example, you might want a report that
contains all of the requirements for a specific development iteration, all of the
requirements that relate to a particular feature, or a set of requirements that needs to be
inspected.
RM tools let you define different requirement types, such as business requirements, use
cases, functional requirements, hardware requirements, and constraints. This lets you
differentiate all the types of information that are typically contained in an SRS. Many
tools allow you to configure an information architecture (which defines how
requirements types and other objects relate to one another) that is customized to your
practices. Most of the tools provide strong capabilities for defining attributes for each
requirement type, a great advantage over the typical document-based approach.
RM tools typically support hierarchical numeric requirement labels, in addition to
maintaining a unique internal identifier for each requirement. These identifiers often
consist of a short text prefix that indicates the requirement type—such as UR for a user
requirement—followed by a unique integer. Some tools provide displays to let you
manipulate the hierarchical requirements tree.
Requirements can be imported into an RM tool from various source document formats.
The textual description of a requirement is treated simply as a required attribute.
Several products let you incorporate non textual objects such as graphics and
spreadsheets into the requirements repository. Other products let you link individual
requirements to external files (such as Microsoft Word files, graphics files, and so on)
that provide supplementary information that augments the contents of the requirements
repository.
Output capabilities from the tools generally include the ability to generate a
requirements document in a variety of formats, including predefined or user-specified
documents, spreadsheets, and webpages. Some tools allow significant customization
for creating templates, allowing you to specify page layout, boilerplate text, attributes
to extract from the database, and the text styles to use. Specification documents are
then simply reports that are generated from the tool according to certain query criteria,
formatted to look like a typical SRS. For example, you could create an SRS that
contains all the functional requirements that are allocated to a specific release and
assigned to a particular developer. Some tools provide functionality that lets users make
changes in exported documents offline, which are then synchronized with the tool’s
database when the user is back online.
Most tools enable different views of the requirements to be generated within the tool
or exported from the tool. Features typically include the ability to set up user groups
and define permissions for selected users or groups to create, read, update, and delete
projects, requirements, attributes, and attribute values. Setting up appropriate views and
permissions facilitates the review of requirements and collaboration to improve those
requirements. Some tools also include learning aids, such as tutorials or sample
projects, to help users get up to speed.
Requirements management tools generally have robust tracing features. Tracing is
handled by defining links between two types of objects or objects of the same type.
Some requirements management tools include modeling capabilities that also allow the
models to be linked at an element level to individual requirements or to other model
elements.
Some agile project management tools also provide RM capabilities. These tools are
used to manage and prioritize backlogs, allocate requirements to iterations, and
generate test cases directly from requirements.
When you are selecting an RM product, determine whether the tool will be able to
exchange data with the other tools you use. Think about how you’ll take advantage of
these product integrations as you perform your requirements engineering, testing,
project tracking, and other processes. For example, consider how you would define
trace links between functional requirements and specific design or code elements, and
how you would verify that all tests linked back to specific functional requirements have
been successfully executed.

B. Selecting and Implementing a Requirement Tool

Any of these requirements tools can move your requirements practices to a higher plane
of sophistication and capability. However, success depends upon selecting the most
appropriate tool for your organization and getting your teams to adopt it as part of their
routine practices.
Selecting a tool
Select a tool based on the combination of desired features, platform, and pricing that
best fits your development environment and culture. Business analysts should lead the
selection efforts by defining the evaluation criteria and performing the actual
assessment. Some companies outsource tool evaluations to consultants who can assess
a company’s needs comprehensively and make recommendations from the available
tool candidates. “Packaged solution projects,” for choosing a COTS package also can
be applied to selecting a requirements tool. To summarize the selection process:
1. Identify your organization’s requirements for the tool to serve as evaluation criteria.
2. Prioritize and weight the criteria according to what capabilities or other factors
matter most to your organization.
3. Set up demos or acquire evaluation copies of the tools you want to consider.
4. Score each tool against the criteria in a consistent manner.
5. Calculate a total score for each tool by using your criteria scores and the weights
you assigned to them.
6. For each tool that scored well, use it on an actual project to see if it behaves as you
anticipated from the objective scores.
7. To make a final selection, combine the scores, licensing costs, and ongoing costs
with information on vendor support, input from current users, and your team’s
subjective impressions of the products. Two good final questions to ask people who
evaluate the tools are, “Which tool would you most want to use?” and, “Which tool
would you be most upset about being forced to use?”
Setting up the tool and processes:
Recognize that it will take effort to install a tool, load a project’s requirements into it,
define attributes and trace links, keep the contents current, define access groups and
their privileges, and adapt your processes to use the tool. Configuring the tool can be
complex; there is a steep learning curve just to set up a sophisticated requirements tool.
Management must allocate the resources needed for these operations. Make an
organization-wide commitment to actually use the product you select, instead of letting
it become expensive shelfware.
There’s little point in using a requirements tool if you don’t take advantage of its
capabilities. I encountered one project team that had diligently stored all its
requirements in an RM tool but hadn’t defined any requirement attributes or trace links.
Nor did they provide online access for all the stakeholders. The fact that the
requirements were stored in a different form didn’t provide significant benefits,
although it consumed the effort needed to get the requirements into the tool. Another
team stored hundreds of requirements in a high-end tool and defined many trace links.
Their only use of the information was to generate massive printed traceability reports
that were supposed to be reviewed manually for problems. No one actually examined
the reports, and no one regarded the database as the authoritative repository of the
project’s requirements. Neither of these organizations reaped the full benefits of their
considerable investments of time and money in the tools.
Even if you select the best available tool, it won’t necessarily provide every capability
that your organization wants or needs. It might not support your existing requirements
templates or processes. You’ll still likely need to adapt some of your existing processes
to incorporate the tool in them. Expect to have to make some changes to templates,
attribute names, and the sequencing of requirements development activities. Consider
the following suggestions to overcome process issues as you strive to maximize your
return on investment from a requirements tool:
• Assign an experienced BA to own the tool setup and process adaptations. She
will understand the impact of configuration choices and process changes.
• Think carefully about the various requirement types that you define. Don’t treat
every section of your current SRS template as a separate requirement type, but
don’t simply stuff all of the SRS contents into a single requirement type either.
• Use the tool to facilitate communication with project stakeholders in various
locations. Set the access and change privileges to permit sufficient input to the
requirements by various people without giving everyone complete freedom to
change everything in the database.
• Don’t try to capture requirements directly in an RM tool during your early
elicitation workshops. As the requirements begin to stabilize, though, storing
them in the tool makes them visible to the workshop participants for
refinement.
• Use RD tools during elicitation activities only if you are confident that they
will not slow down the discovery process and waste your stakeholders’ time.
• Don’t define trace links until the requirements stabilize. Otherwise, you can
count on doing a lot of work to revise the links as requirements continue to
evolve.
• To accelerate the movement from a document-based paradigm to the use of the
tool, set a date after which the tool’s database will be regarded as the definitive
repository of the project’s requirements. After that date, requirements residing
only in word-processing documents won’t be recognized as valid requirements.
Provided you remember that a tool can’t overcome process deficiencies, you’re
likely to find that requirements tools greatly enhance the control you have over
your software requirements.
Facilitating user adoption:

The diligence of the users of your requirements tools is a critical success factor.
Dedicated, disciplined, and knowledgeable people will make progress even
with mediocre tools, whereas the best tools won’t pay for themselves in the
hands of unmotivated or ill-trained users. Don’t write a check for a tool unless
you’re willing to respect the learning curve and make the time investment.

Buying a tool is easy; changing your culture and processes to accept the tool
and take best advantage of it is much harder. Most organizations already are
comfortable with taking elicitation notes in a word-processing document or by
hand, and with storing their requirements in documents. Changing to use
software-based tools requires a different way of thinking. Using RD tools
requires breaking old habits for running elicitation sessions. An RM tool makes
the requirements visible to any stakeholder who has access to the database.
Some stakeholders interpret this visibility as reducing the control they have
over the requirements, the requirements engineering process, or both. Some
people prefer not to share an incomplete or imperfect set of requirements with
the world, yet the database contents are there for all to see. Keeping the
requirements private until they’re “done” means you miss an opportunity to
have other pairs of eyes scan the requirements frequently for possible
problems.

People are often resistant to change things that they’re familiar with, and they
usually have a comfort level with working on requirements in documents. They
might have a perception—even if incorrect—that using a requirements tool
will be harder for them. Also, don’t forget that most of the tool users are already
busy. Time must be allocated to let them get used to using the tool in their daily
jobs. Eventually, the tool probably won’t actually require more time from
users, but they first need to get over the learning curve and develop new work
habits using the tool. Following are some suggestions to help you deal with
issues regarding user adoption and culture change:

• Identify a tool advocate, a local enthusiast who learns the tool’s ins and outs,
mentors other users, and sees that it gets employed as intended. This person
should be an experienced business analyst who can be the single owner for
ensuring tool adoption. This initial tool advocate will work with other users on
their projects to ingrain the tool into their daily activities. Then he’ll train and
mentor others to support the tool as other projects adopt it.
• One of the biggest adoption challenges to overcome is that users don’t believe
the tool will actually add any value. Perhaps they haven’t recognized the pain
from limitations of their existing manual approaches. Share stories with them
about where the lack of a tool caused a negative impact and ask them to think
of their own examples.
• Your team members are smart, but it’s better to train them than to expect them
to figure out how best to use the tool on their own. They can undoubtedly
deduce the basic operations, but they won’t learn about the full set of tool
capabilities and how to exploit them efficiently.
• Because you can’t expect instantaneous results, don’t base a project’s success
on a tool you’re using for the first time. Begin with a pilot application of the
tool on a noncritical project. This will help the organization learn how much
effort it takes to administer and support the tool.
The proliferation and increased usage of tools to assist with requirements
development and management represents a significant trend in software
engineering that will undoubtedly continue. Too many organizations, though, fail
to reap the benefits of their investment in such tools. They do not adequately
consider their organization’s culture and processes and the effort needed to shift
from a document-based requirements paradigm to a tool-based approach. The
guidance in this chapter will help you choose appropriate tools and use them
effectively. Just remember, a tool cannot replace solid requirements process or
team members with suitable skills and knowledge. A fool with a tool is an
amplified tools.
Chapter 8: Requirement Engineering Techniques
8.1 Methods for Requirement Engineering
A comprehensive perspective of the area of requirements engineering, selecting methods and
techniques in order to analyze and suggest a set of principles that will help to compose a
sensible framework that justifies the adoption of a specific technique, or set of techniques for
a specific project.
Requirements engineering is the process of defining, documenting, and maintaining
requirements in the engineering design process, it is a process of gathering and defining service
provided by the system.
To carry out the requirements engineering activity we have numerous elicitation techniques
and methodologies available, in this article, we will list some of the best-known techniques and
when to use them.
1. Interviews
By far this is the most common technique in use because an obvious way to find out what the
users of a software system need is to ask them, so interviews are of primary steps for
information gathering where the software engineer will have face-to-face interaction with
stakeholders. The business analyst will spend most of the time interviewing system users and
system owners during the early stages of the project life cycle.
There are types of interviews:
Individual Interviews: As the name says we have just one stakeholder answering the
questions.
Group Interviews: In this case, a group of stakeholders answers the questions, the good thing
is that the responses of different stakeholders influence each other.
Unstructured Interview
These involve a conversation by the interviewee asking general questions. It is usually an
inefficient technique as it has a tendency to go off track from the main goal and the analyst will
have to redirect the interview in the right path.
An unstructured interview is a type of interview that is non-directive in nature. Here, the
interviewer does not rely on a set of standardized questions but adopts spontaneity when
gathering relevant information from the respondent in line with the purpose of the interview.
The interviewer freely asks questions and allows the interviewee to lead the dialogue.
In some way, an unstructured interview is similar to an everyday conversation because of it is
informal and free-flowing nature. Unstructured interviews can be used in a variety of fields
especially sociology and it is also adopted for market research and recruitment processes.
Unstructured interviews adopt a feedback mechanism to direct the course of the conversation
in line with the research. The researcher develops new questions based on the responses
provided by the interviewee hence, he or she can gather more in-depth and reliable information
about the research subject.
Structured Interview
The interviewer will be the one making specific questions in order to obtain the required
information from the interviewee. This type of interview is considered to be efficient.
A structured interview is a type of interview in which the researcher asks a set of premeditated
questions in order to gather information about the research subjects. It is also known as a
standardized interview or a researcher-administered interview, and it aims at investigating
research variables using the same set of questions.
Typically, structured interviews are used to collect information with regards to the quantity or
numerical value of the research subjects. It outlines events, behaviors, procedures, and
guidelines for conducting the interview and recording the information collected to serve as the
research data.
There are three phases of the structured Interviews process:
Before the interview, you must determine the goal of an interview in order to gather high-level
business requirements, the second step is to identify participants, you need to think about which
stakeholder will be able to contribute to your goal, for example, the product owner, marketing
team, end-users, team members, etc. The third step is to make a list of questions to ask, it can
be open-ended or closed questions. Open-ended questions are questions that allow stakeholders
to give a free-form answer and closed questions can be answered with “Yes” or “No,” or they
have a limited set of possible answers. The last step is to book a place and time with the
stakeholders.
During the interview, you can introduce yourself to the stakeholders and clearly state what is
the purpose and agenda of this interview. After that you can share your questions with the
stakeholders, whenever a stakeholder answers a question, be an active listener, which means
keep you engaged with your conversation partner in a positive way, listen attentively while
someone else speaks, paraphrasing and reflecting back on what was said and take notes as
much as you can. To close the interview, you can briefly summarize what was said and present
in order to validate if the statements were understood correctly and what are the next steps of
the project.
After the interview, you must organize and analyze the answers in order to validate your notes.
After that, you can create models and scenarios, identify gaps, contradictions, or
inconsistencies and share them with the stakeholders asking them to check and confirm the
results.
Checklist for interviews:
Preparation Interview goal.
Interview participants
Interview location.
Interview questions.
Execution
Opening the interview.
Share the agenda.
Make the questions.
Finalization
System up the elicited knowledge.
Present the next steps of the project.
Follow-up
Document the elicited requirements.
Create models and scenarios.
List open issues in a to-do list.
Ask stakeholders to confirm the results.
Positives and negatives of the interview technique:
Positive:
Interviews are easier to schedule and lead than large-group activities such as requirements
workshops.
Interviews are appropriate for eliciting business requirements from executives who do not have
a lot of time to meet.
Negative:
When we have many stakeholders together, it can be difficult to keep the discussion focused
on the objective, so there is a chance the interview will go off-topic.
Stakeholders might get excited and suggest new features that will never be used.
Limited amount of time that stakeholders may be available for interviews.
2. Questionnaires or Surveys
Questionnaires it is a technique in which a document is used to collect information and opinion
from stakeholders.
You can use questionnaires to get information from many people. You can use them in two
ways: to get statistical evidence for an assumption, or to gather opinions and suggestions.
Questionnaires are a way to survey large groups of users to understand their needs. They are
inexpensive, making them a logical choice for eliciting information from large user
populations, and they can be administered easily across geographical boundaries.
The analyzed results of questionnaires can be used as an input to other elicitation techniques.
For example, you might use a questionnaire to identify users’ biggest pain points with an
existing system, then use the results to discuss prioritization with decision-makers in a
workshop. You can also use questionnaires to survey commercial product users for feedback.
Tip: Before sending a questionnaire form to many people, always test the form on a few people
from the target group.
Some examples of survey questions include:
Likert scales allow respondents to make a linear choice, for example, “strongly agree, agree,
neutral, disagree, strongly disagree”. It’ll help you understand attitudes but can give skewed
positive answers
Rating and rankings let your respondents choose an answer on a scale of 0–5 or 0–10 which
are easy to understand and analyze it.
Checkboxes and drop boxes offer a setlist of predetermined answers, giving you control of
the data for more open questions, yet limits the creativity of the responses you could get.
Text boxes give your respondents full control over what they tell you, giving you accurate
answers but these can be time-consuming to analyze and categorize.
Positives and negatives of the questionnaire technique:
Positive:
Is cost-effective and removes constraints such as a geographically dispersed stakeholder base
or time issues.
You can use the results to see how important the problem really is.
Negative:
Open-ended questions allow users to respond any way they want, so it’s hard to look for
commonalities in the results.
There is also a high risk of misunderstanding with closed questions.
Surveys have restricted inputs and this can stifle creativity.
3. Brainstorm
Brainstorming refers to the practice of generating ideas and putting them down in concrete
form. The idea of a brainstorm is that everyone in the meeting should have the same power to
speak and that all ideas are valid.
In a brainstorming session, you gather together a group of people, create a stimulating and
focused atmosphere, and let people come up with ideas without risk of being ridiculed, which
means the main rule of the game is not to criticize any idea.
Before the meeting, it is very important that you send the participants what the subject of the
meeting will be so that each participant can think about it and come up with good ideas for the
meeting.
To brainstorm effectively:
Prepare the group
Identify purpose and desire outcome.
Explain what brainstorming is if other people don’t know.
Select a facilitator to guide the process.
Invite the right person.
Present the problem
Make sure that everyone is in the right mind frame for brainstorming.
Explain the problem/goal that you hope to correct.
Prioritize the problem
Draw the prioritization matrix on a whiteboard or flipchart.
Finishing the brainstorm
Once the brainstorming session is over, begin the refining process based on the pre-
established criteria.
Condense groups of similar ideas into one thought.
Create a list of what results, and distribute it to everyone for review.
Basics ruler for brainstorming:
Generate as many ideas as possible before considering any of them.
Never criticize another participant’s ideas.
Avoid censoring seemingly “crazy” ideas.
Evolve existing ideas to expand on them.
Positives and negatives of the brainstorming technique:
Positive:
An idea presented can be questioned and become an even better idea.
Getting lots of ideas from different perspectives.
Easy to understand, it is not a complicated technique.
Encourages creative thinking and thinking “out of the box”.
Negative:
Encourages creative thinking and thinking “out of the box”.
People can be uncomfortable voicing creative ideas in a group setting.
It’s easy to lose focus on the purpose of the meeting.
4. User Observation
Users are not always aware of what they really do and how they do it. When you ask users to
describe how they do their jobs, they will likely have a hard time being precise details that
might be missing or incorrect and they may come up with logical, but wrong explanations.
Often this is because tasks are complex and it’s hard to remember every minute detail. In other
cases, it is because users are so familiar with executing a task that they can’t articulate
everything they do. Perhaps the task is so habitual that they don’t even think about it.
Sometimes you can learn a lot by observing exactly how users perform their tasks.
Observation vastly improves your knowledge of the current work and some of the associated
work problems
User observation can be either passive or active.
Active observation: asking questions of users while observing them, is the best approach for
gaining an understanding of an existing process.
Passive observation is more effective when gathering user feedback on a design prototype.
Silent observations are appropriate when busy users cannot be interrupted.
Some things to keep in mind when conducting user observation:
Construct a visual of the end-to-end process a person follows to do their job daily.
Be mindful when asking questions to not disrupt seeing a natural work environment.
Observe, take notes, remain unbiased and keep from making judgments.
Gather any documentation that helps you find out procedures, like a user training manual.
Observe well enough to understand fully what a platform, software, or device is capable of.
3 Phases of observation process:
Before the observation: You need to determine the purpose of the session, the main idea is to
conduct the observation session to understand the current process. In the second step, you need
to identify the participants and this phase is very important because normally a process can
have other sub-processes involved and all stakeholders must be covered, so once you had
identified the participants, you need to have a word with the stakeholders and set up some time
for these observation sessions.
So we have the third step which is creating a schedule, you can space out the sessions or you
can have a couple of sessions on the same day, it all depends on the stakeholder availability.
This is is basically a preparatory phase for the observation technique, you know what is the
purpose, the participants are identified and they are engaged and you have a schedule with all
the meetings.
During the observation:
You would give your introduction, where you are from, what you are doing, and also briefly
explain to them the purpose and agenda of the session, after that, the stakeholder starts to
demonstrate how he performs his tasks and you would be sitting there next to him asking
questions and making notes. The main idea is to get a clear picture in your mind of why and
how the stakeholder is doing it.
After the observation: You must clearly state all your notes, data, process flow, tools,
stakeholder responses and send them for validation.
Positives and negatives of the user observation technique:
Positive:
By observing end-users in the real context in which they perform their tasks.
Negative:
Observations are time-consuming.
5. Document Analysis.
Normally every project starts as a blank piece of paper. Finding a starting point can be a
challenge when initiating a project. To get things moving, you can begin project requirement
gathering with document analysis.
First, you need to ask your stakeholders to provide the necessary documents. There will be
source material galore in most companies. Some of the things you can request include:
Benchmarking studies: Contain information on industry best practices and the actions that
other organizations have taken to achieve success.
Business plans: Contains details of current business processes, process participants, handoffs,
and other process-related information that can help the analyst understand how processes work.
Business Architecture diagrams: These will often show who does what, where and which
business services are in-source/out-sourced. They can give you a macro-level view of your
domain.
User manuals: If you’re working with an existing system, user guides and help screens can
help you to understand the “as is” screen-flows. They might even hint at underlying process
logic and business rules.
System specifications: Sometimes, you might strike gold and find that a previous BA has
produced a full set of requirements for the system or process that you’re aiming to change. If
so, this will be an excellent reference point, but remember that not all requirements get
implemented, so it’s worth checking whether anything was de-scoped.
Once you’ve got the documents, they need to be processed methodically.
Positives and negatives of the document analysis technique:
Positive:
Can come in useful where the stakeholder is unavailable or no longer with the organization.
Ensures that the analyst does not start from a blank page.
Acts as a means of cross-checking requirements with other sources.
When the current stakeholders cannot offer you much information, document analysis will
offer valuable insight.
Negative:
Document Analysis is limited to the as-is situation.
A risk with this technique is that the available documents might not be up to date.
It can be time-consuming to find and sift through masses of information.

8.2 Viewpoint-oriented Requirements Methods

This chapter describes the use of viewpoints for requirements engineering. This chapter
should be read if you have problems with requirements elicitation due to a failure to identify
all the major system stakeholders. Viewpoints are designed to reduce the risk of overlooking
stakeholders and their requirements. They can help to manage and analyze the requirements
once they have been elicited. We discuss the basic principles underpinning viewpoints and
how they can be used informally. We also describe a systematic approach, called PREview,
to the use of viewpoints and illustrate this with an example of a safety-related system.

In this chapter we suggest that viewpoint identification should be one of the first steps of a
requirements analysis because it helps the elicitation and management of requirements.
Collect requirements from multiple viewpoints, introduced viewpoints as an intermediate
level technique. In this chapter, we review the benefits which can be gained by using
viewpoints, and suggest how viewpoints can be used by introducing the PREview* approach.
The term 'viewpoint' is broadly synonymous with a perspective on a system (Figure 13.1). As
a simple example, consider a proposal to commission and install traffic lights at the
intersection of two roads. There is a wide range of configurations which such a traffic light
system may have and a corresponding set of requirements which an analyst must collect and
make sense of. For example, should the system have left/right turn filters? Should pedestrian
crossings be provided? Should the period between changes of the lights be dynamically
configurable? The answers to these questions depend on the domain problems which the
system seeks to solve. However, there are several people or roles who, because they will use,
operate, or pay for the system, have a stake in it. Each of these has a perspective on the system
and analysts cannot be confident about developing an adequate specification unless they have
collected and analysed all their requirements. Those which might be identified here include:
1. drivers
2. cyclists
3. pedestrians
4. emergency services
5. the highway authority Each of these viewpoints represents the perspective of a particular
stakeholder on the traffic management problem each stakeholder imposes requirements on the
solution to the problem. As explained below, there are often other useful viewpoints on a
system which represent requirements with no human or organisational source.
Viewpoints focus primarily on the early elicitafion stages of the requirements process.
Systematic support has always been harder to provide here than for system modelling or
specification. Hence, practitioners looking for a method capable of solving their elicitation
problems, in the way that (for example) SADT solves their modelling problems, will be
disappointed. However, using viewpoints can help structure the elicitation process.
Viewpoints can also help prioritise and manage requirements.
Another way of thinking of viewpoints is that they:

• focus the analyst's attention on the parts of the problem which affect stakeholders, and
• project the discovered requirements onto the system to be developed. This is illustrated
Here two viewpoints focus on the hazy and ill-formed proposed system and project their
requirements discovered by these foci onto an emerging system specification. Elicitation
of the two viewpoints' requirements take place without regard to each other in order to
explicitly separate elicitation from distracting issues such as conflict resolution. Overlaps
between the viewpoints' foci indicate that the viewpoints' domains of interest are not
disjoint. This may result in duplicated requirements. There may also be incompatible
requirements. The fact that the requirements are explicitly associated with an identified
viewpoint helps to inform the resolution of inconsistencies and duplications.
If you are working in a familiar domain where systems are highly constrained (e.g. the
architecture of the systems is fixed) then viewpoints probably do not offer significant
advantages. Similarly, if you are involved with developing systems where there are few
or homogeneous sources of requirements, viewpoints may offer little advantage. If,
however, you frequently perform requirements rework, experience incompleteness-
derived quality problems, or have problems with managing requirements from different
sources, then viewpoints may offer significant advantages.
If incompleteness in your elicitation process is your principal problem, then it may be
most cost-effective to apply viewpoints informally. Viewpoint identification based on a
checklist of viewpoints 'classes' (i.e. viewpoints likely to occur in the domain) can be
used to guide the search for viewpoints. Elicitation of each viewpoint's requirements then
contributes to system modelling and specification with no intermediate inconsistency
handling step. Instead, inconsistencies are identified and rectified in an ad hoc manner as
they emerge during system modelling and specification. The viewpoints and associated
information are discarded.
This approach is broadly compatible with the use of viewpoints as informally practised
in many development projects. However, many users experience difficulty viewpoints
like this. Without a good definition of viewpoint, viewpoint identification is hard. There
are also problems in integrating viewpoints' requirements and handling inconsistency in
large projects. In any project where there are more than a handful of viewpoints, these
problems may nullify the advantages of viewpoints. In this case, a systematic approach
to the use of viewpoints may be helpful.
Although the viewpoints concept has been around for many years, there are very few
methods which are viewpoint-oriented and which are in widespread industrial use (and
therefore properly validated). Although a few structured methods such as SADT support
the general notion of viewpoints, perhaps only CORE* can be truly described as an
industrial viewpoints-oriented method. We therefore prefer to refer to viewpoints
'approaches' rather than 'methods'. Later in this chapter, we suggest an approach to the
use of viewpoints called PREview. This provides guidelines on the fundamentals of using
viewpoints such as how to identify and manage viewpoints

Why Viewpoints?
A viewpoint-based approach to requirements analysis recognizes that all information about
the system requirements cannot be discovered by considering the system from a single
perspective. Any single perspective inevitably emphasizes the requirements of one
stakeholder at the expense of other viewpoints. Developing a solution to a traffic management
problem based only on drivers' requirements would be unsatisfactory for pedestrians and
cyclists. Similarly, analysis of the problem from a single synthetic perspective which
attempted to represent every stakeholder would be very difficult. The principal advantages
offered by viewpoints are as follows.
• The requirements are likely to be more complete than if viewpoints are not explicitly
identified. In the latter case, important requirements may be easily overlooked because their
viewpoints were never recognized.
• A separation of concerns is provided which permits the development of a set of 'partial
specifications' in isolation from other viewpoints. This avoids having to confront conflicts
with other viewpoints' requirements during elicitation. A result of this is that, when they prove
necessary, the trade-offs between requirements can be better informed.
• Traceability is enhanced by the explicit association of requirements with the viewpoints
from which they are derived. Viewpoints are complementary to a number of other
requirements engineering practices. In particular, they can help inform the development of
system models. Similarly, system models can be developed for each viewpoint to help clarify
their requirements.
What is a Viewpoint?
A viewpoint represents an encapsulation of partial information about a system's requirements
from a particular perspective. The information is partial because it is restricted to one
perspective on the system and therefore omits other perspectives' requirements. A viewpoint
should not only contain requirements. It is good practice to associate additional information
with requirements to help with assessing requirements' mutability and with tracing. A
viewpoint provides a convenient structuring mechanism with which to associate requirements
with this other information. Hence, a viewpoint may contain a set of requirements as well as
a definition of the viewpoint's perspective, a list of the sources from which the requirements
were elicited and a rationale for each requirement.
Viewpoints are not only concerned with human perspectives. Viewpoints can be associated
with:
• the system's stakeholders
• the system's operating environment
• the system's domain

A stakeholder is a human, role, or organization with an interest in the system. This can include
both the customer's and developer's organizations. For the traffic light problem, the customer's
viewpoints might be those identified at the start of this chapter. For an MIS application by
contrast, the customer's viewpoints might be those of users such as sales staff and systems
administrators as well as those with a more strategic interest in the system such as finance and
logistics managers. Developers' viewpoints may include those of the analyst(s) and other
disciplines involved in the system development.
Stakeholders are not the only sources of requirements. A system is always installed in an
environment. Where the environment includes other systems/components with which it must
exchange data or control, these impose requirements. An interfaced system/component has a
perspective on the system just as a stakeholder does. Hence it makes sense to use a viewpoint
to model that perspective.
In addition, many applications are constrained by phenomena inherent in their domain. Signal
propagation errors occur in communications media; government information systems are the
target of unauthorized users; and traffic lights are constrained by vehicle braking and
acceleration capabilities. The latter might be represented by a 'safety' viewpoint because this
may be useful as a means to isolate and explicitly represent the safety requirements on the
system. Similarly, we might have signal processing and security viewpoints in other domains.
The domain imposes requirements just as stakeholders and the environment do. These tend to
act as constraints on the system.
In some applications the domain-imposed requirements are trivially obvious. In others, they
are implicit in the principal stakeholders' requirements. Unfortunately, in some applications
neither of these are true and the domain requirements are obscure and hard to elicit. They may
have no stakeholder to articulate them, they may366 Viewpoints remain implicit features of
the domain culture; evident to experts but obscure to others. Their discovery depends on the
availability of domain expertise. If the analyst is not a domain expert, they must be sensitized
to the need to explicitly seek expertise. Explicitly identifying a domain viewpoint can help
raise the profile of the domain requirements.
PREview: A pragmatic Viewpoints Approach
In this section we introduce the use of the PREview viewpoint-oriented approach. PREview
helps to avoid the problems of identifying and managing viewpoints. It has been developed
from experience of large systems engineering projects and is rooted in pragmatic issues such
as the need for flexibility. In particular, PREview seeks to support the management and
analysis of viewpoints without introducing specialist notations. Checklists and tables are used
where some other viewpoints approaches use more formal notations. Although these
approaches hold long-term promise we think that they are currently impractical for industrial
applications.
To be usable, a viewpoint-oriented approach should integrate with an existing requirements
process. This reduces both the costs and risks of applying the approach. Although there is no
universal requirements process, most processes broadly conform to the spiral model.
The key point about the spiral model is in that requirements engineering is iterative rather
than linear. Requirements information emerges spasmodically and is poorly formed. To make
sense of this, three basic activities have to be repeatedly applied until order emerges. These
activities are represented by the three segments of the spiral. The radial arms of the spiral
represent both increasing cost and the generation of information by all three phases. The more
times we go round the spiral, the better the quality of our requirements information should be.
However, we consume more resources in doing so.
The discovery/analysis/negotiation cycle is iterated a number of times. During each iteration,
new information emerges which may necessitate the modification of already acquired
information. Eventually, the requirements information meets an acceptable level of
completeness and consistency. The requirements definition information emerges from each
cycle and forms the basis of a requirements document.
In more detail, the three basic activities performed each cycle are as follows.
1. Requirements elicitation. Given a statement of organizational needs and
other inputs, various different sources are consulted to understand the problem
and the application domain and to establish their requirements. These
requirements may not be complete and may be expressed in a vague and
unstructured way.
2. Requirements analysis. The requirements collected during the elicitation
phase are integrated and analyzed. Usually, this will result in the identification
of missing requirements, inconsistencies and requirements conflicts.
3. Requirements negotiation. Inconsistencies and conflicts discovered during
analysis need to be resolved. The analysts and stakeholders consider the
problematic requirements to try to reach a consensus about their resolution.
This typically requires negotiations to establish the necessary trade-offs. These
trade-offs may necessitate the elicitation of further requirement information.
The viewpoint-oriented approach which we suggest (PREview) is compatible with
this general model.
The shaded boxes correspond to each of the segments of the spiral model except
the box labelled requirements definition. This corresponds to the axes in the spiral
model. In PREview, the main activities are as follows:
• Requirements elicitation involves identification of the system's viewpoints and
elicitation of the requirements information from the stakeholders/documents/etc.
These are the 'sources' of the viewpoints' requirements. Before viewpoint
identification, however, the system concerns are identified and elaborated.
Concerns are discussed below.
• Requirements analysis involves analyzing the viewpoints to discover
inconsistent and redundant requirements. The task here is limited to their
identification by analyzing how different viewpoints' requirements interact. For
this activity, viewpoints' foci can be used as a guide. Requirements belonging to
viewpoints with overlapping foci are more likely to have potential for
inconsistencies. Requirements belonging to disjoint viewpoints, by contrast, are
less likely to conflict. Resolution of the conflicting requirements is performed by
the next activity.
• In requirements negotiation, the conflicting and redundant requirements are
resolved. The resolution of inconsistencies normally involves assessment of
competing requirements' relative importance, feasibility, cost, etc., in order to
inform the necessary trade-offs. These trade-offs may be localized to the
requirements concerned. However, they may have side-effects which necessitate
the reformulation of other requirements or stimulate the elicitation of new
requirements. This implies a further iteration of the discovery-analysis-negotiation
cycle.
This cycle is usually iterated a number of times until the set of viewpoints and
their requirements is stable and redundancy has been reduced. Once this state of
equilibrium is reached, the requirements can be integrated into a cohesive
requirements document.
It is useful to distinguish two types of requirements: those which are specific to
particular viewpoints and those which are global to the whole system. We use the
term 'external requirements' for global requirements to distinguish them from
requirements discovered from particular viewpoints. External requirements derive
from 'concerns'. Concerns are the top-level, overriding goals of the system and are
usually derived from the customer's critical business objectives. Typical examples
include reliability, safety, cost and maintainability. Concerns are characterized by
being crucial to the success of the project and by being non-negotiable. Concerns
exist for most systems but are often subverted by the sheer difficulty of handling
large volumes of volatile and non-complementary requirements. This can result in
systems which fail to meet the most basic needs. It is therefore useful to carefully
distinguish between concerns and other requirements.
Concerns are frequently vaguely defined and express concepts rather than detailed
system properties. To be satisfied, they must be converted into specific, verifiable
requirements. They can then serve as constraints on the other system requirements.
To achieve this, concerns are converted into external requirements which must be
explicitly satisfied. In addition, they are converted into 'concern questions'. These
provide a quick and easy check on requirements' compliance with concerns.
PREview therefore provides two levels of protection from requirements which
have the potential to compromise concerns.
• Concern questions are applied when requirements are first discovered in order to
quickly eliminate grossly incompatible requirements.
• External requirements are checked more systematically during analysis of each
viewpoint's requirements in order to identify more subtle conflicts.
To illustrate the PREview viewpoints approach we use an example taken from the
railway domain; the specification of an on-board train protection system called
TCS (Train Control System). In this application, the train is controlled by a human
driver. TCS is a safety-related system whose job is one of monitoring the train and
intervening if an unsafe state is detected. This is done by ensuring that the driver
respects the operational rules in force on the track and takes corrective action when
the driver breaks these rules. Operational rules include speed limits and protocols
for passing signals. Some rules are constant while others may vary according to
track conditions. Data is collected in real-time from track-side equipment to
monitor speed restrictions and to detect signals. Essentially, if the driver allows
the train to go too fast or to illegally cross a 'stopping point' (such as a signal at
stop),
TCS will cause the emergency brakes to be applied. TCS must be integrated with
an existing execution environment and other on-board systems. A module called
Hardware Systems Interface (HSI) exists, through which the TCS software
communicates with all the hardware interfaces. This provides:
• an interface of functions permitting (for example) emergency braking to be
invoked, and
• data permitting TCS to poll for train speed, distance to next stopping point, etc.
Requirement Elicitation in PREview
Before viewpoint identification can begin, an understanding of the system's technical and
organizational environment must be gained. The analyst needs to understand the
organizational environment. This will allow him or her to identify the correct mix of technical
and managerial personnel in the customer's organization to discover their (and, by implication,
their organization’s) concerns.
Concern identification
Concerns are identified at the outset of a project. In the TCS application, the customer's
concerns are: 'Safety' and 'Compatibility'. 'Safety' is a concern because although TCS does not
control the train it does contribute to train safety. 'Compatibility' is a concern because TCS
must be integrated with the existing systems' execution cycle and because the HSI module
provides the interface to all other modules.
Concern elaboration
Once identified, concerns must be elaborated into external requirements and concern
questions. Concern questions act as the conscience of the analyst who should apply them as a
test for compliance when a viewpoint's requirements are first discovered. They therefore serve
as a first defense against non-compliant requirements. The following concern question can be
derived for 'Compatibility':
Q1 Is the requirement consistent with the interface provided by the HSI module?
Consider the case where a stakeholder sets out a requirement to calculate a minimum braking
distance to a degree of accuracy which requires as parameters the train speed, mass, line
gradient and track surface conditions. Applying the concern question to this requirement
would prompt checking that these parameter values were indeed available through the HSI
interface. In the TCS, track surface conditions are not monitored via the HSI module so the
requirement would be shown to be infeasible.
Of course, sufficient information will not always be available to demonstrate compatibility at
the elicitation stage and incompatible requirements will inevitably escape detection. For this
reason, every concern is developed into one or more requirements. These are the external
requirements with which every viewpoint's requirement must be compliant. Tests for
compliance are performed within the requirements analysis phase.
For example, the external requirements derived for the 'Compatibility' concern are as follows.
ER4: The TCS software shall be executed in the Ada safety environment of the coded
processor.
ER5: The TCS software shall execute within the application cycle of the existing on-board
software.
ER6: The reaction time of the TCS software to the change of state of one bit in the variants
table shall be 280ms.
ER7: The real-time performance of the existing on-board software shall be maintained.
Concern elaboration must be performed carefully. By investing resources at this very early
stage, the elaborated concerns will serve to guard against incompatibilities which may be
introduced later. Some classes of concern may employ other techniques to assist with their
elaboration. For example, a safety concern may exploit hazard analysis techniques to identify
the specific hazards against which the system must provide a defense. Here, a specific external
requirement and concern question might be developed for each hazard.
For example, in the 'Safety' concern, the specific hazards against which TCS must protect are
excess speed and overshooting a stopping point. These can be elaborated into the following
three external requirements:
ER1: The system shall detect the occurrence of excess speed
ER2: The system shall detect the occurrence of overshoot
ER3: The system shall apply emergency braking when either excess speed or overshoot are
detected.
Note the wide variance in the level of detail expressed by these external requirements. They
range from low-level implementation constraints (280 ms) to abstract concepts (overshoot).
This illustrates the naivety of the view of requirements engineering as dealing only with the
'what', with all 'how' decisions being conveniently deferred. In reality, and especially for
systems installed in an existing technical environment, it is not such a clean process. It also
illustrates that in analysing requirements for inconsistencies, the analyst must be prepared to
handle requirements at many different levels.
Viewpoint identification
Viewpoint identification is difficult but crucial to the effective use of a viewpoint-oriented
approach. Failure to identify an appropriate set of viewpoints implies that some, possibly
important, perspectives on the system are omitted, leading in turn to an incomplete and
unrepresentative requirements specification. The analyst must find a balance between
ensuring that all the viewpoints are represented and deriving an unmanageably large set of
viewpoints. Too many viewpoints will hinder integration of their requirements and lead to
excessive duplication. To help this balancing act, viewpoint identification must be supported
by guidelines. However, much viewpoint information can be reused between projects in the
same domain, so their application becomes easier as experience is gained.
To identify viewpoints, the analyst must develop a good understanding of the system's
operational and organizational environments. The operational environment will reveal the
users and other systems/components with which the system will interact. It also embodies any
inherent domain phenomena. The organizational environment will reveal the indirect
stakeholders such as managers and regulators.
In order make them manageable, viewpoints have a structure. They consist of the follows:
• The viewpoint name. This should reflect the perspective adopted by the viewpoint.
• The viewpoint focus. This defines the perspective taken by the viewpoint.
• The concerns applicable to the viewpoint.
By default, this is the set of all system concerns. Concerns may be eliminated from the
viewpoint if it can be demonstrated that they have no constraining effect on the viewpoint.
• The viewpoint sources. These explicitly identify the sources of the requirements associated
with the requirement. They may be individuals, roles, groups or documents.
• The viewpoint requirements. This is the set of requirements discovered by analyzing the
system from the viewpoint's perspective and by consultation with the sources.
• The viewpoint history. This records changes to the information recorded in the viewpoint
over time. For example, a rationale for why a particular concern need not be considered by
the viewpoint should appear here.
The name, focus and sources must be formulated before the requirements can be elicited. All
three of these properties contribute to the viewpoint's identification. Focus defines the scope
of the viewpoint's requirements as a function of the problem domain and the components
influenced in the system. In a typical application, focus will initially be defined in terms of
the application domain but as analysis proceeds and a system architecture emerges, focus will
become more specific.
Sources may be human or documentary. Examples include system users for a user viewpoint,
existing specification documentation for an interfaced system/component viewpoint, and
domain experts for a domain viewpoint.
Several sources may contribute requirements to a viewpoint. Similarly, a single stakeholder
may contribute requirements to more than one viewpoint. For example, a manager may have
one perspective as a user and another concerned with the system's effect on the company's
business. In these cases, it is common for the stakeholders requirements to be contradictory
across different viewpoints. To cope with this you must be able to recognize when a
stakeholder has different viewpoints. You can then use this to help the stakeholders set out
their requirements by inviting them to adopt different viewpoints.
In some applications, the viewpoints are obvious but in others, the viewpoints will need to be
actively sought. In this case, it may be helpful to decompose from the three categories of
viewpoint identified above, namely: 'stakeholder' viewpoints, 'operating environment'
viewpoints and 'domain' viewpoints.
Driver: The driver is a stakeholder whose requirements should be identified. This is implicit
from both the operational and organisational environment.
HSI: The HSI viewpoint represents a subsystem/component from TCS's environment. This is
implicit from the operational environment.
These correspond to identifiable perspectives on the system and cohesive sets of requirement
sources. For example, drivers are a homogeneous group whereas HSI's requirements can be
derived from its existing specification documentation. The non-leaf nodes represent more
general viewpoint classifications. They represent stages in the process of identifying the
appropriate viewpoints.
For example, stakeholders can be characterized as either direct (i.e. users or operators) or
indirect (i.e. they will not interact directly with the system). In the railway domain, indirect
stakeholders can be further classified according to whether they represent the customer who
commissions the train or third parties. In TCS, the latter are represented by a regulator
responsible for assuring safety, compliance with standards, etc. 'Regulator' is a leaf because
there is only one regulator. 'Customer', however, can be decomposed to greater depth. The
customer will have to maintain the train systems and operate the train. There are three
additional viewpoints related to train operation. The 'Normal operation' viewpoint is that of
operating the train in the absence of driver errors which necessitate the emergency
intervention of the TCS software. The 'Safe state assurance' viewpoint is where the
circumstances under which the TCS software intervenes are defined. Finally, the 'Erroneous
state recovery' viewpoint is that of how the train can return to normal operation following
emergency intervention of the TCS software.
A viewpoint hierarchy may be reusable by similar systems to guide the search for viewpoints.
Note, however, that decomposition of viewpoints is primarily a tool to aid identification of
viewpoints and their sources. This must be balanced against the need to minimise the number
of viewpoints. Following the elicitation of their requirements, it may be useful to collapse
viewpoints with common roots back into a single viewpoint. This will make management of
the viewpoints easier later on. The leaves of the hierarchy form the starting point for
requirements elicitation, because they should correspond closely to actual stakeholders, etc.,
in the system. However, the set of viewpoints actually used in subsequent analysis may be a
smaller number of more general viewpoints.
Below, we give two examples of viewpoints on TCS. 'Safe state assurance' is illustrated in
Figure 13.6 and represents requirements for maintaining the train in a safe state. The definition
of its focus serves to describe the extent of the requirements' influence on the system. At a
later stage of the analysis this could be augmented with a list of the components to which the
requirements had been allocated.
Both concerns are considered to constrain the viewpoint:
• 'Safety' is used because incorrect requirements may compromise safety
• 'Compatibility' is used because performance and interface issues are affected by the
viewpoint's requirements. When the viewpoint's requirements are elicited from the sources,
they must all be checked to ensure that they satisfy each of the concern questions elaborated
from the 'Safety' and 'Compatibility' concerns. In addition, at the requirements analysis stage
they must be analyzed to verify that they do not conflict with any of the concerns' external
requirements.
We have added the three requirements elicited from the viewpoint's sources, although these
would normally be elicited only after the viewpoint's identification. These are described
below.
Sometimes it can be demonstrated that a viewpoint cannot affect a concern. In this case, the
concern can be omitted from the concern field and the viewpoint requirements need not be
checked against the concern questions or external requirements. However, you should record
the justification for ignoring the concern in the change history.
Requirements discovery
Once a viewpoint has been identified, the requirements arising from that viewpoint can be
discovered from the viewpoint's source(s). For each requirement, the concern questions
should be asked to discover if it is likely to conflict with the concern.
The following concern question must be applied to each requirement.
Q1: Is the requirement consistent with the interface provided by the HSI module?
This raises the question of whether the requirements are feasible within the limits imposed by
the interface provided by the HSI module and the train's on-board execution environment. In
the case of SS2, for example, the analyst must ensure that information about the train's
relationship to stopping points is available from the HSI interface, and that emergency braking
can be invoked through the HSI interface.
In principle, all of a viewpoint's requirements should be mutually consistent but this is not
always the case. Some contradictions are natural. For example, a 'user' viewpoint may
represent many users, each with the same task to perform but each with different preferences.
In this case, it is best to try to resolve the inconsistencies without reference to other
viewpoints. Developing a system model for the viewpoint may help to clarify how to reconcile
competing requirements.
In other cases, the viewpoint will less homogeneous. For example, another viewpoint may
include operators and managers. In this case, the conflicts will be more fundamental due to
their different tasks and interests in the system. Occasionally it may be impossible to resolve
these inconsistencies without reference to the wider system. In such cases the viewpoint
should be decomposed into two new viewpoints, each reflecting the divergent requirements.
This does not mean that the contradictions are never resolved. Rather, resolution is deferred
until the requirements negotiation stage when the viewpoints' requirements can be looked at
in the context of the wider system rather than in isolation. It will then be easier to assess the
competing requirements' wider implications. This will help identify the most appropriate
trade-offs.
It is important that the viewpoints which emerge from requirements elicitation are internally
consistent. Only then can they be analyzed for consistency with other viewpoints at the
requirements analysis stage. However, this must be tempered by the need to minimize the
number of viewpoints.
Eventually, the viewpoints' sets of requirements will be complete. The next task is to integrate
them.
Requirements analysis in PREview:
The first task in integrating the viewpoints' requirements is to ensure that they each conform
to the external requirements derived from the concerns applicable to their viewpoint. Hence,
all of 'Safe state assurance' requirements need to be checked for consistency with the external
requirements for 'Safety' and 'Compatibility'. Interaction matrices are used to support this
checking.
The viewpoint's requirements are tabulated against the external requirements as shown in
Figure 13.9. Where they intersect, an assessment of whether they are mutually reinforcing (1),
do not effect each other (0), or conflict (1000) is performed and entered in the table. A 0
means that no action need be taken. A 1 means that the requirement may be redundant and
consideration should be given to eliminating or simplifying it. A 1000 means that the
requirement needs to be changed to make it consistent with the external requirement.
Note that for the 'Safe state assurance' viewpoint, SS1 reinforces external requirements ER1
and ER3. These are all concerned with detection and correction of excess speed. A similar
situation exists for SS2. SS3, however, has a potential conflict with ER5, 6 and 7.
The potential conflict arises because of the need to integrate TCS into the existing on-board
execution cycle and the consequent need to meet performance constraints. This raises the
question of whether requirement SS3 is feasible under these constraints.
The result of the analysis is that all 3 of the 'Safe state assurance' viewpoint's requirements go
forward to the requirements negotiation stage: SS1 and SS2 to see if they are redundant and
could be simplified; and SS3 to investigate whether it needs to be modified or if a further
constraint needs to added. Hence we have detected potential conflicts with the compatibility
concern and raised the need for further analysis.
Interaction matrices are also used to focus the analysis on inconsistencies between different
viewpoints' requirements. Analysing and checking each requirement against every other
requirement quickly becomes infeasible as the number of requirements increases. To counter
this, viewpoints' foci can be used as a guide to whether two viewpoints' requirements are
likely to interact. If their foci intersect (i.e. impose requirements which influence the same
parts of the system or its environment), then they should be tabulated and checked for
consistency. For example, the foci of the two viewpoints 'Safe state assurance' and 'Erroneous
state recovery' imply that there may be s o m e overlap.
Requirements negotiation
PREview does not define how the inconsistencies and redundancies identified by the
requirements analysis phase are resolved. How this is done must be left to the judgement of
the analyst and the various requirements' sources. However, the lists of inconsistent and
potentially redundant requirements provide an agenda for any requirements negotiations
between the analyst and conflicting stakeholders.
Note that the existence of redundant requirements is useful information. A requirement
originating from several viewpoints may be taken to suggest that the requirement is of
relatively high priority. By contrast, a requirement originating from only one viewpoint
suggests that it may be likely to change. For this reason, no attempt to eliminate redundancies
between viewpoint requirements should be made. However, it may be useful to try to
harmonize the requirements if they do not express exactly the same requirement.
After recommendations have been made for resolving redundancies and inconsistencies, the
changed requirements are fed back into the requirements elicitation phase. This is to ensure
that any changes are themselves compliant with concerns and are mutually consistent. An
application of PREview will typically result in several iterations of the
discovery/analysis/negotiation cycle. Each cycle should require diminishing effort.
Eventually, the viewpoints and their requirements should be sufficiently stable to integrate
into a requirements document.
Requirements definition
Once a stable set of viewpoints and requirements has been achieved, the requirements must
be integrated into a usable form. To most practical purposes, this means a requirements
document. Typically, the organisation of a requirements document is not viewpoint-oriented.
This means that the requirements information must be mapped onto the form defined for the
document. Note that it is essential to preserve the viewpoint information so that requirements
can be traced back.
from the requirements document to their viewpoints and their sources.
There are six activities involved in this mapping.
1. Identify the required structure of the requirements document and divide it into
the main sections. For example, it may be structured into sections on: system
constraints, functional requirements, performance requirements, interface
requirements and usability requirements.
2. Identify a set of quality, consistency or other standards which the document
should meet and formulate these as a checklist against which any requirement
can be evaluated.
3. For each external requirement, allocate it to one of the sections according to
whether it expresses a system constraint, functional requirement, etc.
4. Repeat activity 3 for each viewpoint requirement.
5. For each requirement (external or viewpoint) apply the checklist defined in
activity 2 and adapt requirements which fail to satisfy the checks.
6. Review each section and eliminate redundancy. Activity 2 is designed to
ensure that requirements use consistent terminology (a glossary may be a
useful byproduct of this activity) and are formulated at a level of detail which
is acceptable. Where requirements fail these checks, they should either be
reformulated or flagged as needing mor e detailed attention at a later stage.
It is also possible that other more serious errors will be identified here. This will require
feedback of the erroneous requirement(s) to the requirements negotiation phase and at least
one more iteration of the discovery analysis-negotiation cycle until the error is resolved
Activity 6 will be needed as any viewpoint-oriented requirements elicitation method
inevitably results in redundant requirements. This is the price paid for increasing the
likelihood of completeness. Even with the requirements analysis and negotiation phases, it is
unlikely that all redundancy in the requirements set will have been detected and resolved.
Chapter 9: Software Requirement and Risk Management
A risk is a condition that could cause some loss or otherwise threaten the success of a project.
This condition hasn’t actually caused a problem yet—and you’d like to keep it that way. These
potential problems might have an adverse impact on the project’s cost, schedule, or technical
success; the product’s quality; or the team’s effectiveness. Risk management is the process of
identifying, evaluating, and controlling risks before they harm your project. If something
untoward has already happened on the project, it’s an issue, not a risk. Deal with current
problems and issues through your project’s ongoing status tracking and corrective action
processes.
Because no one can predict the future with certainty, risk management is used to minimize
the likelihood or impact of potential problems. Risk management means dealing with a
concern before it becomes a crisis. This improves the chance of project success and reduces
the financial or other consequences of those risks that you can’t avoid. Risks that lie outside
the team’s sphere of control should be directed to the appropriate level of management for
attention.
Because requirements play such a central role in software projects, the prudent project
manager will identify requirements-related risks early and control them aggressively. Typical
requirements risk includes misunderstanding the requirements, inadequate user involvement,
uncertain or changing project scope and objectives, and continually changing requirements.
Project managers can control requirements risks only through collaboration with customers
and other stakeholders. Jointly documenting requirements risks and planning mitigation
actions reinforces the customer-development partnership that was discussed in Chapter 2,
“Requirements from the customer’s perspective.”
Simply knowing about the risks doesn’t make them go away, so this chapter presents a brief
tutorial on software risk management (Wiegers 2007). Later in the chapter, we also describe
a number of risk factors that can raise their ugly heads during requirements engineering
activities. Use this information to launch an attack on your requirements risks before they
attack your project.
Fundamentals of software risk management:
Projects face many kinds of risks besides those related to requirements. Dependence on an
external entity, such as a subcontractor or another project that is providing components to be
reused, is a common source of risk. Project management is fraught with risks from poor
estimation, rejection of accurate estimates by managers, insufficient visibility into project
status, and staff turnover. Technology risks threaten highly complex and leading-edge
development projects. Lack of knowledge is another source of risk, such as with practitioners
who have insufficient experience with the technologies being used or with the application
domain. Transitioning to a new development method introduces a raft of new risks. And ever-
changing, imposed government regulations can disrupt the best-laid project plans.
Scary! This is why all projects need to take risk management seriously. Risk management
involves scanning the horizon for icebergs, rather than steaming full speed ahead with great
confidence that your ship is unsinkable. As with other processes, scale your risk management
activities to your project’s size. Small projects can get by with a simple risk list, but formal
risk management planning is a key element of a successful large-scale project.
Elements of risk management:
Risk management involves the application of tools and procedures to contain project risk
within acceptable limits. It provides a standard approach to identify and document risk factors,
evaluate their potential severity, and propose strategies for mitigating them (Williams,
Walker, and Dorofee 1997).
Risk assessment is the process of examining a project to identify potential threats. Facilitate
risk identification with lists of common risk factors such as those described in the
“Requirements-related risks” section later in this chapter or with other public lists of typical
risks (for example, Carr et al. 1993; McConnell 1996). During risk analysis, you’ll examine
the potential consequences of specific risks to your project. Risk prioritization helps you focus
on the most severe risks by assessing the potential risk exposure from each. Risk exposure is
a function of both the probability of incurring a loss due to the risk and the potential magnitude
of that loss.
Risk avoidance is one way to deal with a risk: don’t do the risky thing. You can avoid some
risks by not undertaking certain projects, by relying on proven rather than cutting-edge
technologies and development methods, or by excluding features that will be especially
difficult to implement. Software development is intrinsically risky, though, so avoiding risk
might also mean losing opportunities.
Most of the time you’ll have to perform risk control activities to manage the top-priority risks
you identified. Risk management planning produces a plan for dealing with each significant
risk, including mitigation approaches, contingency plans, owners, and timelines. Mitigation
actions try either to prevent the risk from becoming a problem at all or to reduce the adverse
impact if it does. The risks won’t control themselves, so risk resolution involves executing
the plans for mitigating each risk. Finally, track your progress toward resolving each risk item
through risk monitoring, which should become part of your routine project status tracking.
Monitor how well your risk mitigation actions are working, look for new risks that have
popped up, retire risks whose threat has passed, and update the priorities of your risk list
periodically.
Documenting project risks:
It’s not enough to simply recognize the risks that face your project. You need to manage them
in a way that lets you communicate risk issues and status to stakeholders throughout the
project’s duration. Figure 32-2 shows a template for documenting an individual risk
statement. You might find it more convenient to store this information in tabular form, such
as a spreadsheet, which makes it easy to sort the list of risks in various ways, or in a database.
Keep the risk list separate from project plans so that it’s easy to update throughout the
project’s duration.
Use a condition-consequence format when you document risk statements. That is, state the
risk condition that you are concerned about, followed by the potential adverse outcome—the
consequence—from that condition. Often, people who suggest risks state only the condition
(“the customers don’t agree on the product requirements”) or the consequence (“we can
satisfy only one of our major customers”). Pull these statements together into the condition-
consequence structure: “If the customers don’t agree on the product requirements, then we
might be able to satisfy only one of our major customers.” One condition might lead to several
consequences, and several conditions can result in the same consequence.
The template provides spaces to record the probability of a risk materializing into a problem,
the negative impact on the project as a result of that problem, and the overall risk exposure. I
like to estimate the probability on a scale from 0.1 (highly unlikely) to 1.0 (certain to happen),
and the impact on a relative scale of 1 (no problem) to 10 (big trouble). Even better, try to rate
the potential impact in units of lost time or money. Multiply the probability by the impact to
estimate the exposure from each risk.
Don’t try to quantify risks too precisely. Your goal is to differentiate the most threatening
risks from those you don’t need to tackle immediately. You might find it easier simply to
estimate both probability and impact as high, medium, or low. Those items that have at least
one high rating demand your early attention.
Use the Risk Management Plan field to identify the actions you intend to take to control the
risk. Some mitigation strategies work to reduce the risk probability, others to reduce the
impact. Consider the cost of mitigation when planning. It doesn’t make sense to spend
$20,000 to control a risk with a maximum estimated impact of only $10,000 if it materialized
into a problem. You might also devise contingency plans for the most severe risks to anticipate
what actions to take if, despite your efforts, the risk does affect your project. Assign every
risk that you plan to control to an individual owner, and set a target date for completing the
mitigation actions. Long-term or complex risks might require a multistep mitigation strategy.
Planning for risk management:
A risk list is not the same as a risk management plan. For a small project, you can include
your plans for controlling risks in the software project management plan. A large project
should write a separate risk management plan that spells out the approaches it intends to take
to identify, evaluate, document, and track risks. This plan should include the roles and
responsibilities for the risk management activities. A risk management plan template is
available with this book’s companion content. Many projects appoint a project risk manager
to be responsible for staying on top of the things that could go wrong. One company dubbed
their risk manager “Eeyore,” after the gloomy Winnie-the-Pooh character who constantly
bemoaned how bad things could become
Establish a rhythm of periodic risk monitoring. Keep the 10 or so risks that have the highest
risk exposure visible, and track the effectiveness of your mitigation approaches regularly.
When a mitigation action is completed, reevaluate the probability and impact for that risk item
and then update the risk list and any other pending mitigation plans accordingly. A risk is not
necessarily under control simply because the mitigation actions have been completed. You
need to judge whether your mitigation approaches have reduced the exposure to an acceptable
level or whether the opportunity for a specific risk to become a problem has passed.
Requirements-related risks:
The risk factors described on the following pages are organized by the five requirements
engineering subdisciplines of elicitation, analysis, specification, validation, and management.
Techniques are suggested that can reduce each risk’s probability or impact. This list is just a
starting point: accumulate your own list of risk factors and mitigation strategies based on the
lessons you learn from each project. Theron Leishman and David Cook (2002) describe
additional risks related to software requirements. Be sure to write your risk statements in the
condition-consequence format.
Requirements elicitation:
Numerous factors can conspire to hamper your requirements elicitation efforts. Following are
several areas of potential elicitation risk and suggestions for how to avoid them.
Product vision and project scope: Scope creep is more likely if the stakeholders lack a
shared understanding of what the product is supposed to be (and not be) and do. Early in the
project, write a vision and scope document that contains your business requirements, and use
it to guide decisions about new or modified requirements.
Time spent on requirements development: Tight project schedules often pressure managers
and customers into glossing over the requirements because they believe that if the developers
don’t start coding immediately, they won’t finish on time. Record how much effort you
actually spend on requirements development for each project so that you can judge whether
it was sufficient and improve your planning for future projects. Agile development approaches
allow construction to begin earlier than on projects following a waterfall life cycle.
Customer engagement: Insufficient customer involvement during the project increases the
chance of an expectation gap. Identify stakeholders, customers, and user classes early in the
project. Determine who will serve as the literal voice of the user for each user class. Engage
key stakeholders as product champions. Make sure product champions fulfill their
commitments so you elicit the correct needs.
Completeness and correctness of requirements specifications: Elicit user requirements
that map to business requirements to ensure that the solution will deliver what the customers
really need. Devise usage scenarios, write tests from the requirements, and have customers
define their acceptance criteria. Create prototypes to make the requirements more meaningful
for users and to elicit specific feedback from them. Enlist customer representatives to review
the requirements and analysis models.
Requirements for innovative products: It’s easy to misgauge market response to products
that are the first of their kind. Emphasize market research, build prototypes, and use focus
groups to obtain early and frequent customer feedback about your innovative product visions.
Defining nonfunctional requirements: Because of the natural emphasis on product
functionality, it’s easy to neglect nonfunctional requirements. Query customers about quality
characteristics such as performance, usability, security, and reliability. Document these
nonfunctional requirements and their acceptance criteria as precisely as you can.
Customer agreement on requirements: If the diverse customers for your system don’t agree
on what you should build, someone will be unhappy with the result. Determine who the
primary customers are, and use the product champion approach to get adequate customer
representation Implementing requirements engineering and involvement. Make sure you’re
relying on the right people for making decisions about requirements. Have appropriate
stakeholder representatives review the requirements.
Unstated requirements: Customers often hold implicit expectations that are neither
communicated nor documented. Try to identify any assumptions the customers might be
making. Use open-ended questions to encourage customers to share more of their thoughts,
wishes, ideas, information, and concerns than you might otherwise hear. Asking customers
what would make them reject the product might reveal some topics that have not yet been
explored.
Existing product used as the requirements reference: Requirements development might
not be deemed important on next-generation or replacement projects. Developers are
sometimes told to use the existing product as their source for requirements, with a list of
changes and additions.
Solutions presented as needs: User-proposed solutions can mask the users’ actual needs,
lead to automating ineffective business processes, and over constrain the developers’ design
options. The analyst must drill down to understand the intent—the real requirement—behind
a solution the customer has presented.
Distrust between the business and the development team: As you have seen throughout
this book, effective requirements engineering demands close collaboration among various
stakeholders, particularly customer communities (the business side for IT projects) and
developers. If these parties do not feel that their counterparts are working in good faith toward
a mutually beneficial outcome, conflicts can arise and requirements elicitation can be
threatened.
Requirements analysis:
It isn’t prudent to just record whatever the customer tells you and dive into development.
Requirements analysis poses its own threat areas, as described below.
Requirements prioritization: Ensure that every functional requirement, feature, or user
requirement is prioritized and allocated to a specific system release or iteration. Evaluate the
priority of new requirements against the backlog of work remaining to be done, so that you
can make appropriate trade-off decisions and iteration plans.
Technically difficult features: Evaluate the feasibility of each requirement to identify those
that might take longer than anticipated to implement. Use status tracking to watch for
requirements that are falling behind their implementation schedule. Take corrective action as
early as possible. Prototype the novel or risky requirements to select effective approaches.
Unfamiliar technologies, methods, languages, tools, or hardware: Don’t underestimate the
learning curve of getting up to speed with new techniques that are needed to satisfy certain
requirements. Identify those high-risk requirements early on, and work with the development
team to allow sufficient time for false starts, learning, and experimentation.
Requirements specification:
Requirements are all about communication. Just because requirements are communicated on
paper or in writing doesn’t mean they are actually understood.
Requirements understanding: Different interpretations of the requirements by developers
and customers lead to expectation gaps, in which the delivered product fails to satisfy
customer needs. Peer review of requirements by developers, testers, and customers can
mitigate this risk. Trained and experienced business analysts will acquire the right information
and write high-quality specifications. Creating models and prototypes that represent the
requirements from multiple perspectives can reveal fuzzy, ambiguous requirements.
Time pressure to proceed despite open issues: It is a good idea to mark areas of the
requirements that need further work with TBD (to be determined) or as issues, but it’s risky
to proceed with construction if these haven’t been resolved. Record who is responsible for
closing each open issue and the target date for resolution.
Ambiguous terminology: Create a glossary to define business and technical terms that might
be interpreted differently by different readers. Requirements reviews can help participants
reach a common understanding of terms and concepts.
Design included in requirements: Design elements that are included in the requirements
place constraints on the options available to developers. Unnecessary constraints inhibit the
creation of optimal designs. Review the requirements to make sure they emphasize what needs
to be done to solve the business problem, rather than dictating the solution.
Requirements validation:
Even if you’ve done a good job on requirements elicitation, it’s important to confirm the
quality and validity of the solution that the requirements specify. Validation offers the
following pitfalls.
Unvalidated requirements: The prospect of reviewing a lengthy requirements specification
is daunting, as is the idea of writing tests very early in the development process. However, if
you confirm the correctness and quality of each set of requirements before their
implementation, you can avoid considerable expensive rework later. Include time and
resources for these quality activities in the project plan. Gain commitment from your customer
representatives to participate in requirements reviews. Perform incremental, informal reviews
to find problems as early and cheaply as possible.
Inspection proficiency: If inspection participants do not know how to inspect requirements
effectively, they might miss serious defects. Train all team members who will participate in
inspections of requirements documents. Invite an experienced inspector from your
organization or an outside consultant to observe your early inspections to coach the
participants.
Requirements management:
Much of the requirements-related risk on a software project comes from how changes are
handled. Those and other requirements management risks are mentioned below.
Changing requirements: You can control rampant scope creep by using documented
business requirements and scope definitions as the benchmark for approving changes. A
collaborative elicitation process with extensive user involvement can cut requirements creep
nearly in half (Jones 1996a). Detecting requirements errors early reduces the number of
modifications requested later on. Design the system for easy modifiability, particularly when
you are following an iterative life cycle.
Requirements change process: Risks related to how requirements changes are handled
include not having a defined change process, using ineffective change mechanisms, failing to
incorporate valuable changes efficiently, and incorporating changes that bypass the process.
A requirement change process that includes impact analysis, a change control board, and a
tool to support the process is an important starting point. Clear communication of changes to
the affected stakeholders is essential.
Unimplemented requirements: Requirements tracing helps you avoid overlooking any
requirements during design, construction, or testing.
Expanding project scope: If requirements are poorly defined initially, further clarification
can expand the scope of the project. Vaguely specified areas of the product will consume
more effort than anticipated. The project resources that were allocated according to the initial
incomplete requirements might be insufficient to implement the full scope of user needs. To
mitigate this risk, plan on a phased or incremental delivery life cycle. Implement the top
priority functionality in the early releases, and elaborate the system’s capabilities in later
iterations.
Risk management is your friend:
A project manager can use risk management to raise the awareness of conditions that could
cause the project to suffer. Consider the manager of a new project who’s concerned about
getting appropriate users involved in requirements elicitation. The astute manager will realize
that this condition poses a risk and will document it in the risk list, estimating the probability
and impact based on previous experience. If time passes and users still are not involved, the
risk exposure for this item will increase, perhaps to the point where it compromises the
project’s success. I’ve been able to convince managers to postpone a project that could not
engage sufficient user representatives by arguing that we shouldn’t waste the company’s
money on a doomed project.
Periodic risk tracking keeps the project manager apprised of the threat from identified risks.
Escalate risks that aren’t adequately controlled to senior managers, who can either initiate
corrective actions or make a conscious business decision to proceed despite the risks. Risk
management helps you keep your eyes open and make informed decisions, even if you can’t
control or avoid every adversity your project might encounter