Product Cover Image

Executable Specifications with Scrum: A Practical Guide to Agile Requirements Discovery

By Mario Cardinal

Published by Addison-Wesley Professional

Published Date: Jul 15, 2013

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

Preface     xvi
Chapter 1  Solving the Right Problem     1
Distinguishing the Requirements from the Solution     4
Recognizing the Impact of Uncertainty     5
Tackling Uncertainty    7
Summary     10
References     10

Chapter 2  Relying on a Stable Foundation     13
Defining What Will Hardly Change     14
Creating a Healthy Team     14
Requiring the Involvement of All Stakeholders     16
Expressing a Shared Vision     17
Distinguishing a Meaningful Common Goal     20
Identifying a Set of High-Level Features     21
Validating the “Can-Exist” Assumption     22
Summary     23
References     23

Chapter 3  Discovering Through Short Feedback Loops and Stakeholders’ Desirements     25
Applying the Trial-and-Error Method     25
Using Short Feedback Loops     29
Targeting Feedback Along the Expected Benefits     31
Focusing on the Stakeholders’ Desirements     31
Summary     34
References     34

Chapter 4  Expressing Desirements with User Stories     35
Describing Desirements by Using User Stories     35
Discovering Desirements by Exploring Roles and Benefits     38
Establishing a Ubiquitous Language     40
Recording Desirements by Using a Product Backlog     41
Summary     43
References     44

Chapter 5  Refining User Stories by Grooming the Product Backlog     45
Managing the Product Backlog     46
Collaborating to Groom the Product Backlog     48
Ranking User Stories with a Dot Voting Method     49
Illustrating User Stories with Storyboards     52
Sizing User Stories Using Comparison     56
Splitting User Stories Along Business Values     60
Tracking User Stories with a Collaboration Board     62
Delivering a Coherent Set of User Stories     68
Planning Work with User Stories     70
Summary     71
References     72

Chapter 6  Confirming User Stories with Scenarios     73
Scripting User Stories with Scenarios     74
   Expressing Scenarios with Formality     76
   Scripting Scenarios Using the FIT Tabular Format     77
   Scripting Scenarios Using Given-When-Then Syntax     79
   Choosing Between FIT Tabular Format or Given-When-Then Syntax     80
   Formalizing a Ubiquitous Language     81
   Splitting Scenarios into Commands or Queries     83
Confirming Collaboratively in a Two-Step Process     85
Removing Technical Considerations from Scenarios     89
Evolving Scenarios from Sprint to Sprint     91
   Organizing Scenarios by Feature     92
   Documenting Scenarios by Feature     93
   Avoiding Duplication and Merging Conflicts     94
Summary     95
References     96

Chapter 7  Automating Confirmation with Acceptance Tests     97
Evolving Scenarios into Acceptance Tests     98
Automating Scenarios Using the Red-Green-Refactor Cycle     101
Translating the Scenario into an Acceptance Test     104
   Transposing Using an Internal DSL     104
   Creating a Test     107
   Coding the DSL into the Newly Created Test     108
Connecting the Newly Created Test with the Interface     110
   Exercising the Interface     112
   Chaining Context Between the Steps of the Scenario     113
   Making the Test Fail     114
Implementing the Interface     115
   Replacing Unit Testing with Context-Specification Testing     116
   Making the Test Pass     117
Evolving the Acceptance Test     117
Running Acceptance Tests Side-by-Side with Continuous Integration     118
Enhancing Scenarios with Test Results     119
Summary     121
References     122

Chapter 8  Addressing Nonfunctional Requirements     123
Improving External Quality Using Restrictions     125
Translating Nonfunctional Requirements into Restrictions     127
Reducing the Functional Scope to a Single Scenario     129
Setting Measurable Quality Objectives     131
Testing Restrictions with Proven Practices     135
Ensuring Internal Quality Using Sound Engineering Practices     137
   Improving Software Construction with Explicit Practices     137
   Mastering Practices with Collaborative Construction     140
Summary     142
References     143

Chapter 9  Conclusion     145
Recapitulating the Book     146
Summarizing the Process     148
Drawing Attention to Individual Roles     149

Glossary     153
Index     159

Purchase Info

ISBN-10: 0-13-277652-9

ISBN-13: 978-0-13-277652-3

Format: eBook (Watermarked)?

This eBook includes the following formats, accessible from your Account page after purchase:

ePubEPUBThe open industry format known for its reflowable content and usability on supported mobile devices.

MOBIMOBIThe eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

Adobe ReaderPDFThe popular standard, used most often with the free Adobe® Reader® software.

This eBook requires no passwords or activation to read. We customize your eBook by discretely watermarking it with your name, making it uniquely yours.

Includes EPUB, MOBI, and PDF

$27.99

Add to Cart