Planning Extreme Programming | 1969-12-31 00:00:00 | | 0 | Extreme Programming
The Extreme Programming (XP) paradigm has developers doing things like programming in pairs, writing tests to verify all code, and continuously refactoring designs for improved performance. Written by two of its inventors,
Planning Extreme Programming shows you how to implement XP by using a simple, effective process. This remarkably short (yet remarkably useful) title will give any XP manager or programmer a perspective on delivering software that meets the needs of customers better.
Simplicity is the watchword of the XP software process. This book is virtually devoid of traditional software-engineering jargon and design diagrams, and yet does a good job of laying the foundation of how to perform XP--which is all about working with a customer to deliver features incrementally.
The terminology in the book is commonsensical. (In the terms of XP, each iteration adds certain new features, or stories. It's up to the customer to decide what functionality is more important and will be delivered first. By never letting a working build get out of sight, the XP process virtually ensures that software will be close to what the customer wants.)
Early chapters borrow analogies from everyday experience--like planning a trip or driving a car--to set the stage for XP process planning. The book has plenty of advice for dealing with the stakeholders (customers) of a project. Because of confidentiality agreements, however, we don't get many details from the real world, although the discussion is anchored by a hypothetical project for planning the Web site of the future for travel, with some specifics.
There is plenty of advice for planning projects, based on individual and team `velocity` (a measure of productivity) and the like--practical suggestions for running daily, short status meetings (in which all of the participants stand up, to keep them short). Clearly, there's a culture that surrounds many XP teams, and this text does a good job of conveying some of this to the reader.
At fewer than 150 pages, Planning Extreme Programming is notably concise, and that's probably the whole point. Most shops today work on Internet time, which doesn't wait for extensive project analysis and design documents. In XP, you create working software from the very start. This book is an essential guide to anyone who's working in XP shops or who might be interested in what this innovative, iterative software process can offer. --Richard Dragan
Topics covered:Introduction to planning Risk management in software `Driving` as a metaphor for software development Roles for software development: business vs. technical people Four variables for project planning: cost, quality, time, and scope Predicting future programmer productivity, based on past performance Project scope and estimation The XP process: software releases, iterations, stories, collecting, and writing stories (features) Hints for ordering features Tips on planning and status meetings Using visual graphs to monitor project progress Tracking and fixing bugs Project red flags
User review
Objective overview of XP planning
Using a very objective and simple approach, the book presents the xp way of planning in a very easy and enjoyable way. It does not contain much practical advice, but it is an excellent starting point for someone who is not familiar with xp and its practices. After reading this book one should definitely look for `Agile Estimating And Planning` from Mike Cohn. It contains a more thorough approach on the subject.
User review
Begin Your XP Journey Here
Well, I had been tentative about spending time investigating the meaning of `Extreme Programming`, based primarily on what I consider to be a name that smacks of jargon, and because I thought that the audience for this development approach was young hip gamer-types who wanted to develop business applications! I now appologize to those who synthesized the techniques (although I still consider the name to be unfortunate, sorry). I am optimistic that this approach to development will solve many of the problems that I have faced over the years, and that this solution is much simpler than I could have dreamed of! This book is just 130 pages, and the techniques are clearly, succinctly, and I think expertly described by Kent and Martin. The level of humor is good, and the practicality of the solution is clear.
User review
crackles with ideas and fleshes out more of XP
Kent Beck and Martin Fowler have to be something of a `dream team` for a computer book. Not only was this book informative and interesting, but I actually enjoyed reading it. The book crackles with ideas and sparkles with a subtle wit.
The content of the book covers all aspects of planning, managing and tracking progress on an XP (Extreme Programming) project and is a worthy companion to Kent Beck's anthemic XP Explained. Hard stuff missed out from the earlier work such as how to estimate how long things will take, how to write user stories and how to organize the details of iterations and releases is explained in a straightforward way. It also introduces a few new key XP concepts, showing that this radical methodology didn't spring fully formed into the mind of Beck, but is still evolving. One such key is `Yesterdays Weather`, the idea that you can't go far wrong by using past performance as an initial guess for future results.
If you are at all intrigued by the new `agile` methodologies, read XP Explained and then this one. Then buy a few more copies for your management.
User review
Excellent book
This book lays out the point of planning, the approach taken, and the steps to do.
This book has a lot of content not found in any other XP book that I own. The gold nuggets in here are useful for project management for years to come. It's a 5 star for sure.
User review
How exactly to plan XP?
This book is very valuable if you already started to practice Extreme Programming. It contains a very encouraging foreword by Tom DeMarco. The first nine chapters are introductory, and you may skip them if you read the XP Manifesto `Extreme Programming Explained` by Kent Beck. Chapters from ten to twenty three contain valuable information not found in any other XP-related book.
- How exactly to plan releases? What if frequent releases aren't appropriate and marketing demands to release once a year?
- How exactly to write user stories, and how to handle them? Although the reader may find some sample stories in `Extreme Programming Installed` by Ron Jeffries, Ann Anderson and Chet Hendrickson, the stories in the `Planning Extreme Programming` are used as core elements in the whole planning process, shown as example.
- How exactly to build the iteration plan and the release plan? How to track an iteration?
I would also like to recommend `Extreme Programming Applied: Playing to Win` by Ken Auer, Roy Miller, Ward Cunningham. I think this is the most practical book on XP ever written.
I would also like to recommend the titles about individual XP aspects:
- Design Improvement: `Refactoring: Improving the Design of Existing Code ` by Martin Fowler;
- Test-Driven Development: `Test Driven Development: By Example ` by Kent Beck;
- Sustainable Pace: `Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency` by Tom DeMarco;
- Pair Programming: `Pair Programming Illuminated` by Laurie Williams and Robert Kessler;
- Whole Team: `Agile Software Development` by Alistair Cockburn;
- Planning Game: `Planning Extreme Programming` by Kent Beck, Martin Fowler;
- Small Releases: `Software Project Survival Guide` by Steve C McConnell.
