You are previewing Agile Development in the Real World.
O'Reilly logo
Agile Development in the Real World

Book Description

This book is a practical guide for new agile practitioners and contains everything a new project manager needs to know to get up to speed with agile practices quickly and sort out the hype and dogma of pseudo-agile practices.The author lays out the general guidelines for running an agile project with the assumption that the project team may be working in a traditional environment (using the waterfall model, or something similar).

Agile Development in the Real World conveys valuable insights to multiple audiences:

  • For new-to-agile project managers, this book provides a distinctive approach that Alan Cline has used with great success, while showing the decision points and perspectives as the agile project moves forward from one step to the next. This allows new agile project managers or agile coaches to choose between the benefits of agile and the benefits of other methods.
  • For the agile technical team member, this book contains templates and sample project artifacts to assist in learning agile techniques and to be used as exemplars for the new practitioner’s own project.
  • For the Project Management Office (PMO), the first three chapters focus on portfolio management. They explain, for the agilists’ benefit, how projects are selected and approved, and why projects have an inherent "shelf-life" that results in hard deadlines that may seem arbitrary to traditional technical teams.
  • Table of Contents

    1. Cover
    2. Title
    3. Copyright
    4. Contents at a Glance
    5. Contents
    6. About the Author
    7. About the Technical Reviewers
    8. Acknowledgments
    9. Introduction
    10. Part I: Getting Started
      1. Chapter 1 : Evolution of Project Management
        1. Ancient Project Management
        2. Formal Development of Project Management
          1. Software Development As a Manufacturing Metaphor
          2. Moving Toward Software Engineering
          3. Software Engineering As an Immature Science
        3. Project Management for the Twenty-first Century
        4. Evolution of Agile Development
          1. Extreme Programming: An Early Agile Method
          2. Progressive Elaboration
          3. Effort vs. Planning by Project Method
          4. The Agile Manifesto: Values and Principles
        5. Comparing Agile and Traditional Practices
          1. High-Quality Product Development
          2. Traditional Approach
          3. Agile Approach
          4. Comparing Agile vs. Traditional Results
        6. PMI Parallels
        7. Conclusion
      2. Chapter 2 : The Birth of a Project: Portfolio Management
        1. Submit a Project Proposal
        2. Align the Proposal with Existing Business Goals
          1. Business Alignment
          2. Risk
          3. Return on Investment (ROI)
          4. Product Life Span
          5. Total Cost of Ownership (TCO)
        3. Find a Sponsor
        4. Build a Business Case
        5. Prioritize the Project Portfolio
          1. Project Types
          2. Project Selection Criteria
        6. Authorize the Project with a Charter
          1. The Project Vision and Mission
          2. Milestones and the Roadmap
          3. The Project Charter
        7. Review the Portfolio Periodically
        8. Differences with Agile
        9. PMI Parallels
        10. Conclusion
        11. Additional Tools
          1. Prioritization Process Using the Delphi Technique
      3. Chapter 3 : Project Startup
        1. Overview
        2. The Project Manager
        3. The Product Owner
        4. The Business Analyst
        5. Manage Stakeholder Expectations
          1. Hold a Business Team Kickoff Meeting
          2. Clarify Stakeholder Relationships
          3. Define Roles and Responsibilities
          4. Stakeholder Analysis and Engagement Grid
          5. Build a Communication Plan
        6. Define Stakeholders’ Scope
          1. Business Abstracts
          2. The Project Abstract
          3. Workflow Context Diagram
          4. Meetings, Agendas, and Minutes
          5. Recommendations for Writing Minutes Easily
          6. Update the Project Charter
        7. Define the Features Catalog (Product Backlog)
          1. Prioritize the Feature Catalog
          2. Estimate Relative Feature Sizes
          3. Scoping Metrics
          4. Estimate the Top Part of the Features Catalog
        8. Develop a Preliminary Release Plan
          1. Iteration 0
          2. Hardening Iteration
          3. Release Iteration
          4. How Long Is an Iteration?
        9. PMI Parallels
        10. Conclusion
        11. Additional Tools
    11. Part II: Iteration 0
      1. Chapter 4 : Preparing the Project
        1. Some Upfront Work Is Necessary
        2. What Is Iteration 0?
        3. Count from Zero
        4. Acquiring the Technical Team
          1. Avoid the Myth of Multitasking
          2. Hold a Technical Team Kickoff Meeting
          3. Tailor an Agile Iteration Approach
        5. Architecture
        6. Development Infrastructure
        7. Functional Requirements
        8. Project Support Tools
        9. Reestimating the Project
          1. The Iron Triangle
          2. Impossible Projects
          3. Fixed-Term Agile Projects
          4. Forecasting from Team Productivity
        10. PMI Parallels
        11. Conclusion
      2. Chapter 5 : Architecture: Product Foundation
        1. Introduction
        2. What Is Software Architecture?
          1. Definition
          2. Balance
          3. Refactoring vs. Rewriting
        3. Application Architectural Views
        4. Platform-Independent and Platform-Specific Design Models (Logical View)
          1. Platform-Independent Model (PIM)
          2. Platform-Specific Model (PSM)
          3. Agile Practices
        5. Architectural Layers (Physical View)
        6. Software Architecture (Development View)
          1. Problem Domain Component (PDC)
          2. Data Management Component (DMC)
          3. Systems Interface Component (SIC)
          4. Human Interface Component (HIC)
          5. Component Interface Validator (CIV)
        7. Architecture Recommendations
        8. Emergent Design: An Architectural Alternative
        9. PMI Parallels
        10. Conclusion
      3. Chapter 6 : Infrastructure: Supporting the Project
        1. Overview
        2. Infrastructure Environments
          1. The Requirements Environment
          2. The Development Environment
          3. The Test Environment
          4. The Test Environment Is Not the Development Environment
          5. The Staging Environment
          6. The Production Environment
          7. The Project Environment
        3. Tools
          1. Requirements Environment Tools
          2. Development Environment Tools
          3. Testing Environment Tools
        4. PMI Parallels
        5. Conclusion
      4. Chapter 7 : Initial Requirements: Defining the Product
        1. Overview
        2. High-Quality Product Development
        3. Functional Requirements
          1. Requirements Hierarchy
          2. Other Useful Terms
        4. Requirements Elicitation
          1. Merging Different Perspectives
          2. Quenty Twestions: Interviewing Is Not a First-Approach Technique
          3. Prefer Use Cases to Features
        5. Produce Detailed Requirements
          1. Associate Features to Business Workflow
          2. Decompose Each Workflow to Use Cases into the Use Case Catalog
          3. Write the Detailed Use Case for Approval
          4. Make the Detailed Use Case a Functional Specification
          5. Develop the UX Artifact
          6. Start the Requirements Traceability Matrix (RTM)
          7. Repeat Through the Features Catalog
        6. PMI Parallels
        7. Conclusion
        8. Additional Tools
          1. Descriptions
    12. Part III: Iteration 1 to N
      1. Chapter 8 : Overview of an Agile Iteration
        1. The Agile Approach
        2. Agile Team Roles
        3. Product Backlog to Iteration Backlog
        4. Iteration Process Overview
          1. Iteration Planning (Box 1)
          2. Validate Use Case with an Object Model (Box 3)
          3. Develop UX Artifacts (Box 4)
          4. Develop GUI Test Cases (Box 5)
          5. Develop Integration Test Cases (Box 6)
          6. Implement Use Case and Unit Tests (Box 7)
          7. Run Regression Tests (Box 8)
          8. Transfer the Build (Box 9)
          9. Run GUI Tests (Box 10)
          10. Code and Run Integration Tests (Box 11)
          11. Run QA and Regression Tests (Box 12)
          12. Defects and the Change Meeting (Box 13)
          13. Build Approved? (Box 14)
          14. Build Iteration and QA Reports (Box 15)
          15. Present the User Demo (Box 16)
          16. Stage or Release the Build (Box 17)
        5. Implicit Change Management Flow Within an Iteration
        6. Prepare the Release
        7. PMI Parallels
        8. Conclusion
          1. Software Development as Puzzle Building
        9. Additional Tools
          1. Agile Iteration Development and Terminology Summary
      2. Chapter 9 : Requirements Thread
        1. Is There Such as Thing as an Agile Business Analyst?
          1. Does Scrum Use a Business Analyst?
          2. Does Extreme Programming Use a Business Analyst?
          3. Does an Agile Team Need a Business Analyst?
        2. The Role of an Agile Business Analyst
          1. Stakeholder Expectation Management
          2. Product Scope Control
          3. Requirements Verification and Validation
          4. Requirements Communication
          5. Requirements Traceability
          6. Change Control and the Definition of Done
          7. The Business Analyst Tasks
        3. Use Cases and User Stories
          1. The User Story Template
          2. Behavior-Driven Design (BDD)
          3. INVEST for Use Cases or User Stories
        4. Validating Requirements
          1. Leveraging Orthogonality for Validation
          2. Verify for Consistency
          3. To Validate or Not to Validate?
          4. Going Further
        5. The Business Analyst within the Agile Iteration
          1. Iteration Planning (Box 1)
          2. Develop the Detailed Use Case (Box 2)
          3. Validate the Use Case with an Object Model (Box 3)
          4. Develop the User Experience Artifact (Box 4)
          5. Defects and Change Meeting (Box 13)
          6. Build Approved? (Box 14)
          7. The User Demo (Box 16)
          8. Stage or Release the Build (Box 17)
        6. PMI Parallels
        7. Conclusion
        8. Additional Tools
          1. ATM Project
        9. Validating Use Cases with XUML6
          1. Class Diagrams
      3. Chapter 10 : Development Thread
        1. The Agile Software Developer
        2. Agile Developer Characteristics and Idioms
          1. Projectized Agile Teams vs. Developer Allocation
          2. Sustainability
          3. The Agile Team Room
          4. Pairing (Pair Programming)
          5. Osmotic Communication
          6. Information Radiators and Big Visible Charts
          7. Daily Standup Meetings
          8. Refactoring
          9. Test Driven Development for Unit Tests
        3. Developers within the Iteration
          1. Iteration Planning (Box 1)
          2. Develop the User Experience Artifact (Box 4)
          3. Implement Use Case and Unit Tests (Box 7)
          4. Run Regression Tests (Box 8)
          5. Upload the Development Build for Testing (Box 9)
          6. Defects and Change Meeting (Box 13)
          7. Approve the Build (Box 14)
          8. Build QA & Iteration Reports (Box 15)
          9. The User Demo (Box 16)
          10. Stage or Release the Build (Box 17)
        4. PMI Parallels
        5. Conclusion
          1. A Typical Day in the Life of an Agile Developer
          2. Summary of Developer Roles
      4. Chapter 11 : Testing Thread
        1. The Agile Tester
        2. Test Cases
          1. Integration Tests
          2. Regression Tests
          3. QA Compliance Tests
        3. Concurrency
        4. Writing Test Cases
        5. Testers in the Iteration
          1. Iteration Planning (Box 1)
          2. Develop GUI Test Cases (Box 5)
          3. Write Integration Test Cases (Box 6)
          4. Receive the Test Build (Box 9)
          5. Run the GUI Tests (Box 10)
          6. Code and Run the Automated Integration Test Code (Box 11)
          7. Run QA and Regression Tests (Box 12)
          8. Defects and Change Meeting (Box 13)
          9. Build Approved? (Box 14)
          10. Build the Iteration and QA Reports (Box 15)
          11. The User Demo (Box 16)
          12. Stage or Release the Build (Box 17)
        6. PMI Parallels
        7. Conclusion
        8. Summary of Tester Roles
        9. Additional Tools
        10. The NEBS Transform
        11. Naming Conventions
        12. Sample Integration Test Suite
        13. Test Script Form Instructions
      5. Chapter 12 : Project Management Thread
        1. The Agile Project Manager
          1. Agile Practices and Retrospectives
          2. Monitoring the Release Plan
          3. Daily Meetings
        2. Agile Perspectives
          1. The APM Perspective with Management
          2. The APM Perspective with the Agile Team
          3. The Agile Team and the Stakeholders
        3. Task Tracking: The Kanban Board
          1. Kanban: A “Pull System”
          2. Work-in-Progress Limits
          3. No Iterations!
          4. Resizing Cards on the Fly
        4. Comparing Velocities Between Teams, Individuals, or Groups
          1. Team Velocities
          2. Individual Velocities
          3. Group Velocities
        5. Agile and Earned Value Management
          1. The Components of Earned Value Management
          2. Putting It All Together
        6. The Agile Project Manager in the Iteration
          1. Iteration Planning (Box 1)
          2. Design Approval Meeting (Box 5)
          3. Defects and Change Meeting (Box 13)
          4. Build Approved? (Box 14)
          5. Build Iteration and QA Reports (Box 15)
          6. The User Demo (Box 16)
          7. Stage or Release the Build (Box 17)
        7. PMI Parallels
        8. Conclusions
        9. Additional Tools
          1. Kanban Process Summary
          2. Building a Burn-Up Chart (Example)
          3. Quality Report (Example)
    13. References
    14. Index