From the Book: PREFACE: This book is a case study describing a Web-based software project developed using a development process known as Extreme Programming (XP). The project is real, driven by the needs of a real customer. The artifacts presented in this book are real. The code is real, the user stories are real, and the anecdotes are real. We videotaped all our meetings and development episodes so that we maintained an honest and objective chronicle of the events. We wanted our readers to have as true-to-life an experience as possible. At first we thought we might have to keep the scope of the project artificially small enough to fit into this book. However, it turned out that the size of the first XP release of the project was both useful to our customer and the ideal size for this book. So even the size of the release is real. Before this project, none of us had used XP in its entirety. So this book also chronicles the adoption of XP by a team that is relatively unfamiliar with it. Our goal in writing this book is to help demonstrate how a real XP project works. We have chosen to do this by example, rather than by explanation. The examples are real. They chronicle the thought processes of the team as it struggles with the concepts of XP. You will see us make mistakes and then correct them. You will see us have insights and then find them to be invalid. You will see the ebb and flow of a real development project. This book is written for developers, managers, customers, and anyone else involved in the development of software. We welcomeanyfeedback and can be reached at the following e-mail addresses: James [email protected] Robert C. [email protected]
Cited By
- Karlsson L, Höst M and Regnell B Evaluating the practical use of different measurement scales in requirements prioritisation Proceedings of the 2006 ACM/IEEE international symposium on Empirical software engineering, (326-335)
- Newkirk J Introduction to agile processes and extreme programming Proceedings of the 24th International Conference on Software Engineering, (695-696)
Index Terms
- Extreme Programming in Practice
Reviews
Alexander T Tzanov
The title of this book suggests it is a practical guide to extreme programming (XP). The contents, however, actually present the authors’ experiences and lessons learned in the development of an XP project. The book is written in a verbose style by working developers, and its value is limited to other developers. The underlying XP values such as evolutionary design over up-front design, good code over diagrams, quick iterations with customer feedback, and human communications over paper are discussed only in the framework of the authors’ project. The book is organized into 15 chapters, an index, and an appendix. Each chapter concludes with a short summary of lessons learned, as well as an analysis of mistakes and good assumptions. Since the book is about a particular experience, no references are provided. The first two chapters are extremely short, and serve as an extended introduction to the book. The authors introduce their Web tracking project, point out the differences between XP and traditional widespread programming practices, and provide some basic definitions. In the remaining chapters, the authors provide a step-by-step discussion of various aspects of XP programming, in the scope of their project development. Chapter 3 discusses the phases of an XP project in general: exploration, spike (very fast experiments that can provide accurate information at any stage of development), release planning, iteration planning, and development. Chapter 4 focuses on exploration, and shows the authors’ approach to fulfilling the underlying XP aim: having the business team focus on business decisions, and the technical team focus on technical decisions. The authors’ chosen technique was to collect a list of “user stories” via open discussion with users, and to use this list as skeleton for the first project release. Chapter 5 considers the involvement of a previously defined list of user stories in project planning, and introduces new XP elements: story prioritization and velocity. Chapter 6 focuses on the establishment of the first iteration plan. The authors discuss the practical aspects of breaking stories into tasks, the duration of the iteration cycle, and tasks estimation, and emphasize the possible traps and errors in this process. The most interesting part of the book is in chapters 7 through 15. Chapters 7 and 8 discuss two tasks: the first iteration task (chapter 7) and the login task (chapter 8). With the help of software listings, the authors provide an analysis of what they did well and what went wrong during this development phase. Chapter 9 brings to life another aspect of XP software development: refactoring. Duplication of code is not allowed in XP, so the authors provide listings of original and refactored servlets, together with a discussion of the implementation of various methods for optimizing the code, such as template and pull up. The main question is if refactoring in XP can be avoided by using up-front design. The authors’ conclusion is that up-front design is not particularly good at predicting the structure of the code. The lesson learned in chapter 10 was the value of backing into a solution from initial premises and constraints. This approach was inspired by the fact that most errors were due to bad guessing, which must be avoided. The supplemental listings present step-by-step refactoring of the code of the task registration servlets, together with implementation of the spoofing technique. The other vital part of the project’s development was the refactoring of tests and databases, which is dealt with in chapter 11. The important conclusion gained via the authors’ experience, and supported with provided code listings, is that anticipation of the structure of the database in an early part of the iteration is not useful, since it gives a false sense of security. The use of spoofing technique might also be helpful. Chapter 13 brings to life a discussion of misunderstanding between customer and programmer, and stresses the fact that the misunderstanding could have been discovered much earlier if the stories had been written as XP recommends. Chapter 14 analyzes the final steps: finishing the release. The lesson here is the authors’ analysis of what the development process would have looked like if it had not been an XP project, illuminating the benefits of XP programming. The final chapter, 15, enumerates the experience gained and projects that experience onto larger projects. The chapter finishes with a summary of the lessons learned in the project. There are many comparable books in this category, which the authors vaguely mention in their text. In particular, any software developer, IT manager, or researcher who needs a comprehensive understanding of XP must consider Fowler [1] and Beck [2] as appropriate starting points. Online Computing Reviews Service
Access critical reviews of Computing literature here
Become a reviewer for Computing Reviews.