You are previewing Executable Specifications with Scrum: A Practical Guide to Agile Requirements Discovery.
O'Reilly logo
Executable Specifications with Scrum: A Practical Guide to Agile Requirements Discovery

Book Description

Most books about specifications still assume that requirements can be known up front and won’t change much during your project. In today’s “real world,” however, you must specify and build software in the face of high and continuing uncertainty. Scrum and other agile methods have evolved to reflect this reality. Now, there’s a complete guide to specifying software in agile environments when prerequisites are unclear, requirements are difficult to grasp, and anything about your project could change.

Long-time agile coach and enterprise architect Mario Cardinal shows how to create executable specifications and use them to test software behavior against requirements. Cardinal shows how to trawl requirements incrementally, step-by-step, using a vision-centric and emergent iterative practice that is designed for agility. Writing for analysts, architects, developers, and managers, Cardinal makes a strong case for the iterative discovery of requirements. Then, he moves from theory to practice, fully explaining the technical mechanisms and empirical techniques you need to gain full value from executable specifications.

You’ll learn to connect specifications with software under construction, link requirements to architecture, and automate requirements verification within the Scrum framework. Above all, Cardinal will help you solve the paramount challenge of software development: not only to solve the problem right, but also to solve the right problem.

You will learn how to
•    Establish more effective agile roles for analysts and architects
•    Integrate and simplify the best techniques from FIT, ATDD, and BDD
•    Identify “core certainties” on which your project team should rely to ensure requirements discovery
•    Manage uncertainty by discovering stakeholder desires through short feedback loops
•    Specify as you go while writing small chunks of requirements
•    Use storyboarding and paper prototyping to improve conversations with stakeholders
•    Express stakeholder desires that are requirements with user stories
•    Refine your user stories, and plan more effective Scrum sprints
•    Confirm user stories by scripting behaviors with scenarios
•    Transform scenarios into automated tests that easily confirm your software’s expected behavior as designs emerge and specifications evolve
•    Ensure higher-quality software by specifying nonfunctional requirements

Table of Contents

  1. About This eBook
  2. Title Page
  3. Copyright Page
  4. Praise for Executable Specifications with Scrum
  5. Dedication Page
  6. Contents
  7. Table of Contents
  8. Figure List
  9. Preface
    1. Goal of This Book
    2. Who Should Read This Book?
    3. Road Map for This Book
  10. Acknowledgments
  11. About the Author
  12. Chapter 1. Solving the Right Problem
    1. Distinguishing the Requirements from the Solution
    2. Recognizing the Impact of Uncertainty
    3. Tackling Uncertainty
    4. Summary
    5. References
  13. Chapter 2. Relying on a Stable Foundation
    1. Defining What Will Hardly Change
    2. Creating a Healthy Team
    3. Requiring the Involvement of All Stakeholders
    4. Expressing a Shared Vision
    5. Distinguishing a Meaningful Common Goal
    6. Identifying a Set of High-Level Features
    7. Validating the “Can-Exist” Assumption
    8. Summary
    9. References
  14. Chapter 3. Discovering Through Short Feedback Loops and Stakeholders’ Desirements
    1. Applying the Trial-and-Error Method
    2. Using Short Feedback Loops
    3. Targeting Feedback Along the Expected Benefits
    4. Focusing on the Stakeholders’ Desirements
    5. Summary
    6. References
  15. Chapter 4. Expressing Desirements with User Stories
    1. Describing Desirements by Using User Stories
    2. Discovering Desirements by Exploring Roles and Benefits
    3. Establishing a Ubiquitous Language
    4. Recording Desirements by Using a Product Backlog
    5. Summary
    6. References
  16. Chapter 5. Refining User Stories by Grooming the Product Backlog
    1. Managing the Product Backlog
    2. Collaborating to Groom the Product Backlog
    3. Ranking User Stories with a Dot Voting Method
    4. Illustrating User Stories with Storyboards
    5. Sizing User Stories Using Comparison
    6. Splitting User Stories Along Business Values
    7. Tracking User Stories with a Collaboration Board
    8. Delivering a Coherent Set of User Stories
    9. Planning Work with User Stories
    10. Summary
    11. References
  17. Chapter 6. Confirming User Stories with Scenarios
    1. Scripting User Stories with Scenarios
    2. Confirming Collaboratively in a Two-Step Process
    3. Removing Technical Considerations from Scenarios
    4. Evolving Scenarios from Sprint to Sprint
    5. Summary
    6. References
  18. Chapter 7. Automating Confirmation with Acceptance Tests
    1. Evolving Scenarios into Acceptance Tests
    2. Automating Scenarios Using the Red-Green-Refactor Cycle
    3. Translating the Scenario into an Acceptance Test
    4. Connecting the Newly Created Test with the Interface
    5. Implementing the Interface
    6. Evolving the Acceptance Test
    7. Running Acceptance Tests Side-by-Side with Continuous Integration
    8. Enhancing Scenarios with Test Results
    9. Summary
    10. References
  19. Chapter 8. Addressing Nonfunctional Requirements
    1. Improving External Quality Using Restrictions
    2. Ensuring Internal Quality Using Sound Engineering Practices
    3. Summary
    4. References
  20. Chapter 9. Conclusion
    1. Recapitulating the Book
    2. Summarizing the Process
    3. Drawing Attention to Individual Roles
  21. Glossary
  22. Index