Essentials of Software Requirements
Best practices for requirements engineering to deliver superior value for both traditional and agile projects, in any application domain.
This chapter is from the book
This chapter is from the book
This chapter is from the book
Many years ago, I (Karl) would sometimes dive into writing a new program based on nothing more than an initial idea. I’d spend time coding, executing, fixing, and making a mess in my source code editor as I fumbled around, trying to get results. Eventually, I realized that the root of the problem was rushing to code without having an end point in mind—coding’s fun! Those frustrating experiences taught me the importance of thinking through some requirements—objectives, usage tasks, data elements, and more—before doing anything else. After I adjusted my process to understand my requirements first, I never again felt like a software project was out of control.
All projects have requirements. Some teams begin with crisply defined business objectives, other teams receive a rich description of the desired solution’s capabilities and characteristics, and still others start with only a fuzzy new product concept. Regardless of the starting point, all participants eventually must reach a shared understanding of what the team is supposed to deliver.
Some project participants aren’t very interested in requirements. Certain managers may claim they’re too busy to engage in requirements discussions. But then their expectations surface after the product has progressed to the point where major changes mean expensive rework. Some technical people might regard the time spent exploring and documenting requirements as a distraction from the real work of crafting code. However, a good set of requirements lets you answer some important—and universal—questions.
Why are we working on this?
Who are we trying to satisfy?
What are we trying to build?
What functionality do we implement first? Next? Maybe never?
How can we tell if our solution1 is good enough?
How do we know when we’re done?
This book describes the twenty most important practices that help software teams create a set of requirements to serve as the foundation for the subsequent development work. These practices broadly apply regardless of the type of product the team is creating or their development approach. Some software teams work not on discrete development projects but on existing products that demand ongoing modifications and new functionality. The people who are responsible for requirements work on product teams like those will find the practices in this book equally applicable to their work.
The requirements terminology differs between traditional (plan-driven or predictive) and agile (change-driven or adaptive) projects. Regardless of the terminology used, developers still need the same information to build the right solution correctly (Wiegers and Beatty, n.d.a). Some teams will perform certain practices iteratively, delivering value in small chunks. Others may do much of the requirements work early in the project because the problem is well understood. A startup that’s trying to assess its product’s market fit will focus on exploring ideas and approaches rather than trying to assemble a detailed specification. Whichever way you plan your development cycles, performing these twenty practices well can make the difference between delivering a solution that satisfies your stakeholders and creating one that does not.
Requirements Defined
Now that we’ve used the word requirement several times, we should define what we mean. A software team must deal with many types of requirements-related knowledge, and people will be confused if they lack a common understanding of them. Although it’s not fully inclusive, one useful definition of requirement comes from Ian Sommerville and Pete Sawyer (1997):
Requirements are … 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.
This definition points out that requirements encompass multiple types of information. However, one aspect lacking from that definition is the concept of a requirement as a statement of a stakeholder need, which is the real starting point for all discussions about requirements.
Several classification schemas and models are in common use to describe various kinds of requirements information (Robertson and Robertson 2013, Wiegers and Beatty 2013, IIBA 2015). They generally agree but differ in some terminology details. In this book, we’ll use the model shown in Figure 1.1.
)
Figure 1.1 Connections between several types of requirements information and containers that store them. Solid lines mean “are stored in.” Dotted lines mean “are the origin of” or “influence.”
This model shows various categories of requirements information (ovals) as well as containers in which to store that information (rectangles). For simplicity, this book will refer to those containers as documents. They could just as well be spreadsheets, databases, requirements management tools, issue tracking tools, wikis, or a wall covered with sticky notes—whatever works for your team. The container itself is less important than the information it holds and how you choose to record, organize, and communicate that information.
Models like that in Figure 1.1 illustrate that there are many types of requirements information. This book uses the definitions in Table 1.1, which are broadly accepted in the requirements engineering and business analysis domains. Note that solution requirements encompass functional, nonfunctional, and data requirements (IIBA 2015). You’ll see examples of these various items in later chapters. This book uses the collective term requirements to refer to all of these types of information, whether your local terminology focuses on features, use cases, user stories, or anything else.
Table 1.1 Definitions of several types of requirements information
Type of information |
Definition |
|---|---|
Business requirement |
Information that describes why the organization is undertaking the project, establishes business objectives, defines a product vision, and includes other direction-setting information. (See Practice #2, “Define business objectives.”) |
Business rule |
A directive that defines or restricts actions within an organization’s operations. A policy, regulation, law, or standard that leads to derived solution requirements that enforce or comply with it. (See Practice #16, “Identify and document business rules.”) |
Constraint |
A restriction imposed on the requirements, design, or implementation activities. |
Data requirement |
A definition of a data object or element that the system must manipulate, its composition and attributes, relationships among data objects, and their input and output formats. (See Practice #8, “Assess data concepts and relationships.”) |
External interface requirement |
A description of a connection between the solution being built and other elements of the world around it, including users, other software systems, hardware devices, and networks. |
Functional requirement |
A description of some behavior that the product will exhibit under specified circumstances. |
Nonfunctional requirement |
Most commonly refers to what is also known as a quality attribute requirement. Quality attributes describe various quality, service, or performance characteristics of the solution. (See Practice #9, “Elicit and evaluate quality attributes.”) |
Solution requirement |
A description of a capability or characteristic that the product being created must possess to satisfy certain user requirements and help achieve the project’s business objectives. Solution requirements include functional, nonfunctional, and data requirements, as well as manual operations. |
System requirement |
A description of a top-level capability or characteristic of a complex system that has multiple subsystems, often including both hardware and software elements. System requirements serve as the origin of derived software solution requirements. |
User requirement |
A description of a task or goal that a user wishes to accomplish with the solution. The International Institute of Business Analysis generalizes this category to “stakeholder requirements,” but in actuality, all requirements originate from some stakeholder (IIBA 2015). Here, we’re specifically referring to things the user needs to do and user-specific expectations the solution must satisfy. (See Practice #6, “Understand what users need to do with the solution.”) |
The fact that the diagonal arrows in Figure 1.1 that lead from Business Requirements down to the Software Requirements Specification are all aligned is no accident. Developers do not directly implement business requirements or user requirements. They implement functional requirements, including those derived from other categories of requirements information. The goal is to implement the right set of functionality that lets users perform their tasks and satisfies their quality expectations, thereby (hopefully) achieving the project’s business requirements, within all imposed constraints. That “right set” of functional requirements comes from a foundation of well-understood business and user requirements.
Not every requirement will fit tidily into one or another of the categories in Table 1.1. Debating exactly what to call a specific statement is not important. What’s important is that the team recognizes the need, analyzes it, records it in an appropriate form and location, and builds whatever is necessary to satisfy it.