Managing Software Requirements the Agile Way

Book description

Learn how to deliver software that meets your clients' needs with the help of a structured, end-to-end methodology for managing software requirements and building suitable systems

Key Features

  • Learn how to communicate with a project's stakeholders to elicit software requirements
  • Deal every phase of the requirement life cycle with pragmatic methods and techniques
  • Manage the software development process and deliver verified requirements using Scrum and Kanban

Book Description

Difficulty in accurately capturing and managing requirements is the most common cause of software project failure. Learning how to analyze and model requirements and produce specifications that are connected to working code is the single most fundamental step that you can take toward project success. This book focuses on a delineated and structured methodology that will help you analyze requirements and write comprehensive, verifiable specifications.

You'll start by learning about the different entities in the requirements domain and how to discover them based on customer input. You'll then explore tried-and-tested methods such as impact mapping and behavior-driven development (BDD), along with new techniques such as D3 and feature-first development. This book takes you through the process of modeling customer requirements as impact maps and writing them as executable specifications. You'll also understand how to organize and prioritize project tasks using Agile frameworks, such as Kanban and Scrum, and verify specifications against the delivered code. Finally, you'll see how to start implementing the requirements management methodology in a real-life scenario.

By the end of this book, you'll be able to model and manage requirements to create executable specifications that will help you deliver successful software projects.

What you will learn

  • Kick-start the requirements-gathering and analysis process in your first meeting with the client
  • Accurately define system behavior as features
  • Model and describe requirement entities using Impact Mapping and BDD
  • Create a feature-based product backlog and use it to drive software development
  • Write verification code to turn features into executable specifications
  • Deliver the right software and respond to change using either Scrum or Kanban
  • Choose appropriate software tools to provide transparency and traceability to your clients

Who this book is for

This book is for software engineers, business analysts, product managers, project managers, and software project stakeholders looking to learn a variety of techniques and methodologies for collating accurate software requirements. A fundamental understanding of the software development life cycle (SDLC) is needed to get started with this book. Although not necessary, basic knowledge of the Agile philosophy and practices, such as Scrum, along with some programming experience will help you to get the most out of this book.

Publisher resources

Download Example Code

Table of contents

  1. Managing Software Requirements the Agile Way
  2. Why subscribe?
  3. Contributors
  4. About the author
  5. About the reviewer
  6. Packt is searching for authors like you
  7. Preface
    1. Who this book is for
    2. What this book covers
    3. To get the most out of this book
    4. Download the example code files
    5. Download the color images
    6. Conventions used
    7. Get in touch
    8. Reviews
  8. Chapter 1: The Requirements Domain
    1. The nature of requirements and specifications
      1. What is a requirement?
      2. What are specifications?
      3. The requirements life cycle
    2. Identifying stakeholders
    3. Identifying goals
      1. Domain goals
      2. Business goals
    4. A traveling analogy of goals, requirements, and specifications
    5. Crossing from requirements to specifications
      1. The requirements funnel
      2. The user story chaos
    6. Summary
    7. Further reading
  9. Chapter 2: Impact Mapping and Behavior-Driven Development
    1. Modeling requirements with impact maps
      1. Introduction to impact mapping
      2. The benefits of impact mapping
    2. Identifying capabilities and features
      1. What is a capability?
      2. What is a feature?
      3. Distinguishing capabilities from features
    3. Introducing BDD
      1. BDD with impact mapping – a perfect partnership
    4. Knowing the difference between functional and non-functional requirements
    5. Summary
    6. Further reading
  10. Chapter 3: Writing Fantastic Features with the Gherkin Language
    1. What's in a feature?
    2. Writing Features with Gherkin
    3. Scripting Scenarios
      1. Discovering Scenarios
      2. Avoiding repetition with Data Tables
      3. Adding more Scenarios
      4. Avoiding repetition with Scenario Outlines
      5. Scenario Outlines versus Data Tables
      6. Avoiding step repetition with Backgrounds
      7. Writing a fully formed Feature
      8. Tips for writing good Features
    4. Using tags to label, organize, and filter our Features
    5. Knowing why Features are executable specifications
    6. Summary
    7. Further reading
  11. Chapter 4: Crafting Features Using Principles and Patterns
    1. Applying the BDD principles
      1. BDD isn't testing
      2. The 80-20 rule
      3. System behavior is not system implementation
      4. Wearing different hats
    2. Discerning patterns in our features
      1. The CRUD Features pattern
      2. The composite features pattern
      3. The feature interpolation pattern
    3. Patterns to avoid
      1. Anti-pattern – thinking like developers
      2. Anti-pattern – incidental details
      3. Anti-pattern – scenario flooding
      4. Anti-pattern – vague outcomes
      5. Anti-pattern – compound steps
    4. Summary
  12. Chapter 5: Discovering and Analyzing Requirements
    1. The lost art of requirements elicitation
    2. Preparing for requirements analysis
      1. Stakeholder model
      2. Glossary
    3. Analyzing requirements
    4. Having a structured conversation
    5. Decompose, Derive, Discover (D3)
      1. Decomposition
      2. Detecting capabilities and features
      3. Decomposition outcome
      4. Derivation
      5. Discovery
    6. Business process mapping
    7. Summary
  13. Chapter 6: Organizing Requirements
    1. Providing easy access to our requirements model
    2. Ensuring traceability with entity identifiers
    3. Creating a specification document
      1. Getting stakeholder agreement on the specification
      2. Scoping the specification
    4. Creating a product backlog
      1. The Agile SDLC
      2. What goes into the product backlog?
      3. Where to keep the backlog
    5. Summary
  14. Chapter 7: Feature-First Development
    1. Setting up for successful delivery
      1. Creating a staging environment
      2. Creating a task board
      3. Defining done
    2. Actualizing just-in-time development
    3. Working with Scrum
      1. Sprint planning
      2. Sprint development cycle
      3. End of Sprint
      4. Dealing with change
    4. Working within Kanban
      1. Kanban planning
      2. Kanban development cycle
      3. Dealing with change
    5. Summary
  15. Chapter 8: Creating Automated Verification Code
    1. Why is automated verification valuable?
    2. Avoiding brittleness by layering automation code
      1. The brittle step definition problem
      2. Applying layers of abstraction
    3. Leveraging automated verification code patterns
      1. Hiding browser details with the Page Object pattern
      2. Wrap up complex operations with the Façade Pattern
      3. Knowing which patterns to apply and when to apply them
      4. Separating the things we verify from the way we verify them
    4. Summary
  16. Chapter 9: The Requirements Life Cycle
    1. Revisiting the requirements management life cycle
      1. Validating requirements
      2. Modeling requirements
      3. Creating specifications
      4. Classifying requirements
      5. Documenting requirements
      6. Prioritizing requirements
      7. Verifying requirements
      8. Dealing with change
    2. Applying the Agile requirements management workflow
      1. Elicitation and Analysis
      2. Modeling and Discovery
      3. Executable specification
      4. Development, Validation, and Verification
    3. Summary
    4. Further reading
  17. Chapter 10: Use Case: The Camford University Paper Publishing System
    1. Understanding the Camford conundrum
    2. Eliciting requirements
      1. Leading the initial discussions
      2. Analyzing requirements
      3. Decomposing the ME's requirements
      4. Deriving requirements
      5. Discovering requirements
    3. Planning the way forward
    4. Summary
  18. Other Books You May Enjoy
    1. Leave a review - let other readers know what you think

Product information

  • Title: Managing Software Requirements the Agile Way
  • Author(s): Fred Heath
  • Release date: August 2020
  • Publisher(s): Packt Publishing
  • ISBN: 9781800206465