Managing Software Requirements
Addison Wesley (Verlag)
978-0-201-61593-7 (ISBN)
- Titel erscheint in neuer Auflage
- Artikel merken
"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. 0201615932B04062001
Dean Leffingwell, software business development consultant and former Rational Software executive, is a recognized authority on software requirements. He was cofounder and chief executive officer of Requisite, Inc., where he developed RequisitePro, the highly successful requirements management software tool, and Requirements College, the basis of Rational's popular requirements management professional development course series. Don Widrig is an independent technical writer and consultant. He developed and delivered Rational Software's RequisitePro Tool Training Course until his "retirement" to the mountains of Colorado in 1997. When he is not busy watching the elk in his yard, Don writes a regular column for his local newspaper and does pro bono work helping the townspeople deal with their computers. He was formerly the vice president of research and development at RELA, Inc., a producer of safety-critical, real-time systems. 0201615932AB05082003
Foreword.
Preface.
Introduction.
Chapter 1. The Requirements Problem.
The Goal.
A Look at the Data.
Root Causes of Project Success and Failure.
The Frequency of Requirements Errors.
The High Cost of Requirements Errors.
Conclusion.
2. Introduction to Requirements Management.
Definitions.
What Is Requirements Management?
Application of Requirements Management Techniques.
Systems Applications.
The Road Map.
The Problem Domain.
Stakeholder Needs.
Moving Toward the Solution Domain.
Features of the System.
Software Requirements.
An Introduction to Use Cases.
Summary.
3. The Software Team.
Software Development as a Team Activity.
Requisite Team Skills for Effective Requirements Management.
Team Members Have Different Skills.
The Organization of Software Teams.
The Case Study.
Background for the Case Study.
The HOLIS Software Development Team.
Summary.
I. ANALYZING THE PROBLEM.
4. The Five Steps in Problem Analysis.
Step 1: Gain Agreement on the Problem Definition.
The Problem Statement.
Step 2: Understand the Root Causes--The Problem Behind the Problem.
Addressing the Root Cause.
Step 3: Identify the Stakeholders and the Users.
Step 4: Define the Solution System Boundary.
Step 5: Identify the Constraints to Be Imposed on the Solution.
Summary.
Looking Ahead.
5. Business Modeling.
Purpose of Business Modeling.
Using Software Engineering Techniques for Business Modeling.
Choosing the Right Technique.
The Unified Modeling Language (UML).
Business Modeling Using UML Concepts.
From The Business Models to the Systems Model.
When To Use Business Modeling.
Summary.
Looking Ahead.
6. Systems Engineering of Software Intensive Systems.
What Is Systems Engineering?
Pragmatic Principles of Systems Engineering.
The Composition and Decomposition of Complex Systems.
Requirements Allocation in Systems Engineering.
On Derived Requirements.
A Quiet Revolution.
When Generations Collide: Graybeard Meets Young Whippersnapper.
Avoiding the Stovepipe System Problem.
When Subsystems Are Subcontracts.
Making It Work Out Right.
The Case Study.
Preliminary User Needs.
Problem Analysis.
HOLIS: The System, Actors, and Stakeholders.
HOLIS Systems Engineering.
The Subsystems of HOLIS.
II. UNDERSTANDING USER NEEDS.
7. The Challenge of Requirements Elicitation.
Barriers to Elicitation.
The "Undiscovered Ruins" Syndrome.
The "User and the Developer" Syndrome.
Techniques for Requirements Elicitation.
8. The Features of a Product or System.
Stakeholder and User Needs.
Features.
Managing Complexity by Picking the Level of Abstraction.
Attributes of Product Features.
9. Interviewing.
The Interview Context.
Value-Added Context.
The Moment of Truth: The Interview.
Compiling the Need Data.
The Analyst's Summary: 10+10+10 _ 30.
The Case Study.
A Note on Questionnaires.
10. Requirements Workshops.
Preparing for the Workshop.
Selling the Concept.
Ensuring the Participation of the Right Stakeholders.
Logistics.
"Warm-Up Materials".
Role of the Facilitator.
Setting the Agenda.
Running the Workshop.
Brainstorming and Idea Reduction.
Production and Follow-Up.
11. Brainstorming and Idea Reduction.
Live Brainstorming.
Idea Reduction.
Pruning.
Grouping Ideas.
Feature Definition.
Prioritization.
Web-Based Brainstorming.
The Case Study: The HOLIS 2000 Requirements Workshop.
Attendees.
The Workshop.
The Session.
Analysis of Results.
12. Storyboarding.
Types of Storyboards.
What Storyboards Do.
Tools and Techniques for Storyboarding.
Tips for Storyboarding.
Summary.
13. Applying Use Cases.
Building the Use Case Model.
Applying Use Cases to Requirements Elicitation.
Case Study: The Use Cases for HOLIS.
Summary.
14. Role Playing.
How to Role Play.
Techniques Similar to Role Playing.
Scripted Walkthroughs.
CRC (Class-Responsibility-Collaboration) Cards.
Summary.
15. Prototyping.
Types of Prototypes.
Requirements Prototypes.
What to Prototype.
Building the Prototype.
Evaluating the Results.
Summary.
III. DEFINING THE SYSTEM.
16. Organizing Requirements Information.
Organizing Requirements of Complex Hardware and Software Systems.
Organizing Requirements for Product Families.
On "Future" Requirements.
Business and Marketing Requirements versus Product Requirements.
The Case Study.
Summary.
17. The Vision Document.
Components of the Vision Document.
The "Delta Vision" Document.
Vision Document for Release 1.0.
Vision Document for Version 2.0.
The Delta Vision Document in a Legacy System Environment.
18. The Champion.
The Role of the Product Champion.
The Product Champion in a Software Product Environment.
The Product Champion in an IS/IT Shop.
IV. MANAGING SCOPE.
19. The Problem of Project Scope.
Components of Project Scope.
The Hard Question.
20. Establishing Project Scope.
Setting Priorities.
Assessing Effort.
Adding the Risk Element.
Reducing Scope.
A Reasonable First Estimate.
The Case Study.
21. Managing Your Customer.
Engaging Customers to Manage their Project Scope.
Communicating the Result.
Negotiating with the Customer.
Managing the Baseline.
Official Change.
Unofficial Change.
22. Scope Management and Software Development Process Models.
The Waterfall Model.
The Spiral Model.
The Iterative Approach.
Life Cycle Phases.
Iterations.
Work Flows.
What to Do, What to Do....
V. REFINING THE SYSTEM DEFINITION.
23. Software Requirements.
Definition of Software Requirements.
Relationship Between Features and Software Requirements.
The Requirements Dilemma: What versus How.
Exclude Project Information.
Exclude Design Information.
More on Requirements versus Design.
Iterating Requirements and Design.
A Further Characterization of Requirements.
Functional Software Requirements.
Nonfunctional Software Requirements.
Design constraints.
Are Design Constraints True Requirements?
Using Parent-Child Requirements to Increase Specificity.
Organizing Parent-child Requirements.
Looking Ahead.
24. Refining the Use Cases.
Questions to Ask.
When Are Use Cases Not the Best Choice?
Is Redundancy a problem?
Refining Use Case Specifications.
How Use Cases Evolve.
The Scope of a Use Case.
The Case Study: Anatomy of a Simple Use Case.
Define the Actor(s).
Define the Use Case by Naming It.
Write a Brief Description.
Define a Flow of Events.
Identify Pre- and Postconditions.
Looking Ahead.
25. A Modern Software Requirements Specification.
The Modern SRS Package.
Who Owns the SRS Package?
Organizing the Modern SRS Package.
Documenting Functional Requirements.
Looking Ahead.
26. On Ambiguity and Specificity.
Mary Had A Little Lamb.
Techniques for Disambiguation.
What to Do?
27. Quality Measures of Software Requirements.
Nine Quality Measures.
Correct Requirements.
Unambiguous Requirements.
Completeness of the Requirement Set.
Consistency in the Requirement Set.
Requirements Ranked for Importance and Stability.
Verifiable Requirement.
Modifiable Requirements Set.
Traceable Requirements.
Understandable Requirements.
Quality Measures for the Use-Case Model.
Use Case Specifications.
Use Case Actors.
Quality Measures of the Modern SRS Package.
A Good Table of Contents.
A Good Index.
A Revision History.
A Glossary.
28. Technical Methods for Specifying Requirements.
Pseudocode.
Finite State Machines.
Decision Trees and Decision Tables.
Graphical Decision Trees.
Activity Diagrams.
Entity-Relationship Models.
Object-Oriented Modeling.
Data Flow Diagrams.
Maintenance of Specifications.
VI. Building the Right System.
29. Building the Right System Right: Overview.
Continually Confirm that the Development Is on Track.
Principles of Software Verification.
The Cost of Verification.
Verification at All Levels.
The Reason for Verification.
Confirm that the Development Results Are Correct.
Learn How to Cope with Change that Occurs During the Development Process.
Looking Ahead.
30. From Requirements to Implementation.
Mapping Requirements to Design and Code.
The Orthogonality Problem.
Object Orientation.
The Use Case as Requirement.
Managing the Transition.
Modeling Software Systems.
Role of the Use-Case Model in Architecture.
Realizing Use Cases in the Design Model.
Structural and Behavioral Aspects of Collaborations.
Using Collaborations to Realize Sets of Individual Requirements.
From Design to Implementation.
Summary.
Looking Ahead.
31. Using Traceability to Support Verification.
The Role of Traceability in Requirements Verification.
Implicit versus Explicit Traceability.
Additional Traceability Options to Consider.
Using Traceability Tools.
Maintenance of Traceability Relationships.
Proceeding without Traceability Tools.
Omitted Verification Relationships.
Excess Verification Relationships.
Thinking About Verification and Traceability.
Looking Ahead.
32. Validating the System.
Validation.
Validation Testing.
Validation Traceability.
Requirements-based Testing.
Case Study: Testing Use Cases.
Test Case 1 Description.
Tracing Test Cases.
Testing Discrete Requirements.
Omitted Validation Relationships.
Excess Validation Relationships.
Testing Design Constraints.
Looking Ahead.
33. Using ROI to Determine the V&V Effort.
Depth versus Coverage.
V&V Coverage.
What to Verify and Validate.
Option 1: Verify and Validate Everything.
Option 2: Use a Hazard Analysis to Determine V&V Necessities.
Hazard Analysis as Return On Investment (ROI).
Looking Ahead.
34. Managing Change.
External Factors.
Internal Factors.
"We Have Met the Enemy, and They Is Us".
A Process for Managing Change.
Step 1: Recognize that Change Is Inevitable, and Plan for It.
Step 2: Baseline the Requirements.
Step 3: Establish A Single Channel to Control Change.
Step 4: Use a Change Control System to Capture Changes.
Step 5: Manage Change Hierarchically.
Requirements Configuration Management.
Tool-based Support for Change Management.
Elements Impacted by Change.
Audit Trail of Change History.
Configuration Management and Change Management.
Summary.
35. Getting Started.
Dedication.
What We've Learned So Far.
Introduction.
Team Skill 1: Analyzing the Problem.
Team Skill 2: Understanding User Needs.
Team Skill 3: Defining the System.
Team Skill 4: Managing Scope.
Team Skill 5: Refining the System Definition.
Team Skill 6: Building the Right System.
Your Prescription for Requirements Management.
Simplifying Assumptions.
The Recipe.
Now, On To the Next Release!
Appendix A.
Appendix B.
Appendix C.
Appendix D.
Appendix E.
Bibliography.
Index. 0201615932T04062001
| Erscheint lt. Verlag | 25.11.1999 |
|---|---|
| Verlagsort | Boston |
| Sprache | englisch |
| Maße | 191 x 241 mm |
| Gewicht | 976 g |
| Themenwelt | Informatik ► Software Entwicklung ► Objektorientierung |
| ISBN-10 | 0-201-61593-2 / 0201615932 |
| ISBN-13 | 978-0-201-61593-7 / 9780201615937 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
aus dem Bereich
