You are previewing Managing Software Requirements: A Use Case Approach, Second Edition.
O'Reilly logo
Managing Software Requirements: A Use Case Approach, Second Edition

Book Description

"Many projects fail because developers fail to build the right thing. Developers of any kind of application should read this book."—Grady Booch

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

Despite the wealth of development knowledge, experience, and tools available today, a substantial percentage of software projects fail, often because requirements are not correctly determined and defined at the outset, or are not managed correctly as the project unfolds. This second edition of the popular text 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.

Using an accessible style, their own war stories, and a comprehensive case study, the authors show how analysts and developers can effectively identify requirements by applying a variety of techniques, centered on the power of use cases. The book illustrates proven techniques for determining, implementing, 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, Second Edition, 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 customers and stakeholders

  • Establishing and managing project scope

  • Applying and refining use cases

  • Product management

  • Transitioning from requirements to design and implementation

  • Transitioning from use cases to test cases

  • Agile requirements methods



  • 032112247XB05082003

    Table of Contents

    1. Copyright
      1. Dedication
    2. The Addison-Wesley Object Technology Series
    3. The Component Software Series
    4. Foreword
      1. The Rock Problem
        1. A Simple Metaphor: Building a House
      2. About This Book
    5. Preface to the Second Edition
      1. About the Second Edition
      2. Acknowledgments
    6. Preface to the First Edition
      1. Context
      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
    7. Introduction
      1. 1. The Requirements Problem
        1. The Goal of Software Development
        2. A Look at the Data
        3. The Root Causes of Project Success and Failure
          1. The Frequency of Requirements Errors
          2. The High Cost of Requirements Errors
        4. Summary
      2. 2. Introduction to Requirements Management
        1. Definitions
          1. What Is a Software 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
        4. Summary
      3. 3. Requirements and the Software Lifecycle
        1. Traditional Software Process Models
          1. The Waterfall Model
          2. The Spiral Model
        2. The Iterative Approach
          1. Lifecycle Phases
          2. Iterations
          3. Disciplines
        3. Requirements in the Iterative Model
        4. Summary
      4. 4. 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
    8. 1. Analyzing the Problem
      1. 5. 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. 6. Business Modeling
        1. The Purpose of Business Modeling
        2. Using Software Engineering Techniques for Business Modeling
          1. Choosing the Right Technique
          2. The Unified Modeling Language
          3. Business Modeling Using UML Concepts
        3. From the Business Model to the Systems Model
        4. When to Use Business Modeling
        5. Summary
        6. Looking Ahead
      3. 7. 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: Graying Baby Boomer Meets Generation X-er
          4. Avoiding the Stovepipe System Problem
          5. When Subsystems Are Subcontracts
          6. Addressing the Conundrum
        3. The Case Study: Systems Engineering for HOLIS
          1. Preliminary User Needs
          2. Problem Analysis
          3. HOLIS: The System, Actors, and Stakeholders
          4. HOLIS Systems Engineering
          5. The Subsystems of HOLIS
        4. Summary
      4. Team Skill 1 Summary
    9. 2. Understanding User and Stakeholder Needs
      1. 8. 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. Summary
      2. 9. 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. Summary
      3. 10. Interviewing
        1. Context-Free Questions
        2. Solutions-Context Questions
        3. The Moment of Truth: The Interview
        4. Compiling the Needs Data
          1. The Analyst's Summary: 10 + 10 + 10 ≠ 30
          2. The Case Study
        5. A Note on Questionnaires
        6. Summary
      4. 11. 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. Attending to Logistics
          4. Providing Warm-Up Materials
          5. Choosing the Facilitator
        3. Setting the Agenda
        4. Running the Workshop
          1. Problems and Tricks of the Trade
          2. Brainstorming and Idea Reduction
          3. Production and Follow-Up
        5. Summary
      5. 12. Brainstorming and Idea Reduction
        1. Live Brainstorming
        2. Idea Reduction
          1. Pruning Ideas
          2. Grouping Ideas
          3. Defining Features
          4. Prioritizing Ideas
            1. Cumulative Voting: The Hundred-Dollar Test
            2. “Critical, Important, Useful” Categorization
        3. Web-Based Brainstorming
        4. The Case Study: The HOLIS Requirements Workshop
          1. The Attendees
          2. The Workshop
          3. The Session
          4. The Analysis of Results
        5. Summary
      6. 13. Storyboarding
        1. Types of Storyboards
        2. What Storyboards Do
        3. Tools for Storyboarding
        4. Tips for Storyboarding
        5. Summary
      7. Team Skill 2 Summary
    10. 3. Defining the System
      1. 14. A Use Case Primer
        1. The Benefits of Use Cases
        2. Use Case Basics
          1. On Actors
          2. Use Case Anatomy
        3. A Step-by-Step Guide to Building the Use-Case Model
          1. Step 1: Identify and Describe the Actors
          2. Step 2: Identify the Use Cases and Write a Brief Description
          3. Step 3: Identify the Actor and Use-Case Relationships
          4. Step 4: Outline the Individual Use Cases
          5. Step 5: Refine the Use Cases
        4. On Use Cases, Storyboarding, and User Interface Design
          1. Use Cases and User Interfaces
          2. Use Cases and Storyboarding
          3. A Use Case Storyboard Example
        5. The Case Study: The HOLIS Use Cases
          1. Find the HOLIS Actors
          2. Find the HOLIS Use Cases
          3. Associate the Actors and Use Cases
          4. Outline the Use Cases
        6. Summary
      2. 15. Organizing Requirements Information
        1. Organizing Requirements of Complex Hardware and Software Systems
        2. Organizing Requirements for Product Families
        3. On “Future” Requirements
        4. The Case Study: Organizing the HOLIS Requirements
        5. Summary
        6. Looking Ahead
      3. 16. The Vision Document
        1. Components of the Vision Document
        2. The Delta Vision Document
          1. The Vision Document for Version 1.0
          2. The Vision Document for Version 2.0
          3. The Delta Vision Document in a Legacy System Environment
        3. Summary
      4. 17. Product Management
        1. The Role of the Product Champion
        2. The Product Manager in a Software Product Company
        3. Primary Activities for a Product Manager
          1. Driving the Vision
          2. Maintaining the Product Road Map
          3. Defining the Whole Product Plan
          4. Sponsoring the Use-Case Model and Supplementary Requirements
          5. Testing the Product Concept
          6. Completing the User Experience
          7. Defining Commercial Terms
          8. Positioning and Messaging
        4. Supporting Activities
          1. Branding and Product Labeling
          2. End User Training Materials
          3. Product Demo
          4. Sales and Marketing Collateral
        5. The Product Champion in an IS/IT Shop
        6. Summary
      5. Team Skill 3 Summary
    11. 4. Managing Scope
      1. 18. Establishing Project Scope
        1. The Problem of Project Scope
        2. The Hard Question
        3. The Requirements Baseline
        4. Setting Priorities
        5. Assessing Effort
        6. Adding the Risk Element
        7. Reducing Scope
          1. A Reasonable First Estimate
        8. The Case Study: Scope Management for HOLIS
        9. Summary
      2. 19. 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 Changes
          2. Unofficial Changes
        5. Summary
      3. Team Skill 4 Summary
    12. 5. Refining the System Definition
      1. 20. Software Requirements—A More Rigorous Look
        1. Looking Deeper into Software Requirements
          1. The Relationship between Software Requirements and Use Cases
          2. The Relationship between Features and Software Requirements
        2. The Requirements Dilemma: What versus How
          1. Excluding Project Information
          2. Excluding Design Information
        3. More on Requirements versus Design
          1. Iterating Requirements and Design
        4. A Further Characterization of Requirements
          1. Functional Software Requirements
          2. Nonfunctional Software Requirements
          3. Design Constraints
        5. Summary
        6. Looking Ahead
      2. 21. Refining the Use Cases
        1. How Use Cases Evolve
        2. The Scope of a Use Case
        3. The Case Study: Anatomy of a Simple Use Case
          1. Reviewing the Actors
          2. Reviewing the Name
          3. Refining the Description
          4. Defining and Refining the Flow of Events
          5. Identifying the Pre- and Post-conditions
          6. Identifying Special Requirements
          7. Summary of Our Refined Use Case
        4. Extending Use Cases
        5. Including Use Cases in Other Use Cases
        6. Summary
        7. Looking Ahead
      3. 22. Developing the Supplementary Specification
        1. The Role of the Supplementary Specification
        2. Expressing Functional Requirements in the Supplementary Specification
        3. Exploring Nonfunctional Requirements
          1. Usability
          2. Reliability
          3. Performance
          4. Supportability
        4. Understanding Design Constraints
          1. Sources of Design Constraints
            1. Restriction of Design Options
            2. Conditions Imposed on the Development Process
            3. Regulations and Imposed Standards
          2. Handling Design Constraints
          3. Are Design Constraints True Requirements?
        5. Identifying Other Requirements
        6. Linking the Supplementary Specification to the Use Cases
        7. Template for the Supplementary Specification
        8. Summary
        9. Looking Ahead
      4. 23. On Ambiguity and Specificity
        1. Finding the “Sweet Spot”
          1. Mary Had a Little Lamb
        2. Techniques for Disambiguation
        3. Summary
      5. 24. Technical Methods for Specifying Requirements
        1. Pseudocode
        2. Finite State Machines
        3. Decision Tables and Decision Trees
        4. Activity Diagrams
        5. Entity-Relationship Models
        6. Summary
      6. Team Skill 5 Summary
    13. 6. Building the Right System
      1. 25. From Use Cases to Implementation
        1. Mapping Requirements Directly 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. The Architecture of Software Systems
            1. The “4+1” View of Architecture
          7. The 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
      2. 26. From Use Cases to Test Cases
        1. A Tester's Perspective: Musings on the Big Black Box
        2. Is a Use Case a Test Case?
        3. Common Testing Terms
        4. Relationships of Test Artifacts
        5. The Role of the Test Cases
        6. Use-Case Scenarios
        7. Deriving Test Cases from Use Cases: A Four-Step Process
          1. Step 1: Identify the Use-Case Scenarios
          2. Step 2: Identify the Test Cases
          3. Step 3: Identify the Test Conditions
          4. Step 4: Add Data Values to Complete the Test Case
        8. Managing Test Coverage
        9. Black-Box versus White-Box Testing with Use Cases
        10. Summary
      3. 27. Tracing Requirements
        1. The Role of Traceability in Systems Development
        2. The Traceability Relationship
        3. A Generalized Traceability Model
          1. Tracing Requirements in the System Definition Domain
            1. Tracing User Needs to Features
            2. Tracing Features to Use Cases
            3. Tracing Features to Supplementary Requirements
          2. Tracing Requirements to Implementation
            1. Tracing Use Cases to Use-Case Realizations
            2. Tracing from the Use-Case Realization into Implementation
            3. Tracing Supplementary Requirements into Implementation
          3. Tracing from Requirements to Testing
            1. Tracing from Use Case to Test Case
            2. Tracing from Supplementary Requirements to Test Cases
        4. Using Traceability Tools
        5. Proceeding without Traceability Tools
        6. Summary
      4. 28. 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. Looking Ahead
      5. 29. Assessing Requirements Quality in Iterative Development
        1. Software Project Quality
        2. Assessing Quality in Iterative Development
        3. Requirements Artifacts Sets
        4. Performing the Assessment
        5. Quality Assessment Checklists for Requirements
        6. Summary
      6. Team Skill 6 Summary
        1. Looking Ahead
      7. Getting Started
        1. Dedication
        2. What You've Learned So Far
          1. Introduction
          2. Team Skill 1: Analyzing the Problem
          3. Team Skill 2: Understanding User and Stakeholder 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
      8. 30. Agile Requirements Methods
        1. Mitigating Requirements Risk with Effective Requirements Practices
        2. Methodology Design Goals
          1. Principle 1: Interactive, Face-to-Face Communication Is the Cheapest and Fastest Channel for Exchanging Information
          2. Principle 2: Excess Methodology Weight Is Costly
          3. Principle 3: Larger Teams Need Heavier Methodologies
          4. Principle 4: Greater Ceremony Is Appropriate for Projects with Greater Criticality
        3. Documentation Is a Means to an End
        4. An Extreme Requirements Method
        5. An Agile Requirements Method
        6. A Robust Requirements Method
        7. Summary
      9. 31. Your Prescription for Requirements Management
        1. Selecting Your Requirements Approach
          1. The Simplifying Assumptions
          2. The Prescription
            1. Step 1: Get Organized
            2. Step 2: Understand the Problem Being Solved
            3. Step 3: Understand User and Stakeholder Needs
            4. Step 4: Define the System
            5. Step 5: Continuously Manage Scope and Manage Change
            6. Step 6: Refine the System Definition
            7. Step 7: Build the Right System
            8. Step 8: Manage the Requirements Process
            9. Step 9: Congratulations! You've Shipped a Product!
        2. On to the Next Release!
    14. Appendixes
      1. A. HOLIS Artifacts
        1. Background for 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 Imposed on the Solution
        3. Team Skill 2: Understanding User and Stakeholder Needs
          1. Summary of User Needs as Collected from Interviews
          2. The Requirements Workshop
            1. The Workshop
            2. The Session
            3. The Analysis of Results
          3. HOLIS System-Level Use-Case Model Survey
        4. Team Skill 3: Defining the System
          1. HOLIS Requirements Organization
          2. HOLIS Vision Document
          3. Lumenations, Ltd.
          4. HOLIS Vision Document
          5. © 2002 Lumenations, Ltd. 102872 Cambridge Ave. Marcy, NJ 12345
        5. Team Skill 4: Managing Scope
        6. Team Skill 5: Refining the System Definition
          1. HOLIS Sample Use Case: Control Light
            1. Brief Description
            2. Basic Flow
            3. Alternative Flow of Events
            4. Pre-conditions for Control Light Use Case
            5. Post-condition for Control Light Use Case
            6. Extension Points
            7. Special Requirements
          2. HOLIS Central Control Unit Supplementary Specification
        7. Team Skill 6: Building the Right System
          1. HOLIS Sample Test Case 01: Test Control Light
            1. Description
          2. HOLIS Sample Test Case 02: Test Round-Trip Message Protocol
            1. Description
            2. Events
      2. B. Vision Document Template
        1. Table of Contents
      3. C. Use-Case Specification Template
        1. Table of Contents
        2. Use-Case Name
          1. Brief Description
          2. System or SubSystem
          3. Flow of Events
            1. Basic Flow
            2. Alternative Flows
            3. Special Requirements
            4. Pre-conditions
            5. Post-conditions
            6. Extension Points
      4. D. Supplementary Specification Template
        1. Table of Contents
      5. E. Requirements Management in the Rational Unified Process
        1. The Structure of the Rational Unified Process
        2. Requirements Management in the Rational Unified Process
          1. Analyzing the Problem
          2. Understanding User and Stakeholder Needs
          3. Defining the System
          4. Managing Scope
          5. Refining the System Definition
          6. Managing Changing Requirements
        3. Process Integration
      6. F. Requirements Management in the SEI-CMM and within ISO 9000:2000
        1. Requirements Management in the SEI-CMM
        2. Requirements Management in ISO 9000:2000
    15. Bibliography