极限编程实践指南：英文版

Foreword by Scott W.Ambler
Preface
Introduction
part I  The Game
Chapter 1  Extreme Principles
 Work with Your Customers
 Use Metaphors to Describe Difficult Concepts
 Plan
 Keep Meetings Short
 Test First
 Keep it Simple
 Program in Pairs
 Code to Standards
 Own it Collectively
 Integrate Continuously
 Refactor
 Release in Small Increments
 Don't Burn Out (40-Hour Work Week)
 Embrace Change
Chapter 2  The Players
 Two Teams
 The Customer Team
 The Development Team
 The Role of Roles
 Establishing Rights
 Conclusion
part II  onceptualizing the System
Chapter 3  Creating a Vision of the System
 Conceptualizing the System
 The Vision Card
 The Metaphor
 Metaphors for Development
 Conclusion
Chapter 4  Writing User Stories
 The Philosophy of User Stories
 User Stories
 Numbering the Stack
 Conclusion
 Appendix to Chapter 4
Chapter 5  Writing Acceptance Tests
 What Is an Acceptance Test?
 Writing Tests
 Difficulty with Acceptance Tests
Infinitely Many Acceptance Tests
 Automating Acceptance Tests
 Conclusion
Chapter 6  One Simple Solution
 What Are We Looking for?
 Keep It Simple
 Conceptual Solution Spikes
 Conclusion
Chapter 7  Watching Our Words
 The Problem
 What's in a Name
 Constant Refactoring and Communicating
 Conclusion
part III  Planning
Chapter 8  Providing Estimates
  Providing Estimates
  Assumptions
  Splitting
  Planning Spikes
  Conclusion
Chapter 9  Planning Releases
 Velocity
 The Cost of the Release
Establishing Priorities
 Pair Programming
 Creating the Release Plan
 Conclusion
Chapter 10  Planning Iterations
 Creating a Series of Iterations
 The Setting for Iteration Planning
 The First Iteration
 Subsequent Iterations
 Scheduling Iterations
 Conclusion
Chapter 11  Tactical Planning
 Beginning an iteration
 Volunteering for Tasks
 Standup Meetings
 Tracking the Project
 Finishing Early
 Conclusion
part IV  Development
Chapter 12  Pair Programming
 The Mechanics of Pair Programming
 Development as a Conversation
 Peer Pressure
 Double the Fun
 The Net Effect
As Fast as the Slowest
 Conclusion
Chapter 13  Test First
 The XP Project
 Why Test?
 What to Test
 When to Test
 How to Test: A Testing Framework
 Warranted Assumptions Revisited:
 Test Driven Development
 Example
 A Case for Test Driven Development
 Conclusion
Chapter 14  Design
 Design and XP
 Where Design Patterns Fit in XP
 Architecture and XP
 Agile Modeling
 What is Agile Modeling (AM)?
 Overview of the Values, Principles, and Practices of Agile Modeling (AM)
 Conclusion
Chapter 15  Code With Intention
 What's in a Name
 Simplicity is the Ultimate Complexity
 Warranted Assumptions
Let the Compiler Tell You
 "No Comment"
 Collective Code Ownership
 Better to Burn Out than to Fade Away?
 Happy Developers Are Productive Developers
 Get a Life
 Conclusion
Chapter 16  Refactoring
 Examples of Refactorings
 Courage
 Code Smells
 When to Refactor
 The Two Hats
 Refactoring to Patterns
 Example of Refactoring
 Conclusion
Chapter 17  Relentless Integration
 Some Practical Advice
 Only Check in When Tests Pass at 100 Percent
 An Antipattern
 Approaches to Integration
 What About Code Reviews
 The Impact of Collective Code Ownership
 Conclusion
part V  Delivery
chapter 18  Delivering the System
 Delivery Day
 Productionizing
 Testing
 Celebrating Victories
part VI  Additional Topics
Chapter 19  Adopting and Adapting XP
 Understanding XP
 Adopting XP
 Methods of Adoption
 Adapting XP
 XP Practices
 Return on Investment
 Conclusion
Chapter 20  Scaling XP
 Large-Scale Development
 Organizing the Large XP Project
 Open and Honest Communication
 Integration
 The Importance of Good People
 Conclusion
Chapter 21  The Future of XP
 Where XP is Going
 On to the Battlefield
 A Holonic Approach to XP
 Software Development as a Crt
 Evolving XP
 Appendix: Example
 Bibliography
 Index