Mastering the Requirements Process
- Agility Guide
- Requirements Process in Context
- The Process
- A Case Study
- Trawling for Requirements
- Prototyping the Requirements
- Writing the Requirements
- The Quality Gateway
- Reusing Requirements
- Reviewing the Specification
- Iterative and Incremental Processes
- Requirements Retrospective
- Your Own Requirements Process
- In Conclusion
in which we look at a process for gathering requirements and discuss how you might use it
The requirements process described in this book is the product of our experience. We developed the Volere Requirements Process and its associated specification template from the activities and deliverables we have found effective over years of working on projects and consulting with our clients. The result of this experience is a requirements-gathering and specification process whose principles can be applied to almost all kinds of application types in almost all kinds of development environments.
We want to stress from the very beginning that while we are presenting a process, we are using it as a vehicle for finding requirements. That is, we do not expect you to wave the process around and tell your coworkers that this is "the way to do it." We do expect you will find many useful things to do within the process that will help you to gather requirements more productively and accurately. We are sure of this fact, because we have personally seen hundreds of companies adapt the process to their own cultures and organizations, and we know of thousands more that have done so.
A requirements process is not just for waterfall development. Our clients use XP, RUP, and many other acronyms, as well as traditional waterfall, incremental, and all flavors of agile development processes. Over the years they have agreed with us: If the right product is to be built, then the right requirements have to be discovered. But requirements don't come about by fortuitous accident. To find the correct and complete requirements, you need some kind of systematic process.
The Volere Requirements Process Model in appendix A contains a detailed model of all of the activities and the connections between them. The model is very detailed. Rather than getting involved in that kind of detail and complexity right away, let's stand back and take a simpler view of the overall process. This simplified view is shown in Figure 2.1.
This simplified version of the process model will reappear at various places throughout this book. For the most part, the simplified version is faithful enough to the complete version in appendix A. Sometimes, for the sake of making an explanation simpler or clearer, we will make minor changes to the model or show only part of it. Please be aware of this and use the detailed model for any of your important implementation decisions.
Figure 2.1 shows all of the main activities in the Volere Requirements Process, including how they are linked by their deliverables. The deliverables are shown as moving from one activity to the next. For example, the Trawling for Requirements activity would probably gather the requirements for one business use case at a time. The requirements would be written to demonstrate that they have been correctly understood and agreed, and then passed to the Quality Gateway for testing prior to being included in the Requirements Specification. Any rejects would be sent back to the originator, who probably would take them back to the trawling activity for clarification and further explanation. Don't take this apparent waterfall approach too literally—the activities usually iterate and overlap before producing their final output. As we go through this process in detail, we will explain where and how iteration and incremental delivery can be used.
When referring to development processes, agility is normally taken to mean the absence of a set process that must be followed regardless of the product being developed. However, it does not mean the absence of all process. Agile development means selecting the appropriate process, or parts of a process, that are appropriate for the product and the project.
Not all projects can be as agile as others. Large numbers of stakeholders, the need for documentation, scattered development teams, and other factors will inevitably dictate the degree of agility that can be applied by the project team. As a consequence, you must determine the degree of agility appropriate to your current project. In Chapter 1, we introduced symbols to represent your aspirations for agility. These symbols are intended to guide you as you select the most appropriate way to use the information in this book.
Rabbit projects are those where circumstances allow for the highest degree of agility. They are typically, but not necessarily, smaller projects where close stakeholder participation is possible. Rabbit projects usually include a smaller number of stakeholders.
Participants in rabbit projects may think it odd to consider using any kind of process at all for requirements. However, as you look at the process in this chapter, think not of a process that delivers a requirements specification, but rather of a process that delivers a requirement, or at least requirements, one use case at a time. If you are using eXtreme Programming (most likely with rabbit projects), the fastest way to learn your customer's and (importantly) his organization's requirements is not at the keyboard but at the whiteboard. Pay particular attention to the part that prototyping and scenarios play in the process and to the idea of essence of the system. It is crucial that you understand the difference between a requirement and a solution.
Rabbit projects are iterative. They gather requirements in small units (probably one business use case at a time) and then implement the solution piecemeal, using the implementation to get feedback from the stakeholders. However, we stress that this feedback should not be used to find out what the stakeholders wanted in the first place. That is the role of requirements, and it is far more effective and efficient if done using requirements methods. Read on.
Horse projects are the "halfway house" of agility. They use as much agility as possible, but have constraints imposed by the project and the organization. Horse projects should use most of the process we are about to describe, keeping in mind that you could easily use an iterative approach to requirements gathering. That is, the requirements for one unit of work—probably one business use case—are gathered and then the designers start work on those requirements. This strategy needs the overall architecture to be in place before it can work. The advantage is that while the requirements analysts are gathering the requirements for one business use case, the developers are busy building a solution for the requirements from the previous business use case.
The sections on trawling, writing, and the Quality Gateway will be of great interest to horse projects. If these activities are done correctly and iteratively, your project can achieve a considerable effectiveness without becoming bogged down in its own process.
Elephant projects are the least agile, but—like their namesake—are large, are dependable, and have long memories. In such a case, your aspirations toward agility may be limited by the organization of the project—for example, you may have a large number of scattered stakeholders—or the need to produce formal requirements documentation such as for pharmaceutical or aeronautical projects, projects that entail some contractual obligation, or projects where you are outsourcing some tasks to another organization.
Most of the elements of the requirements process outlined in this chapter are used by elephant projects. But always be on the lookout for opportunities in your project to increase your agility by gathering requirements in an iterative manner.