Cover image for The Art of Agile Development

Book description

The Art of Agile Development contains practical guidance for anyone considering or applying agile development for building valuable software. Plenty of books describe what agile development is or why it helps software projects succeed, but very few combine information for developers, managers, testers, and customers into a single package that they can apply directly.

This book provides no-nonsense advice on agile planning, development, delivery, and management taken from the authors' many years of experience with Extreme Programming (XP). You get a gestalt view of the agile development process, including comprehensive guidance for non-technical readers and hands-on technical practices for developers and testers.

The Art of Agile Development gives you clear answers to questions such as:

  • How can we adopt agile development?

  • Do we really need to pair program?

  • What metrics should we report?

  • What if I can't get my customer to participate?

  • How much documentation should we write?

  • When do we design and architect?

  • As a non-developer, how should I work with my agile team?

  • Where is my product roadmap?

  • How does QA fit in?

The book teaches you how to adopt XP practices, describes each practice in detail, then discusses principles that will allow you to modify XP and create your own agile method. In particular, this book tackles the difficult aspects of agile development: the need for cooperation and trust among team members.

Whether you're currently part of an agile team, working with an agile team, or interested in agile development, this book provides the practical tips you need to start practicing agile development. As your experience grows, the book will grow with you, providing exercises and information that will teach you first to understand the rules of agile development, break them, and ultimately abandon rules altogether as you master the art of agile development.

"Jim Shore and Shane Warden expertly explain the practices and benefits of Extreme Programming. They offer advice from their real-world experiences in leading teams. They answer questions about the practices and show contraindications - ways that a practice may be mis-applied. They offer alternatives you can try if there are impediments to applying a practice, such as the lack of an on-site customer.

--Ken Pugh, Author of Jolt Award Winner, Prefactoring

"I will leave a copy of this book with every team I visit."

--Brian Marick, Exampler Consulting

Table of Contents

  1. The Art of Agile Development
    1. SPECIAL OFFER: Upgrade this ebook with O’Reilly
    2. Preface
      1. For the Pragmatists
      2. Who Should Read This Book
      3. About the Études
      4. About Pronouns
      5. Using Code Examples
      6. Safari® Enabled
      7. How to Contact Us
      8. Acknowledgments
        1. James Shore
        2. Shane Warden
    3. I. Getting Started
      1. 1. Why Agile?
        1. Understanding Success
        2. Beyond Deadlines
        3. The Importance of Organizational Success
        4. Enter Agility
          1. Organizational Success
          2. Technical Success
          3. Personal Success
      2. 2. How to Be Agile
        1. Agile Methods
        2. Don’t Make Your Own Method
        3. The Road to Mastery
        4. Find a Mentor
      3. 3. Understanding XP
        1. The XP Lifecycle
          1. How It Works
            1. Planning
            2. Analysis
            3. Design and coding
            4. Testing
            5. Deployment
          2. Our Story Continues
        2. The XP Team
          1. The Whole Team
          2. On-Site Customers
            1. The product manager (aka product owner)
            2. Domain experts (aka subject matter experts)
            3. Interaction designers
            4. Business analysts
          3. Programmers
            1. Designers and architects
            2. Technical specialists
          4. Testers
          5. Coaches
            1. The programmer-coach
            2. The project manager
          6. Other Team Members
          7. The Project Community
            1. Stakeholders
            2. The executive sponsor
          8. Filling Roles
          9. Team Size
          10. Full-Time Team Members
        3. XP Concepts
          1. Refactoring
          2. Technical Debt
          3. Timeboxing
          4. The Last Responsible Moment
          5. Stories
          6. Iterations
          7. Velocity
          8. Theory of Constraints
          9. Mindfulness
      4. 4. Adopting XP
        1. Is XP Right for Us?
          1. Prerequisite #1: Management Support
            1. If management isn’t supportive...
          2. Prerequisite #2: Team Agreement
            1. If people resist...
          3. Prerequisite #3: A Colocated Team
            1. If your team isn’t colocated...
          4. Prerequisite #4: On-Site Customers
            1. If your product manager is too busy to be on-site...
            2. If your product manager is inexperienced...
            3. If you can’t get a product manager at all...
            4. If you can’t get other on-site customers...
          5. Prerequisite #5: The Right Team Size
            1. If you don’t have even pairs...
            2. If your team is larger than seven programmers...
            3. If your team is smaller than four programmers...
            4. If you have many developers working solo...
          6. Prerequisite #6: Use All the Practices
            1. If practices don’t fit...
          7. Recommendation #1: A Brand-New Codebase
            1. If you have preexisting code...
          8. Recommendation #2: Strong Design Skills
            1. If no one has strong design skills...
          9. Recommendation #3: A Language That’s Easy to Refactor
            1. If your language is hard to refactor...
          10. Recommendation #4: An Experienced Programmer-Coach
            1. If you have no obvious coach...
            2. If your leaders are inexperienced...
            3. If you’re assigned a poor coach...
          11. Recommendation #5: A Friendly and Cohesive Team
            1. If your team doesn’t get along...
        2. Go!
          1. The Challenge of Change
          2. Final Preparation
          3. Applying XP to a Brand-New Project (Recommended)
          4. Applying XP to an Existing Project
            1. The big decision
            2. Bring order to chaos
            3. Pay down technical debt
            4. Organize your backlog
            5. Fix important bugs
            6. Move testers forward
            7. Emerge from the darkness
          5. Applying XP in a Phase-Based Organization
            1. Mandatory planning phase
            2. Mandatory analysis phase
            3. Mandatory design phase
            4. Mandatory coding phase
            5. Mandatory testing phase
            6. Mandatory deployment phase
          6. Extremities: Applying Bits and Pieces of XP
            1. Iterations
            2. Retrospectives
            3. Ten-minute build
            4. Continuous integration
            5. Test-driven development
            6. Other practices
        3. Assess Your Agility
          1. Self-Assessment Quiz
    4. II. Practicing XP
      1. 5. Thinking
        1. Pair Programming
          1. Why Pair?
          2. How to Pair
          3. Driving and Navigating
          4. Pairing Stations
          5. Challenges
            1. Comfort
            2. Mismatched skills
            3. Communication style
            4. Tools and keybindings
          6. Questions
          7. Results
          8. Contraindications
          9. Alternatives
          10. Further Reading
        2. Energized Work
          1. How to Be Energized
          2. Supporting Energized Work
          3. Taking Breaks
          4. Questions
          5. Results
          6. Contraindications
          7. Alternatives
          8. Further Reading
        3. Informative Workspace
          1. Subtle Cues
          2. Big Visible Charts
          3. Hand-Drawn Charts
          4. Process Improvement Charts
          5. Gaming
          6. Questions
          7. Results
          8. Contraindications
          9. Alternatives
          10. Further Reading
        4. Root-Cause Analysis
          1. How to Find the Root Cause
          2. How to Fix the Root Cause
          3. When Not to Fix the Root Cause
          4. Questions
          5. Results
          6. Contraindications
          7. Alternatives
        5. Retrospectives
          1. Types of Retrospectives
          2. How to Conduct an Iteration Retrospective
          3. Step 1: The Prime Directive
          4. Step 2: Brainstorming
          5. Step 3: Mute Mapping
          6. Step 4: Retrospective Objective
          7. After the Retrospective
          8. Questions
          9. Results
          10. Contraindications
          11. Alternatives
          12. Further Reading
      2. 6. Collaborating
        1. Trust
          1. Team Strategy #1: Customer-Programmer Empathy
          2. Team Strategy #2: Programmer-Tester Empathy
          3. Team Strategy #3: Eat Together
          4. Team Strategy #4: Team Continuity
          5. Impressions
          6. Organizational Strategy #1: Show Some Hustle
          7. Organizational Strategy #2: Deliver on Commitments
          8. Organizational Strategy #3: Manage Problems
          9. Organizational Strategy #4: Respect Customer Goals
          10. Organizational Strategy #5: Promote the Team
          11. Organizational Strategy #6: Be Honest
          12. Questions
          13. Results
          14. Contraindications
          15. Alternatives
          16. Further Reading
        2. Sit Together
          1. Accommodating Poor Communication
          2. A Better Way
          3. Exploiting Great Communication
          4. Secrets of Sitting Together
          5. Making Room
          6. Designing Your Workspace
          7. Sample Workspaces
            1. A small workspace
          8. Adopting an Open Workspace
          9. Questions
          10. Results
          11. Contraindications
          12. Alternatives
          13. Further Reading
        3. Real Customer Involvement
          1. Personal Development
          2. In-House Custom Development
          3. Outsourced Custom Development
          4. Vertical-Market Software
          5. Horizontal-Market Software
          6. Questions
          7. Results
          8. Contraindications
          9. Alternatives
        4. Ubiquitous Language
          1. The Domain Expertise Conundrum
          2. Two Languages
          3. How to Speak the Same Language
          4. Ubiquitous Language in Code
          5. Refining the Ubiquitous Language
          6. Questions
          7. Results
          8. Contraindications
          9. Alternatives
          10. Further Reading
        5. Stand-Up Meetings
          1. How to Hold a Daily Stand-Up Meeting
          2. Be Brief
          3. Questions
          4. Results
          5. Contraindications
          6. Alternatives
          7. Further Reading
        6. Coding Standards
          1. Beyond Formatting
          2. How to Create a Coding Standard
          3. Dealing with Disagreement
          4. Adhering to the Standard
          5. Questions
          6. Results
          7. Contraindications
          8. Alternatives
        7. Iteration Demo
          1. How to Conduct an Iteration Demo
          2. Two Key Questions
          3. Weekly Deployment Is Essential
          4. Questions
          5. Results
          6. Contraindications
          7. Alternatives
        8. Reporting
          1. Types of Reports
          2. Progress Reports to Provide
            1. Vision statement
            2. Weekly demo
            3. Release and iteration plans
            4. Burn-up chart
          3. Progress Reports to Consider
            1. Roadmap
            2. Status email
          4. Management Reports to Consider
            1. Productivity
            2. Throughput
            3. Defects
            4. Time usage
          5. Reports to Avoid
            1. Source lines of code (SLOC) and function points
            2. Number of stories
            3. Velocity
            4. Code quality
          6. Questions
          7. Results
          8. Contraindications
          9. Alternatives
          10. Further Reading
      3. 7. Releasing
        1. “Done Done”
          1. Production-Ready Software
          2. How to Be “Done Done”
          3. Making Time
          4. Questions
          5. Results
          6. Contraindications
          7. Alternatives
        2. No Bugs
          1. How Is This Possible?
          2. How to Achieve Nearly Zero Bugs
          3. Ingredient #1: Write Fewer Bugs
          4. Ingredient #2: Eliminate Bug Breeding Grounds
          5. Ingredient #3: Fix Bugs Now
          6. Ingredient #4: Test Your Process
          7. Ingredient #5: Fix Your Process
          8. Invert Your Expectations
          9. Questions
          10. Results
          11. Contraindications
          12. Alternatives
          13. Further Reading
        3. Version Control
          1. Concurrent Editing
          2. Time Travel
          3. Whole Project
          4. Customers and Version Control
          5. Keep It Clean
          6. Single Codebase
          7. Appropriate Uses of Branches
          8. Questions
          9. Results
          10. Contraindications
          11. Alternatives
          12. Further Reading
        4. Ten-Minute Build
          1. Automate Your Build
          2. How to Automate
          3. When to Automate
          4. Automating Legacy Projects
          5. Ten Minutes or Less
          6. Questions
          7. Results
          8. Contraindications
          9. Alternatives
        5. Continuous Integration
          1. Why It Works
          2. How to Practice Continuous Integration
          3. Never Break the Build
          4. The Continuous Integration Script
            1. To update from the repository
            2. To integrate
          5. Introducing Continuous Integration
          6. Dealing with Slow Builds
          7. Multistage Integration Builds
          8. Questions
          9. Results
          10. Contraindications
          11. Alternatives
        6. Collective Code Ownership
          1. Making Collective Ownership Work
          2. Working with Unfamiliar Code
          3. Hidden Benefits
          4. Questions
          5. Results
          6. Contraindications
          7. Alternatives
        7. Documentation
          1. Work-In-Progress Documentation
          2. Product Documentation
          3. Handoff Documentation
          4. Questions
          5. Results
          6. Contraindications
          7. Alternatives
      4. 8. Planning
        1. Vision
          1. Product Vision
          2. Where Visions Come From
          3. Identifying the Vision
          4. Documenting the Vision
          5. How to Create a Vision Statement
          6. Promoting the Vision
          7. Questions
          8. Results
          9. Contraindications
          10. Alternatives
          11. Further Reading
        2. Release Planning
          1. One Project at a Time
          2. Release Early, Release Often
          3. How to Release Frequently
          4. An Example
          5. Adapt Your Plans
          6. Keep Your Options Open
          7. How to Create a Release Plan
          8. Planning at the Last Responsible Moment
          9. Adaptive Planning and Organizational Culture
          10. Questions
          11. Results
          12. Contraindications
          13. Alternatives
          14. Further Reading
        3. The Planning Game
          1. How to Play
            1. Overcoming disagreements
          2. How to Win
          3. Questions
          4. Results
          5. Contraindications
          6. Alternatives
        4. Risk Management
          1. A Generic Risk-Management Plan
          2. Project-Specific Risks
          3. How to Make a Release Commitment
          4. Success over Schedule
          5. When Your Commitment Isn’t Good Enough
          6. Questions
          7. Results
          8. Contraindications
          9. Alternatives
          10. Further Reading
        5. Iteration Planning
          1. The Iteration Timebox
          2. The Iteration Schedule
          3. How to Plan an Iteration
          4. The Commitment Ceremony
          5. After the Planning Session
          6. Dealing with Long Planning Sessions
          7. Tracking the Iteration
          8. When Things Go Wrong
          9. Partially Done Work
          10. Emergency Requests
          11. The Batman
          12. Questions
          13. Results
          14. Contraindications
          15. Alternatives
            1. Iteration length
          16. Further Reading
        6. Slack
          1. How Much Slack?
          2. How to Introduce Slack
          3. Research Time
          4. When Your Iteration Commitment Is at Risk
            1. Use refactoring as a shock absorber
            2. Incur a little voluntary overtime
            3. Cancel research time
          5. Don’t Cross the Line
          6. Reducing the Need for Slack
          7. Questions
          8. Results
          9. Contraindications
          10. Alternatives
            1. Reading groups
            2. Silver stories
          11. Further Reading
        7. Stories
          1. Story Cards
          2. Customer-Centricity
          3. Splitting and Combining Stories
          4. Special Stories
            1. Documentation stories
            2. “Nonfunctional” stories
            3. Bug stories
            4. Spike stories
            5. Estimating
            6. Meetings
            7. Architecture, design, refactoring, and technical infrastructure
          5. Questions
          6. Results
          7. Contraindications
          8. Alternatives
          9. Further Reading
        8. Estimating
          1. What Works (and Doesn’t) in Estimating
          2. Velocity
          3. Velocity and the Iteration Timebox
          4. How to Make Consistent Estimates
          5. How to Estimate Stories
          6. How to Estimate Iteration Tasks
          7. When Estimating Is Difficult
          8. Explaining Estimates
          9. How to Improve Your Velocity
            1. Pay down technical debt
            2. Improve customer involvement
            3. Support energized work
            4. Offload programmer duties
            5. Provide needed resources
            6. Add programmers (carefully)
          10. Questions
          11. Results
          12. Contraindications
          13. Alternatives
          14. Further Reading
      5. 9. Developing
        1. Incremental Requirements
          1. The Living Requirements Document
          2. Work Incrementally
            1. Vision, features, and stories
            2. Rough expectations
            3. Mock-ups, customer tests, and completion criteria
            4. Customer review
          3. Questions
          4. Results
          5. Contraindications
          6. Alternatives
          7. Further Reading
        2. Customer Tests
          1. Describe
          2. Demonstrate
          3. Develop
          4. Focus on Business Rules
          5. Ask Customers to Lead
          6. Automating the Examples
          7. Questions
          8. Results
          9. Contraindications
          10. Alternatives
          11. Further Reading
        3. Test-Driven Development
          1. Why TDD Works
          2. How to Use TDD
            1. Step 1: Think
            2. Step 2: Red bar
            3. Step 3: Green bar
            4. Step 4: Refactor
            5. Step 5: Repeat
          3. A TDD Example
            1. The task
            2. One name/value pair
            3. An empty string
            4. testNull()
            5. valueFor()
            6. Multiple name/value pairs
            7. Multiple count()
            8. Your turn
          4. Testing Tools
          5. Speed Matters
          6. Unit Tests
          7. Focused Integration Tests
          8. End-to-End Tests
          9. TDD and Legacy Code
          10. Questions
          11. Results
          12. Contraindications
          13. Alternatives
          14. Further Reading
        4. Refactoring
          1. Reflective Design
            1. Divergent Change and Shotgun Surgery
            2. Primitive Obsession and Data Clumps
            3. Data Class and Wannabee Static Class
            4. Coddling Nulls
            5. Time Dependencies and Half-Baked Objects
          2. Analyzing Existing Code
          3. How to Refactor
          4. Refactoring in Action
          5. Questions
          6. Results
          7. Contraindications
          8. Alternatives
          9. Further Reading
        5. Simple Design
          1. You Aren’t Gonna Need It (YAGNI)
          2. Once and Only Once
          3. Self-Documenting Code
          4. Isolate Third-Party Components
          5. Limit Published Interfaces
          6. Fail Fast
          7. Questions
          8. Results
          9. Contraindications
          10. Alternatives
          11. Further Reading
        6. Incremental Design and Architecture
          1. How It Works
          2. Continuous Design
          3. Incrementally Designing Methods
          4. Incrementally Designing Classes
          5. Incrementally Designing Architecture
          6. Risk-Driven Architecture
          7. It’s Not Just Coding
          8. Questions
          9. Results
          10. Contraindications
          11. Alternatives
          12. Further Reading
        7. Spike Solutions
          1. About Spikes
          2. Performing the Experiment
          3. Scheduling Spikes
          4. Questions
          5. Results
          6. Contraindications
          7. Alternatives
        8. Performance Optimization
          1. How to Optimize
          2. When to Optimize
          3. How to Write a Performance Story
          4. Questions
          5. Results
          6. Contraindications
          7. Alternatives
          8. Further Reading
        9. Exploratory Testing
          1. About Exploratory Testing
          2. Tool #1: Charters
          3. Tool #2: Observation
          4. Tool #3: Notetaking
          5. Tool #4: Heuristics
            1. None, Some, All
            2. Goldilocks: too big, too small, just right
            3. Position: beginning, middle, end
            4. Count: zero, one, many
            5. CRUD: create, read, update, delete
            6. Command Injection
            7. Data Type Attacks
          6. An Example
          7. When You Find Bugs
          8. Questions
          9. Results
          10. Contraindications
          11. Alternatives
          12. Further Reading
    5. III. Mastering Agility
      1. 10. Values and Principles
        1. Commonalities
        2. About Values, Principles, and Practices
        3. Further Reading
      2. 11. Improve the Process
        1. Understand Your Project
          1. In Practice
          2. Beyond Practices
        2. Tune and Adapt
          1. In Practice
          2. Beyond Practices
        3. Break the Rules
          1. In Practice
          2. Beyond Practices
      3. 12. Rely on People
        1. Build Effective Relationships
          1. In Practice
          2. Beyond Practices
        2. Let the Right People Do the Right Things
          1. In Practice
          2. Beyond Practices
        3. Build the Process for the People
          1. In Practice
          2. Beyond Practices
      4. 13. Eliminate Waste
        1. Work in Small, Reversible Steps
          1. In Practice
          2. Beyond Practices
        2. Fail Fast
          1. In Practice
          2. Beyond Practices
        3. Maximize Work Not Done
          1. In Practice
          2. Beyond Practices
        4. Pursue Throughput
          1. In Practice
          2. Beyond Practices
      5. 14. Deliver Value
        1. Exploit Your Agility
          1. In Practice
          2. Beyond Practices
        2. Only Releasable Code Has Value
          1. In Practice
          2. Beyond Practices
        3. Deliver Business Results
          1. In Practice
          2. Beyond Practices
        4. Deliver Frequently
          1. In Practice
          2. Beyond Practices
      6. 15. Seek Technical Excellence
        1. Software Doesn’t Exist
        2. Design Is for Understanding
        3. Design Trade-offs
        4. Quality with a Name
        5. Great Design
        6. Universal Design Principles
          1. The Source Code Is the (Final) Design
          2. Don’t Repeat Yourself (DRY)
          3. Be Cohesive
          4. Decouple
          5. Clarify, Simplify, and Refine
          6. Fail Fast
          7. Optimize from Measurements
          8. Eliminate Technical Debt
        7. Principles in Practice
        8. Pursue Mastery
    6. References
    7. Index
    8. About the Authors
    9. Colophon
    10. SPECIAL OFFER: Upgrade this ebook with O’Reilly