Chapter 2. Managing Requirements

2.1 Chapter Objectives

After reading and thinking about the concepts and case studies presented in this chapter, you will be able to do the following:

• Understand the activities that are essential to managing software requirements

• Identify key issues and decisions involving the management of requirements in the chapter case studies

• Use the chapter concepts to suggest feasible solutions to the problems faced by the case study stakeholders

• Recognize the importance of managing software requirements

2.2 Context

The ability of a software project team to deliver products or services that satisfy the user’s needs and expectations depends first on the degree to which the requirements express the actual needs and perceptions of the user. The project deliverables can be only as “good” as the requirements that direct their development. Though determining appropriate requirements is essential, it is equally important that the software deliverables being developed satisfy these requirements and that the requirements do not change in an uncontrollable way as the software project progresses. When requirements are well managed, the resulting software deliverables are most likely to satisfy the user.

This chapter focuses on decisions that software project managers make to manage software project requirements. The chapter discusses these decisions in the context of activities performed by a software project team in managing requirements. It purposely does not delve into the details of specific techniques for managing requirements because many other people have written about this subject. Some insightful books that present techniques as well as practical advice for engineering software requirements are Hull et al. (2005), Jackson (2000), Wiegers (2003), and Wiegers (2006). IEEE Std. 830-1998 describes the content and qualities of a good software requirements specification (SRS) and provides several sample outlines for an SRS. Other suggested references related to managing software requirements appear at the end of the chapter context.

Before we talk about activities that compose the management of requirements, we should clarify some terminology. Practitioners use different terms to describe the activities involved in managing requirements. Some practitioners refer to the determination, documentation, and sign-off of the requirements as requirements engineering or requirements definition and to the activities after the requirements are signed off as requirements management (Borland 2006). We have chosen a more expansive use of the term managing requirements to reflect that stakeholders, including software project managers, make decisions regarding requirements throughout the life of a software project as well as throughout the life of the resulting software. Effective management of decision making and of the impact that decisions have on the requirements and resulting software deliverables is critical to the success of a software project.

Our discussion of managing requirements includes references to functional and nonfunctional requirements. Functional requirements are statements about the services that the software will perform for the user. Some software project stakeholders refer to these collectively as the required software behavior. Nonfunctional requirements are statements about quality attributes such as maintainability, performance, reliability, safety, security, or usability that the software should satisfy. Software project stakeholders generally describe and make decisions about software quality with respect to software quality attributes.

We’ll start by presenting activities that software project teams perform to manage requirements; and while doing this, we will discuss decisions that software project managers make or should make during each activity. As you will note, managing requirements involves multiple activities, each of which involves multiple decisions to be made. Because decision making involves risk, the chapter briefly mentions risks associated with making decisions about requirements. Chapter 7, “Managing Risk,” provides a more general discussion of risk in the context of making decisions for software projects.

Activities in Managing Requirements

Managing requirements is a process that usually begins with gathering requirements and should continue while the project team validates that the software deliverables satisfy their requirements. Primary activities in managing requirements include those such as the following (establishing the requirements for a software project includes the activities indicated by an asterisk):

• Eliciting and stating the requirements (specification)*

• Verifying and validating the requirements*

• Negotiating and contracting the requirements and project agreements*

• Managing requirements change and scope

• Validating software deliverables with respect to their requirements

Table 2-1 describes the activities that compose the management of requirements. Later, we will discuss example decisions that software project managers make when performing each activity. The example decisions are representative but are not intended to be complete or exclusive. You should talk with experienced managers about the decisions that they have made on the job and log the types of decisions that you encounter. Before embarking on a particular requirements activity, you might read the related discussion and peruse the corresponding table of example decisions.

Table 2-1: Descriptions of Activities in Managing Requirements

image

image

Establishing the Requirements

Considering the user’s needs and the relevant stakeholders is paramount to successfully establishing the requirements. The software project requirements should support the user’s business objectives. In other words, each requirement should map to a specific business objective. Determining and aligning the expectations of the customer or client with those of the developer or service provider is necessary to establish software requirements that will be acceptable to both types of stakeholders. Chapter 9, “Managing Stakeholder Expectations,” discusses the alignment between the customer and software developer expectations.

Involving the appropriate stakeholders in effective ways at the right times is critical to successfully establishing the software requirements (as well as to the success of the software project). In particular, stakeholders with the responsibility or authority to sign off or approve the software requirements, software project, or software project deliverables including the budget or cost should be involved in establishing the requirements. Before eliciting the requirements, the leaders of the requirements establishment process should consult all key stakeholders regarding the nature of their preferred involvement in the process.

In general, projects with requirements that are unpredictable or that involve unknowns, such as the use of innovative technologies, should include feasibility studies in which the open issues are explored and resolved before the project requirements are established. Neglecting to identify and resolve uncertainties about the requirements can lead to software project failure. For instance, this problem may occur if the software developer decides to specify requirements that depend on the use of a software component to be developed by another vendor that ultimately does not provide the component on time or at all. One way to handle the uncertainty associated with this type of decision is to negotiate an agreement with the component vendor and to design a contingency plan in the event that the vendor is late or unable to deliver the component.

Likewise, if the stakeholders’ understanding of and expectations for the requirements are still evolving, the process of establishing the requirements should include ways to explore alternative requirements. Time spent evaluating and resolving unknowns before deciding upon the requirements reduces the risk that the software deliverables or services will not satisfy the user’s expectations or needs and that they cannot be rendered on time and within budget. Resolving uncertainties regarding the requirements helps reduce the risk of software project failure.

People who establish requirements make decisions such as those shown in Table 2-2. The example decisions are grouped by decision area. What other decisions have you encountered or do you think that you might encounter when establishing requirements?

Table 2-2: Decisions to Make When Establishing Requirements

image

image

Lastly, it is important to remember that managing requirements does not end when the requirements are established. The job of managing requirements is not complete until the software is retired!

Now, we’ll cover the specific activities that compose the establishment of requirements. We will first discuss the elicitation and statement of requirements.

Eliciting and Stating Requirements

Eliciting both functional and nonfunctional requirements is critical to establishing requirements that will satisfy stakeholder needs and expectations. During the gathering of requirements, the software stakeholders frequently spend most of their time evaluating and deciding upon the functions to be performed by the software. Except for software qualities that are closely related to the functional behavior (such as the feedback loop rate for a control system), software stakeholders often wait until the end to consider the quality attributes that the software should exhibit. In an attempt to “wrap up” the requirements elicitation, they may quickly draft statements about the desired software qualities that are imprecise, inaccurate, incomplete, or simply incompatible.

For example, a common requirements mistake to is to state that the software system should “respond in real time and be fast” (whatever fast means). A real-time software system is not simply a system that responds quickly. A real-time system responds predictably with respect to events and time. The system may execute periodically (repeatedly every specified time interval) or aperiodically (only when a specific, noncyclical event occurs). The real-time system may need to satisfy hard deadlines (for example, it must respond within 20 milliseconds after an event occurs or else something undesirable will happen), may be allowed to miss a soft deadline by some specified amount of time (for example, it’s preferable to respond within ten seconds after the event occurs, but it is sufficient to respond within one minute), or may be permitted to not respond at all to the event if the processing system is overloaded.

A quality attribute that software stakeholders often do not consider is the expected or likely evolution of the software. Decisions about software evolution are important if the software is to continue to provide value to the user over a lifetime beyond a single release. For software to be developed and released iteratively or incrementally in a cost-effective way, there needs to be a software release plan to indicate which requirements are expected to be developed for each release. The release plan may be flexible or change as the software developers receive feedback from users as with Agile development or other iterative approaches (Beck et al. 2001; Larman and Basili 2003). While establishing the requirements, the software stakeholders should consider and decide upon an overall plan for the evolution of the software to help the software architects and designers determine an appropriate composition for the software. See Ullah and Ruhe (2006), who present ongoing research in the process to develop a comprehensive and formalized model for planning and optimizing releases for software product lines.

Specifications of requirements should define the requirements from a user’s point of view and should provide a system context. The requirements should fit into a “big picture” of where and how the software will be used. The objective is to specify the requirements in a way that enables the specification to be analyzed with respect to the ability of the requirements to satisfy the user’s business needs. In other words, the specification enables the validation of the requirements. The stakeholders who review the statement of requirements need to develop a common understanding of what each stated requirement means.

The statement of requirements should be written in a way that enables the specification to be analyzed for clarity, completeness, consistency, correctness, and compatibility. Likewise, the requirements should be testable in that ways exist to determine that the software project deliverables satisfy them. For instance, stating that the software system should execute flawlessly in a weightless environment (such as outer space) is meaningless if there is no practical way on Earth to verify that the software does indeed execute as intended without the effects of gravity.

People who elicit and state requirements make decisions such as those shown in Table 2-3. The example decisions are grouped by decision area. What other decisions have you encountered or do you think that you might encounter when eliciting and stating requirements?

Table 2-3: Decisions to Make When Eliciting and Stating Requirements

image

image

Next, we’ll discuss the types of decisions that software engineers make when verifying and validating requirements.

Verifying and Validating Requirements

Verifying the requirements ensures that the specified requirements are clear, complete, consistent, correct, mutually compatible, and feasible, whereas validating the requirements ensures that the specified requirements do indeed satisfy the user’s business needs and expectations for the software project deliverables. It is particularly important that the software professionals who validate the requirements specification include stakeholders who represent the user’s point of view. It may also help if the professionals who inspect requirements have university degrees in majors not related to computer science or have prior experience in writing requirements. See the report on a statistically controlled experiment at Microsoft Corporation involving 70 professionals who participated in a requirements inspection (Carver et al. 2008).

A critical process decision involves the techniques that will be used to verify and validate the software requirements. Software engineers often model the required software behavior and quality attributes to better analyze their correctness, accuracy, and compatibility. The premise for model-driven software development (MDSD) is that models of the software requirements can be verified, validated, and then mapped into software designs (which also may be expressed as models) and implementations that improve quality while reducing the time and cost associated with development. See IBM Systems Journal (2006) for an excellent collection of papers that give an overview of model-driven software development. A question to be asked when using MDSD is, how well do the selected models represent and clarify the required behaviors and qualities? In other words, how well will the selected modeling techniques enable the software developers to know whether the specified requirements are correct, sufficiently accurate, complete, compatible, and so on? Some additional references to techniques for modeling software requirements appear at the end of the chapter context.

Another important process decision, discussed earlier, is how the software developers will detect and resolve unknowns about the requirements. Identifying and resolving unknowns should be done throughout the life of the software project, but it is particularly important during the early stages of the software project when it is easier and less costly to make changes to the requirements and project direction. Even if the project stakeholders do not expect unknowns in the requirements, the verification and validation of requirements should determine whether any requirements may not be achievable or may preclude the achievement of other requirements.

People who verify and validate requirements make decisions such as those shown in Table 2-4. The example decisions are grouped by decision area. What other decisions have you encountered or do you think that you might encounter when verifying and validating requirements?

Table 2-4: Decisions to Make When Verifying and Validating Requirements

image

To explore the last activity in establishing the requirements, we’ll next cover the types of decisions that software engineers make when negotiating and contracting requirements.

Negotiating and Contracting Requirements

In many organizations, the people who negotiate and contract agreements for software projects are not the people who eventually manage or lead these projects. Whether this separation of stakeholders hinders or promotes successful software outcomes probably depends on the degree to which the interests of all types of relevant stakeholders are represented in negotiating and contracting the software project agreements.

Negotiating the software project requirements is inherently a process of trade-offs and decisions. Stakeholder discussion and agreement upon the trade-offs helps stakeholders to focus on elements of the requirements that they can actually control such as scope, time, quality, or cost. The negotiation process stimulates stakeholders to explore options that optimize the expectation space for all. In other words, it maximizes the win-win opportunities for “opposing” stakeholders.

Software project agreements (contracted decisions) should provide the stakeholders with a clear, compatible, complete, consistent, and correct description of elements such as those described in Table 2-5.

Table 2-5: Elements of a Software Project Contract

image

In reading this section, you may view the contracting of requirements through a legalistic lens focused on the protection of stakeholder rights. Though software project contracts are intended to legally protect stakeholder interests, clarifying the expectations and responsibilities of the software project stakeholders is essentially a good business practice. The old adage “leave no stone unturned” is applicable to negotiating and contracting the software project agreements. Software project stakeholders should discuss, reach agreement, and document their expectations, concerns, and any other issues that they have regarding a software project. Making stakeholder expectations transparent is analogous to flushing out and resolving software project unknowns.

People who negotiate and contract requirements make decisions such as those shown in Table 2-6. The example decisions are grouped by decision area. What other decisions have you encountered or do you think that you might encounter when negotiating and contracting requirements?

Table 2-6: Decisions to Make When Negotiating and Contracting Requirements

image

image

We’ll now progress to the types of decisions that software engineers make when managing requirements change and scope.

Managing Requirements Change and Scope

Some software project managers think that the requirements work ends when the requirements are established. In practice, project requirements need management throughout the life of the software project and across multiple projects for software that evolves iteratively or incrementally. The continuous and ongoing management of requirements is necessary because software requirements are not static. Software engineers may use techniques such as prototyping, simulation, and mock-ups to help users determine exactly what the software should do and how the interface to the software should look. But even by applying techniques to better understand the nature of the requirements, the user’s (customer’s) view and expectations still may change as the software project progresses.

The developer’s view of requirements may also change for various reasons. Sometimes there is miscommunication by the stakeholders while eliciting the requirements. Other times, the developer viewpoint changes because of knowledge that is acquired through ongoing communication with potential users (especially with those who were not involved in establishing the original requirements), through applying the chosen technologies and development techniques, and through other forms of research or information gathering. For instance, the developer may discover unexpected technical issues that warrant changes in the requirements.

In general, changes in the requirements for a software project are beneficial when they improve the clarity, compatibility, completeness, consistency, or correctness of the requirements. But it is important that the software project stakeholders carefully consider the impact of a change request on the scope, time, quality, and cost of the deliverables before deciding to make the change. Obviously, changes that enlarge the scope of the requirements for the software project deliverables run the risk of overshooting the budget or schedule of a software project.

The main idea to keep in mind is that changing the software requirements involves a cost-benefit trade-off: there is a cost associated with the resources and time needed to handle the change as well as a potential benefit. The primary decisions that software project stakeholders must make are whether the software project budget can support the cost of a particular software change and whether the business benefit associated with the software change is worth the cost (including time). Stakeholders must weigh the benefit versus the cost associated with a particular change in the software requirements. The software managers should help the project stakeholders decide whether including the change later rather than in a currently planned release of the software yields better value. The stakeholders may need to reevaluate and make new decisions about the project agreements in order to accommodate changes in the requirements.

We’ll now take a moment to apply the PEAK model when making a decision regarding a request to add a feature to the requirements for a software project’s deliverables. Suppose that the customer for a robotic surgical assistant product requests the addition of a new software algorithm after the project agreements have been established. Using the PEAK model, the software developers can ask questions such as the following to help the customer decide whether the benefit of adding this feature outweighs the cost:

(P) Problem: Should the software project stakeholders expand or modify the project requirements to include the new software algorithm?

(E) Experience:

• How difficult or easy will it be to develop and integrate the new algorithm (with respect to process, staff, time, quality, and so on)?

• How difficult or easy will it be to verify and validate the software with the new algorithm (with respect to process, staff, time, quality, and so on)?

(A) Assumptions: What aspects of the algorithm should be established as facts rather than assumed? For instance, the project stakeholders should determine whether the following assumptions are factual:

• This algorithm will be the most appropriate one available for the foreseeable future. In other words, there is no other better algorithm that will be available in the near future.

• The algorithm will not interfere with or be incompatible with the other requirements.

• The performance, reliability, and safety of the algorithm have been sufficiently verified and validated.

(K) Knowledge:

• Considering the surgical procedures for which the robotic surgical assistant will be used, how will this new feature improve the performance, safety, or other quality attributes of the product?

• Does the addition of the new feature preclude the use of other requirements (is incompatible with other requirements)?

• What is the impact on the project time (schedule), quality, and cost (budget) of each alternative solution? Which of these scenarios is preferable to the software project stakeholders and why?

Solution:

• Add new feature in current software release.

• Add new feature in a future release of the software.

• Do not add feature in the foreseeable future.

• Are there other viable solutions? If so, what are they?

Assumed Risk: Given the current input information, what do the software project stakeholders know about the risks that they would assume with each feasible solution?

Ultimately, the software project stakeholders must decide whether the benefits of a particular solution outweigh the cost and risks associated with the solution and whether the cost-benefit relationship for a particular solution is better than that for the other solutions.

Another challenge involves scope creep that may occur when software developers implicitly expand or contract the requirements. The problem with implicit changes to scope is that they are less likely to be communicated uniformly to the project stakeholders who need to be aware of them. Uninformed stakeholders are likely to be surprised and possibly dissatisfied with the resulting validation test results or software project deliverables. The software project stakeholders should discuss, evaluate, and explicitly decide upon changes to the software requirements and their scope. The decision makers should communicate the changes to other software project stakeholders who need to know about them, such as the software analysts who can make certain that the changes are compatible with the ongoing requirements and the software engineers designing tests to validate the software project deliverables. Haphazard and implicit changes to requirements can lead to software development problems and ultimately to unsatisfactory software project deliverables.

People who manage requirements change and scope make decisions such as those shown in Table 2-7. The example decisions are grouped by decision area. What other decisions have you encountered or do you think that you might encounter when managing requirements change and scope?

Table 2-7: Decisions to Make When Managing Requirements Change and Scope

image

Last, but certainly not least, we’ll talk about the types of decisions that software engineers make to validate the software project deliverables with respect to their requirements.

Validating the Software Project Deliverables with Respect to Their Requirements

Software project stakeholders and managers often anxiously await the delivery of software project deliverables that demonstrate the success of the project and the culmination of a business venture. Validating the software project deliverables with respect to their requirements is the apex of their development. Project managers should consider validating project deliverables to be an integral part of managing requirements for several reasons:

• The reason for defining requirements is to help ensure that the resulting software project deliverables satisfy the needs and expectations of the user.

• The validation of software project deliverables with respect to requirements must be done from the user’s point of view.

• The tests used to validate software project deliverables need to reflect changes to the requirements. Therefore, managing requirements involves managing changes to requirements as well as to the associated tests used to validate the software project deliverables.

Validating software project deliverables is best done by people who represent the point of view of the user, who are able to understand the various aspects of different types of software project requirements and deliverables, and whose observations are least likely to be clouded by detailed knowledge of how the project deliverables were developed. Validation experts should also be knowledgeable about problems that are likely to occur in the types of products or services being produced or delivered by the software project as well as about how to find obscure bugs that can occur.

When making decisions regarding the validation of software project deliverables, software managers need to remember that requirements should be tested from the user’s point of view with respect to a system context. Validating software project deliverables ensures that the stakeholder expectations regarding the software project requirements and contractual agreements are met. Project managers also need to keep in mind that validating the software project deliverables with respect to their requirements is worthwhile only if the specified requirements and corresponding software system tests have been verified and validated. In addition, they need to remember that incorporating changes to requirements into the software requirements specification and corresponding software system tests is critical to ensure the complete and correct validation of software project deliverables with respect to requirements.

People who validate software project deliverables with respect to their requirements make decisions such as those shown in Table 2-8. The example decisions are grouped by decision area. What other decisions have you encountered or do you think that you might encounter when verifying and validating requirements?

Table 2-8: Decisions to Make When Validating Software Project Deliverables with Respect to Their Requirements

image

For readers interested in topics related to managing software requirements, we suggest the following references. Wang et al. (2007) discuss an automated approach for monitoring and diagnosing problems that occur with software requirements. For studies and discussions of requirements problems that contribute to software project or product failure, see Ebert and De Man (2005), Ebert and Hickey (2008), and Verner (2008). Some modeling techniques for functional requirements are the Unified Modeling Language (UML) included in the Rational Unified Process (Rational 2001; Object Management Group); problem frames (Jackson 2000; Jackson 2005; Cox et al. 2005), which includes a road map of problem frames research; and Jackson and Jackson (2006) for a formalized approach to separating concerns in requirements analysis. Bar-On and Tyszberowicz (2007) present a methodology for identifying conflicting functional requirements and potentially for deriving alternative, nonconflicting requirements. Raja (2009) overviews and highlights the pros and cons of current software requirements validation techniques, and Damian and Chisan (2006) discuss an empirical study that shows how requirements engineering can help improve other project processes with respect to productivity, quality, and risk management. Cao and Ramesh (2008) provide an analysis of data from 16 software development organizations that reveals 7 Agile requirements engineering practices, along with their benefits and challenges.

2.3 Case Studies

The two case studies in this chapter focus on aspects of managing requirements that are often overlooked by software project stakeholders and managers. In the first case, “The New Account Project at HBC,” the software project managers encounter unexpected problems related to decisions made about selecting and involving the project stakeholders when establishing the requirements. The second case, “On Time, Within Budget, but Wrong” presents a “model” project. Everything goes well in the project until the stakeholders who represent the user decide that the finished software is not what is needed or expected. Read these cases to determine the issues and decisions that led to critical glitches in managing software requirements.

2.4 Summary

The chapter focused on the following activities for managing requirements in the context of decision making for software projects. The asterisk indicates those activities involved in establishing the requirements.

• Eliciting and stating the requirements (specification)*

• Verifying and validating the requirements*

• Negotiating and contracting the requirements and project agreements*

• Managing requirements change and scope

• Validating software deliverables with respect to their requirements

The first case study, “The New Account Project at HBC,” highlighted the importance of evaluating decisions about the appropriate stakeholders to establish the requirements for a software project and what their roles should be. The second case study, “On Time, Within Budget, but Wrong,” focused on making decisions regarding the software quality attributes and other constraints that the software should satisfy. The case study also demonstrated the need to plan for the evolution of software products whose core assets are intended to be reused across similar products and applications.

Managing requirements does not end with their establishment. Software project managers must manage requirements change and scope to enable software projects to be completed on time, to be completed within budget, and to achieve their objectives. The highpoint of a software development project is the validation of the software with respect to the requirements.

Managing requirements, and therefore evaluating and making decisions about requirements, ends when the software is retired.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset