- Paperback: 224 pages
- Publisher: Addison-Wesley Professional; US Ed edition (October 5, 1999)
- Language: English
- ISBN-10: 0201616416
- ISBN-13: 978-0201616415
- Product Dimensions: 7.3 x 0.4 x 9.3 inches
- Shipping Weight: 12.8 ounces (View shipping rates and policies)
- Average Customer Review: 96 customer reviews
- Amazon Best Sellers Rank: #875,347 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Extreme Programming Explained: Embrace Change US Ed Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
There is a newer edition of this item:
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who bought this item also bought
Kent Beck's eXtreme Programming eXplained provides an intriguing high-level overview of the author's Extreme Programming (XP) software development methodology. Written for IS managers, project leaders, or programmers, this guide provides a glimpse at the principles behind XP and its potential advantages for small- to mid-size software development teams.
The book intends to describe what XP is, its guiding principles, and how it works. Simply written, the book avoids case studies and concrete details in demonstrating the efficacy of XP. Instead, it demonstrates how XP relies on simplicity, unit testing, programming in pairs, communal ownership of code, and customer input on software to motivate code improvement during the development process. As the author notes, these principles are not new, but when they're combined their synergy fosters a new and arguably better way to build and maintain software. Throughout the book, the author presents and explains these principles, such as "rapid feedback" and "play to win," which form the basis of XP.
Generally speaking, XP changes the way programmers work. The book is good at delineating new roles for programmers and managers who Beck calls "coaches." The most striking characteristic of XP is that programmers work in pairs, and that testing is an intrinsic part of the coding process. In a later section, the author even shows where XP works and where it doesn't and offers suggestions for migrating teams and organizations over to the XP process.
In the afterword, the author recounts the experiences that led him to develop and refine XP, an insightful section that should inspire any organization to adopt XP. This book serves as a useful introduction to the philosophy and practice of XP for the manager or programmer who wants a potentially better way to build software. --Richard Dragan
Topics covered: Extreme Programming (XP) software methodology, principles, XP team roles, facilities design, testing, refactoring, the XP software lifecycle, and adopting XP.
From the Inside Flap
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 iextremei in the name? XP takes commonsense principles and practices to extreme levels.
If code reviews are good, weill 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, weill make it part of everybodyis daily business (refactoring). If simplicity is good, weill 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 weill integrate and test several times a day (continuous integration). If short iterations are good, weill make the iterations really, really shortoseconds 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.
G To programmers, XP promises that they will be able to work on things that really matter, every day. They wonit 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 wonit make decisions they they arenit best qualified to make. G 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 teamsoall at the same time. Really. Quit laughing. Now youill have to read the rest of the book to see if Iim crazy. This Book
This book talks about the thinking behind XPoits 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 isnit a book about precisely how to do Extreme Programming. You wonit 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 arenit afraid to try new ideas to get them. But if you are going to take a risk, you want to be convinced that you arenit just being stupid.
XP tells you to do things differently. Sometimes XPis 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 donit get to choose whether or not you will write testsoif you donit, you arenit extreme: end of discussion.
XP is designed to work with projects that can be built by teams of two to ten programmers, that arenit 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 conservativeoall 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, iHow would you program if you had enough time?i Now, you canit 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 imentality of sufficiencyi 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. Outline
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 createdohow it can be adopted, when it shouldnit be adopted, and what opportunities it creates for business.
The book is divided into three sections.
The ProblemoThe chapters from iRisk: The Basic Problemi to iBack to Basicsi set up the problem Extreme Programming is trying to solve and present criteria for evaluating the solution. This section will give you an idea of the overall worldview of Extreme Programming. The SolutionoThe chapters from iQuick Overviewi to iTesting Strategyi turn the abstract ideas in the first section into the practices of a concrete methodology. This section will not tell you exactly how you can execute the practices, but rather talks about their general shape. The discussion of each practice relates it to the problems and principles introduced in the first section. Implementing XPoThe chapters from iAdopting XPi to iXP at Worki describe a variety of topics around implementing XPohow to adopt it, what is expected from the various people in an extreme project, how XP looks to the business folks. Acknowledgments
I write in the first person here, not because these are my ideas, but rather because this is my perspective on these ideas. Most of the practices in XP are as old as programming.
Ward Cunningham is my immediate source for much of what you will read here. In many ways I have spent the last fifteen years just trying to explain to other people what he does naturally. Thanks to Ron Jeffries for trying it, then making it much better. Thanks to Martin Fowler for explaining it in a nonthreatening way. Thanks to Erich Gamma for long talks while watching the swans in the Limmat, and for not letting me get away with sloppy thinking. And none of this would have happened if I hadnit watched my dad, Doug Beck, ply his programming craft all those years.
Thanks to the C3 team at Chrysler for following me up the hill, then storming past me on the way to the top. And special thanks to our managers Sue Unger and Ron Savage for the courage to give us the chance to try. Thanks to Daedalos Consulting for supporting the writing of this book. Champion reviewer honors go to Paul Chisolm for his copious, thoughtful, and often downright annoying comments. This book wouldnit be half of what it is without his feedback.
I have really enjoyed my interactions with all my reviewers. Well, at least I have gained tremendous help from them. I canit thank them enough for wading through my 1.0 prose, some of them in a foreign language. Thanks to (listed in the random order in which I read their reviews) Greg Hutchinson, Massimo Arnoldi, Dave Cleal, Sames Schuster, Don Wells, Joshua Kerievsky, Thorsten Dittmar, Moritz Becker, Daniel Gubler, Christoph Henrici, Thomas Zang, Dierk Koenig, Miroslav Novak, Rodney Ryan, Frank Westphal, Paul Trunz, Steve Hayes, Kevin Bradtke, Jeanine De Guzman, Tom Kubit, Falk Bruegmann, Hasko Heinecke, Peter Merel, Rob Mee, Pete McBreen, Thomas Ernst, Guido Haechler, Dieter Holz, Martin Knecht, Dierk K^nig, Dirk Krampe, Patrick Lisser, Elisabeth Maier, Thomas Mancini, Alexio Moreno, Rolf Pfenninger, and Matthias Ressel.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
On the down side, you will definitely have to investigate further. The book is a bit light and brief, a manifesto for a new approach to development. The author is loosely collaborating with a group that plans to publish several books to fill this gap, among them the already published and quite excellent "Refactoring" by Martin Fowler. Beck and some co-authors are at work on a follow-up called "Playing to Win."
One of the more intersting concepts that Kent is pushing is this book is the concept of programming in pairs. This means that whenever code is written that you have 2 people working on the same computer to write code. My first thought was that this would slow down the process, but Kent explains that it does not actually slow down the process, and it actually speeds things up.
This book contains many radical ideas that would really change the development process. For instance Kent explains that its better to meet the requirements as they exist at the end of the project, rather than the requirements that have been set at the begining of the project.
In a day time when progress is measured in "internet time" and requirements are constantly changing, Extreme Programming provides some usefull ideas.
Let me add one other crucial point here: this book attempts to achieve acceptance with the reader through creating an impression of both an epiphany and validation. I found that a lot of things that were being espoused here are things I've been doing a long time. I believe many people will find that to be true and consequently will like the book because of the sense of validation it gives. However, when I was done, I couldn't help but think about how much more could have been done here! How about talking about actual unit testing examples? Why not talk about structure within groups; it's far too easy to just say everyone should be doing everything. Profiling, for instance, is clearly not something everyone should be doing. Like so many things in the modern world, this is largely a retread wrapping itself in the cloak of a revolution.
XP promotes several worthwhile concepts-- collective owenership (if you find a problem, you fix it, you don't find the owner of the problem), authomated unit testing (write tests once, run them everytime you make a change), heavy communication, and severe flexibility.
The element that most people bite on beyond this is pair programming-- two programmers side by side working on one problem. Another reviewer felt that programming requires a certain depth of concentration to perform, and that a second body could be deterimental to this. I tend to disagree, but I also have a very light-weight, on-the-fly style in my software development style. But then again, I'm a jazz musician writing code, so that only makes sense. :)
Even if you don't embrace all of it (and I'm still not convinced on some issues, like pair programming), it's a worthwhile read for the unit testing bits alone.
Most recent customer reviews
First, the structure. Well, this book is under 200 pages.Read more