«Extreme Programming (XP) was conceived and developed to address the specific needs of software development conducted by small teams in the face of ...»
Extreme Programming Explained
First Edition September 29, 1999
ISBN: 0201616416, 224 pages
Extreme Programming (XP) was conceived and developed
to address the specific needs of software development
conducted by small teams in the face of vague and
Front Matter changing requirements. This new lightweight methodology
Table of Contents challenges many conventional tenets, including the longAbout the Author held assumption that the cost of changing a piece of software necessarily rises dramatically over the course of time. XP recognizes that projects have to work to achieve this reduction in cost and exploit the savings once they have been earned.
Fundamentals of XP include:
• Distinguishing between the decisions to be made by business interests and those to be made by project stakeholders.
• Writing unit tests before programming and keeping all of the tests running at all times.
• Integrating and testing the whole system--several times a day.
• Producing all software in pairs, two programmers at one screen.
• Starting projects with a simple design that constantly evolves to add needed flexibility and remove unneeded complexity.
• Putting a minimal system into production quickly and growing it in whatever directions prove most valuable.
Why is XP so controversial? Some sacred cows don’t make
the cut in XP:
• Don’t force team members to specialize and become analysts, architects, programmers, testers, and integrators--every XP programmer participates in all of these critical activities every day.
• Don’t conduct complete up-front analysis and design--an XP project starts with a quick analysis of the entire system, and XP programmers continue to make analysis and design decisions throughout development.
• Develop infrastructure and frameworks as you develop your application, not up-front--delivering business value is the heartbeat that drives XP projects.
• Don’t write andmaintain implementation documentation--communication in XP projects occurs face-to-face, or through efficient tests and carefully written code.
You may love XP, or you may hate it, but Extreme Programming Explained will force you to take a fresh look at how you develop software.
What Is XP?
Part I: The Problem
Chapter 1. Risk: The Basic Problem
Chapter 2. A Development Episode
Chapter 3. Economics of Software Development
Chapter 4. Four Variables
Interactions Between the Variables
Focus on Scope
Chapter 5. Cost of Change
Chapter 6. Learning to Drive
Chapter 7. Four Values
The Values in Practice
Chapter 8. Basic Principles
Chapter 9. Back to Basics
Part II: The Solution
Chapter 10. A Quick Overview
The Planning Game
Chapter 11. How Could This Work?
The Planning Game
Chapter 12. Management Strategy
Chapter 13. Facilities Strategy
Chapter 14. Splitting Business and Technical Responsibility................ 66 Business
What to Do?
Choice of Technology
What if It's Hard?
Chapter 15. Planning Strategy
The Planning Game
Planning in a Week
Chapter 16. Development Strategy
Chapter 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
Chapter 18. Testing Strategy
Who Writes Tests?
Part III: Implementing XP
Chapter 19. Adopting XP
Chapter 20. Retrofitting XP
Chapter 21. Lifecycle of an Ideal XP Project
Iterations to First Release
Chapter 22. Roles for People
Chapter 23. 20–80 Rule
Chapter 24. What Makes XP Hard
Chapter 25. When You Shouldn't Try XP
Chapter 26. XP at Work
Time and Materials
Chapter 27. Conclusion
Appendix A. Annotated Bibliography
Preface This is a book about Extreme Programming (XP). XP is a lightweight methodology for small-to-medium-sized teams developing software in the face of vague or rapidly changing requirements. This book is intended to help you decide if XP is for you.
To some folks, XP seems like just good common sense. So why the "extreme" in the name? XP takes commonsense principles and practices to extreme levels.
If code reviews are good, we'll review code all the time (pair • programming).
If testing is good, everybody will test all the time (unit testing), • even the customers (functional testing).
If design is good, we'll make it part of everybody's daily business • (refactoring).
If simplicity is good, we'll always leave the system with the • simplest design that supports its current functionality (the simplest thing that could possibly work).
If architecture is important, everybody will work defining and • refining the architecture all the time (metaphor).
If integration testing is important, then we'll integrate and test • several times a day (continuous integration).
If short iterations are good, we'll make the iterations really, • really short—seconds and minutes and hours, not weeks and months and years (the Planning Game).
When I first articulated XP, I had the mental image of knobs on a control board. Each knob was a practice that from experience I knew worked well. I would turn all the knobs up to 10 and see what happened. I was a little surprised to find that the whole package of practices was stable, predictable, and flexible.
XP makes two sets of promises.
To programmers, XP promises that they will be able to work on • things that really matter, every day. They won't have to face scary situations alone. They will be able to do everything in their power to make their system successful. They will make decisions that they can make best, and they won't make decisions they they aren't best qualified to make.
To customers and managers, XP promises that they will get the • most possible value out of every programming week. Every few weeks they will be able to see concrete progress on goals they care about. They will be able to change the direction of the project in the middle of development without incurring exorbitant costs.
In short, XP promises to reduce project risk, improve responsiveness to business changes, improve productivity throughout the life of a system, and add fun to building software in teams—all at the same time. Really. Quit laughing. Now you'll have to read the rest of the book to see if I'm crazy.
This book talks about the thinking behind XP—its roots, philosophy, stories, myths. It is intended to help you make an informed decision about whether or not to use XP on your project. If you read this book and correctly decide not to use XP for your project, I will have met my goal just as much as if you correctly decide to use it. A second goal of this book is to help those of you already using XP to understand it better.
This isn't a book about precisely how to do Extreme Programming. You won't read lots of checklists here, or see many examples, or lots of programming stories. For that, you will have to go online, talk to some of the coaches mentioned here, wait for the topical, how-to books to follow, or just make up your own version.
The next stage of acceptance of XP is now in the hands of a group of people (you may be one) who are dissatisfied with software development as it is currently practiced. You want a better way to develop software, you want better relationships with your customers, you want happier, more stable, more productive programmers. In short, you are looking for big rewards, and you aren't afraid to try new ideas to get them. But if you are going to take a risk, you want to be convinced that you aren't just being stupid.
XP tells you to do things differently. Sometimes XP's advice is absolutely contrary to accepted wisdom. Right now I expect those choosing to use XP to require compelling reasons for doing things differently, but if the reasons are there, to go right ahead. I wrote this book to give you those reasons.
What Is XP?
What is XP? XP is a lightweight, efficient, low-risk, flexible, predictable, scientific, and fun way to develop software. It is distinguished from other methodologies by Its early, concrete, and continuing feedback from short cycles.
• Its incremental planning approach, which quickly comes up with • an overall plan that is expected to evolve through the life of the project.
Its ability to flexibly schedule the implementation of • functionality, responding to changing business needs.
Its reliance on automated tests written by programmers and • customers to monitor the progress of development, to allow the system to evolve, and to catch defects early.
Its reliance on oral communication, tests, and source code to • communicate system structure and intent.
Its reliance on an evolutionary design process that lasts as long • as the system lasts.
Its reliance on the close collaboration of programmers with • ordinary skills.
Its reliance on practices that work with both the short-term • instincts of programmers and the long-term interests of the project.
XP is a discipline of software development. It is a discipline because there are certain things that you have to do to be doing XP. You don't get to choose whether or not you will write tests—if you don't, you aren't extreme: end of discussion.
XP is designed to work with projects that can be built by teams of two to ten programmers, that aren't sharply constrained by the existing computing environment, and where a reasonable job of executing tests can be done in a fraction of a day.
XP frightens or angers some people who encounter it for the first time.
However, none of the ideas in XP are new. Most are as old as programming. There is a sense in which XP is conservative—all its techniques have been proven over decades (for the implementation strategy) or centuries (for the management strategy).
The innovation of XP is Putting all these practices under one umbrella.
• Making sure they are practiced as thoroughly as possible.
• Making sure the practices support each other to the greatest • possible degree.
Enough In The Forest People and The Mountain People, anthropologist Colin Turnbull paints contrasting pictures of two societies. In the mountains, resources were scarce and people were always on the brink of starvation. The culture they evolved was horrific. Mothers abandoned babies to roving packs of feral children as soon as they had any chance of survival. Violence, brutality, and betrayal were the order of the day.
In contrast, the forest had plenty of resources. A person had only to spend half an hour a day providing for their basic needs. The forest culture was the mirror image of the mountain culture. Adults shared in raising children, who were nurtured and loved until they were quite ready to care for themselves. If one person accidentally killed another (deliberate crime was unknown), they were exiled, but they only had to go a little ways into the forest, and only for a few months, and even then the other tribespeople brought them gifts of food.
XP is an experiment in answer to the question, "How would you program if you had enough time?" Now, you can't have extra time, because this is business after all, and we are certainly playing to win.
But if you had enough time, you would write tests; you would restructure the system when you learned something; you would talk a lot with fellow programmers and with the customer.
Such a "mentality of sufficiency" is humane, unlike the relentless drudgery of impossible, imposed deadlines that drives so much talent out of the business of programming. The mentality of sufficiency is also good business. It creates its own efficiencies, just as the mentality of scarcity creates its own waste.
The book is written as if you and I were creating a new software development discipline together. We start by examining our basic assumptions about software development. We then create the discipline itself. We conclude by examing the implications of what we have created—how it can be adopted, when it shouldn't be adopted, and what opportunities it creates for business.
The book is divided into three sections.