Managing Software Requirements: A Unified Approach

Book description

"A comprehensive solution to the requirements challenges faced by every development team. Full of insight and ideas all developers can learn from." --Ivar Jacobson

"Many projects fail for the simple reason that the developers fail to build the right thing: They either deliver a system that does not meet the expectations of its intended users, or they deliver a system that focuses on secondary functions at the expense of its primary use. Drawing on their extensive experience, Dean and Don demonstrate how to employ an industrial-strength requirements process, one that helps ensure you will build the right thing. Developers of any kind of application should read this book." --Grady Booch

Despite the wealth of development knowledge, experience, and tools generally available today, a substantial percentage of software projects continue to fail, often because requirements are not correctly determined and defined at the outset, or are not managed correctly as the project unfolds. Clients do not always know or express their needs precisely, and too often designers and developers do not ask the right questions at the right times. As a result, projects often spin out of control as "feature bloat" and shifting priorities cause budgets and schedules to exceed expectations. Managing Software Requirements focuses on this critical cause of failure and offers a practical, proven approach to building systems that meet customers' needs--on time and within budget.

The authors are skilled practitioners who have spent their careers in the trenches building high-quality applications, including safety-critical, real-time systems. Using an informal, approachable style, their own war stories, and a comprehensive case study they show how designers and developers can effectively identify requirements by employing the power of use cases and more traditional forms of requirements expression. The book illustrates proven techniques for determining, implementing, verifying, and validating requirements. It describes six vital Team Skills for managing requirements throughout the lifecycle of a project: Analyzing the Problem, Understanding User Needs, Defining the System, Managing Scope, Refining the System Definition, and Building the Right System. Managing Software Requirements specifically addresses the ongoing challenge of managing change and describes a process for assuring that project scope is successfully defined and agreed upon by all stakeholders.

Topics covered include:

  • The five steps in problem analysis

  • Business modeling and system engineering

  • Techniques for eliciting requirements from clients, users, developers, and other stakeholders

  • Applying and refining use cases

  • Prototyping

  • Organizing and managing requirements information

  • Establishing project scope and managing customers

  • Using both informal and technical methods for specifying requirements

  • How to measure and improve the quality of your product's requirements

  • Moving from requirements to implementation

  • Verifying and validating the system

  • Managing change

The book concludes with a step-by-step guide to incorporating these powerful techniques into future projects.


Table of contents

  1. Copyright
    1. Dedication
  2. Foreword
    1. The Rock Problem
    2. About This Book
  3. Preface
    1. Context and Acknowledgments
    2. Requirements Lessons from Building Software for Others
    3. Lessons from Building High-Assurance Systems
    4. Lessons from the Requirements Management Business
    5. Experiences at Rational Software
    6. Summary
  4. 1. Introduction
    1. 1. The Requirements Problem
      1. The Goal
      2. A Look at the Data
      3. Root Causes of Project Success and Failure
        1. The Frequency of Requirements Errors
        2. The High Cost of Requirements Errors
        3. Conclusion
    2. 2. Introduction to Requirements Management
      1. Definitions
        1. What Is a Requirement?
        2. What Is Requirements Management?
      2. Application of Requirements Management Techniques
        1. Types of Software Applications
        2. Systems Applications
      3. The Road Map
        1. The Problem Domain
        2. Stakeholder Needs
        3. Moving Toward the Solution Domain
        4. Features of the System
        5. Software Requirements
        6. An Introduction to Use Cases
      4. Summary
    3. 3. The Software Team
      1. Software Development as a Team Activity
        1. Requisite Team Skills for Effective Requirements Management
        2. Team Members Have Different Skills
        3. The Organization of Software Teams
      2. The Case Study
        1. Background for the Case Study
        2. The HOLIS Software Development Team
      3. Summary
  5. 2. Analyzing the Problem
    1. 4. The Five Steps in Problem Analysis
      1. Step 1: Gain Agreement on the Problem Definition
        1. The Problem Statement
      2. Step 2: Understand the Root Causes—The Problem Behind the Problem
        1. Addressing the Root Cause
      3. Step 3: Identify the Stakeholders and the Users
      4. Step 4: Define the Solution System Boundary
      5. Step 5: Identify the Constraints to Be Imposed on the Solution
      6. Summary
      7. Looking Ahead
    2. 5. Business Modeling
      1. Purpose of Business Modeling
      2. Using Software Engineering Techniques for Business Modeling
        1. Choosing the Right Technique
        2. The Unified Modeling Language (UML)
        3. Business Modeling Using UML Concepts
      3. From the Business Models to the Systems Model
      4. When to Use Business Modeling
      5. Summary
      6. Looking Ahead
    3. 6. Systems Engineering of Software-Intensive Systems
      1. What Is Systems Engineering?
        1. Pragmatic Principles of Systems Engineering
        2. The Composition and Decomposition of Complex Systems
      2. Requirements Allocation in Systems Engineering
        1. On Derived Requirements
        2. A Quiet Revolution
        3. When Generations Collide: Graybeard Meets Young Whippersnapper
        4. Avoiding the Stovepipe System Problem
        5. When Subsystems Are Subcontracts
        6. Making It Work Out Right
      3. The Case Study
        1. Preliminary User Needs
        2. Problem Analysis
        3. HOLIS: The System, Actors, and Stakeholders
        4. HOLIS Systems Engineering
        5. The Subsystems of HOLIS
      4. Team Skill 1 Summary
  6. 2. Understanding User Needs
    1. 7. The Challenge of Requirements Elicitation
      1. Barriers to Elicitation
        1. The "Yes, But" Syndrome
        2. The "Undiscovered Ruins" Syndrome
        3. The "User and the Developer" Syndrome
      2. Techniques for Requirements Elicitation
    2. 8. The Features of a Product or System
      1. Stakeholder and User Needs
      2. Features
        1. Managing Complexity by Picking the Level of Abstraction
        2. Attributes of Product Features
    3. 9. Interviewing
      1. The Interview Context
        1. The Context-Free Question
      2. Value-Added Context
      3. The Moment of Truth: The Interview
      4. Compiling the Need Data
        1. The Analyst's Summary: 10 + 10 + 10 ≠ 30
        2. The Case Study
      5. A Note on Questionnaires
    4. 10. Requirements Workshops
      1. Accelerating the Decision Process
      2. Preparing for the Workshop
        1. Selling the Concept
        2. Ensuring the Participation of the Right Stakeholders
        3. Logistics
        4. "Warm-Up Materials"
      3. Role of the Facilitator
      4. Setting the Agenda
      5. Running the Workshop
        1. Problems and Tricks of the Trade
        2. Brainstorming and Idea Reduction
        3. Production and Follow-Up
    5. 11. Brainstorming and Idea Reduction
      1. Live Brainstorming
      2. Idea Reduction
        1. Pruning
        2. Grouping Ideas
        3. Feature Definition
        4. Prioritization
      3. Web-Based Brainstorming
      4. The Case Study: The HOLIS 2000 Requirements Workshop
        1. Attendees
        2. The Workshop
        3. The Session
        4. Analysis of Results
    6. 12. Storyboarding
      1. Types of Storyboards
      2. What Storyboards Do
      3. Tools and Techniques for Storyboarding
      4. Tips for Storyboarding
      5. Summary
    7. 13. Applying Use Cases
      1. Building the Use-Case Model
      2. Applying Use Cases to Requirements Elicitation
      3. Case Study: The Use Cases for HOLIS
      4. Summary
    8. 14. Role Playing
      1. How to Role Play
      2. Techniques Similar to Role Playing
        1. Scripted Walkthroughs
        2. CRC (Class-Responsibility-Collaboration) Cards
      3. Summary
    9. 15. Prototyping
      1. Types of Prototypes
      2. Requirements Prototypes
      3. What to Prototype
      4. Building the Prototype
      5. Evaluating the Results
      6. Summary
      7. Team Skill 2 Summary
  7. 3. Defining the System
    1. 16. Organizing Requirements Information
      1. Organizing Requirements of Complex Hardware and Software Systems
      2. Organizing Requirements for Product Families
      3. On "Future" Requirements
      4. Business and Marketing Requirements versus Product Requirements
      5. The Case Study
      6. Summary
    2. 17. The Vision Document
      1. Components of the Vision Document
      2. The "Delta Vision" Document
        1. Vision Document for Release 1.0
        2. Vision Document for Version 2.0
        3. The Delta Vision Document in a Legacy System Environment
    3. 18. The Champion
      1. The Role of the Product Champion
      2. The Product Champion in a Software Product Environment
      3. The Product Champion in an IS/IT Shop
      4. Team Skill 3 Summary
  8. 4. Managing Scope
    1. 19. The Problem of Project Scope
      1. Components of Project Scope
      2. The Hard Question
    2. 20. Establishing Project Scope
      1. The Requirements Baseline
      2. Setting Priorities
      3. Assessing Effort
      4. Adding the Risk Element
      5. Reducing Scope
        1. A Reasonable First Estimate
      6. The Case Study
    3. 21. Managing Your Customer
      1. Engaging Customers to Manage Their Project Scope
      2. Communicating the Result
      3. Negotiating with the Customer
      4. Managing the Baseline
        1. Official Change
        2. Unofficial Change
    4. 22. Scope Management and Software Development Process Models
      1. The Waterfall Model
      2. The Spiral Model
      3. The Iterative Approach
        1. Lifecycle Phases
        2. Iterations
        3. Workflows
      4. What to Do, What to Do …
      5. Team Skill 4 Summary
  9. 5. Refining the System Definition
    1. 23. Software Requirements
      1. Definition of Software Requirements
      2. Relationship between Features and Software Requirements
      3. The Requirements Dilemma: What versus How
        1. Exclude Project Information
        2. Exclude Design Information
      4. More on Requirements versus Design
        1. Iterating Requirements and Design
      5. A Further Characterization of Requirements
        1. Functional Software Requirements
        2. Nonfunctional Software Requirements
        3. Design Constraints
        4. Are Design Constraints True Requirements?
      6. Using Parent-Child Requirements to Increase Specificity
        1. Organizing Parent-Child Requirements
      7. Looking Ahead
    2. 24. Refining the Use Cases
      1. Questions to Ask
        1. When Should I Use the Use-Case Methodology?
        2. When Are Use Cases Not the Best Choice?
        3. The Redundancy Problem
      2. Refining Use-Case Specifications
        1. How Use Cases Evolve
        2. The Scope of a Use Case
      3. The Case Study: Anatomy of a Simple Use Case
        1. Define the Actor(s)
        2. Define the Use Case by Naming It
        3. Write a Brief Description
        4. Define a Flow of Events
        5. Identify Pre- and Postconditions
      4. Looking Ahead
    3. 25. A Modern Software Requirements Specification
      1. The Modern SRS Package
        1. Who Owns the SRS Package?
        2. Organizing the Modern SRS Package
      2. Documenting Functional Requirements
      3. Looking Ahead
    4. 26. On Ambiguity and Specificity
      1. Finding the "Sweet Spot"
      2. Mary Had a Little Lamb
      3. Techniques for Disambiguation
      4. What to Do?
    5. 27. Quality Measures of Software Requirements
      1. Nine Quality Measures
        1. Correct Requirements
        2. Unambiguous Requirements
        3. Completeness of the Requirements Set
        4. Consistency in the Requirements Set
        5. Requirements Ranked for Importance and Stability
        6. Verifiable Requirement
        7. Modifiable Requirements Set
        8. Traceable Requirements
        9. Understandable Requirements
      2. Quality Measures for the Use-Case Model
        1. Use-Case Specifications
        2. Use-Case Actors
      3. Quality Measures of the Modern SRS Package
        1. A Good Table of Contents
        2. A Good Index
        3. A Revision History
        4. A Glossary
    6. 28. Technical Methods for Specifying Requirements
      1. Pseudocode
      2. Finite State Machines
      3. Decision Trees and Decision Tables
      4. Graphical Decision Trees
      5. Activity Diagrams
      6. Entity-Relationship Models
      7. Object-Oriented Modeling
      8. Data Flow Diagrams
      9. Maintenance of Specifications
      10. Case Study
      11. Team Skill 5 Summary
  10. 6. Building the Right System
    1. 29. Building the Right System Right: Overview
      1. Continually Confirm that the Development Is on Track
        1. Principles of Software Verification
        2. The Cost of Verification
        3. Verification at All Levels
        4. The Reason for Verification
      2. Confirm that the Development Results Are Correct
      3. Learn How to Cope with Change that Occurs during the Development Process
      4. Looking Ahead
    2. 30. From Requirements to Implementation
      1. Mapping Requirements to Design and Code
        1. The Orthogonality Problem
        2. Object Orientation
        3. The Use Case as a Requirement
        4. Managing the Transition
        5. Modeling Software Systems
        6. Role of the Use-Case Model in Architecture
      2. Realizing Use Cases in the Design Model
        1. Structural and Behavioral Aspects of Collaborations
        2. Using Collaborations to Realize Sets of Individual Requirements
      3. From Design to Implementation
      4. Summary
      5. Looking Ahead
    3. 31. Using Traceability to Support Verification
      1. The Role of Traceability in Requirements Verification
        1. Implicit versus Explicit Traceability
        2. Additional Traceability Options to Consider
      2. Using Traceability Tools
        1. Maintenance of Traceability Relationships
      3. Proceeding without Traceability Tools
        1. Omitted Verification Relationships
        2. Excess Verification Relationships
      4. Thinking about Verification and Traceability
      5. Looking Ahead
    4. 32. Validating the System
      1. Validation
        1. Acceptance Tests
        2. Validation Testing
        3. Validation Traceability
        4. Requirements-Based Testing
      2. Case Study: Testing Use Cases
        1. Test Case 1 Description
        2. Tracing Test Cases
      3. Testing Discrete Requirements
        1. Omitted Validation Relationships
        2. Excess Validation Relationships
      4. Testing Design Constraints
      5. Looking Ahead
    5. 33. Using ROI to Determine the V&V Effort
      1. Depth versus Coverage
        1. V&V Depth
        2. V&V Coverage
      2. What to Verify and Validate
        1. Option 1: Verify and Validate Everything
        2. Option 2: Use a Hazard Analysis to Determine V&V Necessities
        3. Hazard Analysis as Return on Investment (ROI)
      3. Looking Ahead
    6. 34. Managing Change
      1. Why Do Requirements Change?
        1. External Factors
        2. Internal Factors
      2. "We Have Met the Enemy, and They Is Us"
      3. A Process for Managing Change
        1. Step 1: Recognize that Change Is Inevitable, and Plan for It
        2. Step 2: Baseline the Requirements
        3. Step 3: Establish a Single Channel to Control Change
        4. Step 4: Use a Change Control System to Capture Changes
        5. Step 5: Manage Change Hierarchically
      4. Requirements Configuration Management
        1. Tool-Based Support for Change Management
        2. Elements Impacted by Change
        3. Audit Trail of Change History
        4. Configuration Management and Change Management
      5. Summary
      6. Team Skill 6 Summary
    7. 35. Getting Started
      1. Dedication
      2. What We've Learned So Far
        1. Introduction
        2. Team Skill 1: Analyzing the Problem
        3. Team Skill 2: Understanding User Needs
        4. Team Skill 3: Defining the System
        5. Team Skill 4: Managing Scope
        6. Team Skill 5: Refining the System Definition
        7. Team Skill 6: Building the Right System
      3. Your Prescription for Requirements Management
        1. Simplifying Assumptions
        2. The Recipe
      4. Now, On to the Next Release!
  11. A. HOLIS Artifacts
    1. Background of the Case Study
      1. Lumenations, Ltd.
      2. The HOLIS Software Development Team
    2. Team Skill 1: Analyzing the Problem
      1. Lumenations Problem Statement
      2. System Block Diagram with Actors Identified
      3. Actor Survey
      4. Stakeholder Survey
      5. Constraints to Be Imposed on the Solution
    3. Team Skill 2: Understanding User Needs
      1. Summary of User Needs as Collected from Interviews
      2. The Case Study: The HOLIS 2000 Requirements Workshop
      3. HOLIS System-Level Use-Case Model Survey
    4. Team Skill 3: Defining the System
      1. HOLIS Requirements Organization
      2. HOLIS Vision Document
    5. Team Skill 4: Managing Scope
    6. Team Skill 5: Refining the System Definition
      1. HOLIS Sample Use Case: Control Light
      2. HOLIS Central Control Unit Software Requirements Specification
    7. Team Skill 6: Building the Right System
      1. HOLIS 2000 Sample Test Case 01: Test Control Light
      2. HOLIS 2000 Sample Test Case 02: Test Round-Trip Message Protocol
  12. B. Vision Document Template
    1. Table of Contents
  13. C. Modern SRS Package Template
  14. D. Requirements Management in the SEI-CMM and within ISO 9000
    1. Requirements Management in SEI-CMM
    2. Requirements Management in ISO 9000
  15. E. Requirements Management in the Rational Unified Process
    1. Structure of the Rational Unified Process
    2. Requirements Management in the Rational Unified Process
      1. Analyze the Problem
      2. Understand Stakeholders' Needs
      3. Define the System
      4. Manage the Scope of the System
      5. Refine the System Definition
      6. Manage Changing Requirements
    3. Process Integration
  16. Bibliography

Product information

  • Title: Managing Software Requirements: A Unified Approach
  • Author(s):
  • Release date: October 1999
  • Publisher(s): Addison-Wesley Professional
  • ISBN: 9780201615937