Embed Size (px)
Extreme Programming Explained
Preface This Book What Is XP? Enough Outline Acknowledgments
I: The Problem
1. Risk: The Basic Problem Our Mission
2. A Development Episode
3. Economics of
Embed Size (px)
Extreme Programming Explained
Preface This Book What Is XP? Enough Outline Acknowledgments
I: The Problem
1. Risk: The Basic Problem Our Mission
2. A Development Episode
3. Economics of Software Development Options Example
4. Four Variables Interactions Between the Variables Focus on Scope
5. Cost of Change
6. Learning to Drive
7. Four Values Communication Simplicity Feedback Courage The Values in Practice
8. Basic Principles
9. Back to Basics Coding Testing Listening Designing
II: The Solution
10. A Quick Overview The Planning Game Small Releases Metaphor Simple Design Testing Refactoring Pair Programming Collective Ownership Continuous Integration 40-Hour Week On-Site Customer Coding Standards
11. How Could This Work? The Planning Game Short Releases Metaphor Simple Design Testing Refactoring Pair Programming Collective Ownership Continuous Integration 40-Hour Week On-Site Customer Coding Standards Conclusion
12. Management Strategy Metrics Coaching Tracking Intervention
13. Facilities Strategy
14. Splitting Business and Technical Responsibility Business Development What to Do?
Choice of Technology What if It's Hard?
15. Planning Strategy The Planning Game Iteration Planning Planning in a Week
16. Development Strategy Continuous Integration Collective Ownership Pair Programming
17. Design Strategy The Simplest Thing That Could Possibly Work How Does "Designing Through Refactoring" Work? What Is Simplest? How Could This Work? Role of Pictures in Design System Architecture
18. Testing Strategy Who Writes Tests? Other Tests
III: Implementing XP
19. Adopting XP
20. Retrofitting XP Testing Design Planning Management Development In Trouble?
21. Lifecycle of an Ideal XP Project Exploration Planning Iterations to First Release Productionizing Maintenance Death
22. Roles for People
Programmer Customer Tester Tracker Coach Consultant Big Boss
23. 20–80 Rule
24. What Makes XP Hard
25. When You Shouldn't Try XP
26. XP at Work Fixed Price Outsourcing Insourcing Time and Materials Completion Bonus Early Termination Frameworks Shrinkwrap Products
27. Conclusion Expectation
A. Annotated Bibliography Philosophy Attitude Emergent Processes Systems People Project Management Programming Other
Extreme Programming (XP) nominates coding as the key activity throughout a software project. This can't possibly work!
Time to reflect for a second about my own development work. I work in a just-in-time software culture with compressed release cycles spiced up with high technical risk. Having to make change your friend is a survival skill. Communication in and across often geographically separated teams is done with code. We read code to understand new or evolving subsystem APIs. The life cycle and behavior of complex objects is defined in test cases, again in code. Problem reports come with test cases demonstrating the problem, once more in code. Finally, we continously improve existing code with refactoring. Obviously our development is code-centric, but we successfully deliver software in time, so this can work after all.
It would be wrong to conclude that all that is needed to deliver software is daredevil programming. Delivering software is hard, and delivering quality software in time is even harder. To make it work requires the disciplined use of additional best practices. This is where Kent starts in his thought-provoking book on XP.
Kent was among the leaders at Tektronix to recognize the potential of man in the loop pair programming in Smalltalk for complex engineering applications. Together with Ward Cunningham, he inspired much of the pattern movement that has had such an impact on my career. XP describes an approach to development that combines practices used by many successful developers that got buried under the massive literature on software methods and process. Like patterns, XP builds on best practices such as unit testing, pair programming, and refactoring. In XP these practices are combined so that they complement and often control each other. The focus is on the interplay of the different practices, which makes this book an important contribution. There is a single goal to deliver software with the right functionality and hitting dates. While OTI's successful Just In Time Software process is not pure XP, it has many common threads.
I've enjoyed my interaction with Kent and practicing XP episodes on a little thing called Junit. His views and approaches always chal