Extreme Programming Examined [Paperback]

Giancarlo Succi (Author), Michele Marchesi (Author)

Book Description

Series: XP | Publication Date: May 23, 2001

Extreme Programming (XP) may be the world's hottest software methodology: a lightweight, programmer-friendly approach that is delivering breakthrough results in a wide range of projects worldwide. This book brings together the proceedings of the first global XP conference: the collected "best practices" wisdom from the world's leading XP practitioners. This collection brings together case studies, experiences, and research related to all aspects of XP. It starts with the foundations, then moves on to process, practices, tool support, experiences, and the future: opportunities to apply XP in an even wider range of projects and applications. Among the many highlights: Martin Fowler's discussion of the role of design in XP methodologies; new insights into scalability and organization; an in-depth analysis of XP pair programming; new attempts to integrate XP with UML; and exciting new approaches to rapid modeling of software systems. For software professionals concerned with accelerating software development and improving software quality throughout their organizations.

Editorial Reviews

From the Inside Flap

Only geniuses can make difficult things simple, while any idiot can make a simple task difficult! Albert Einstein used to say something like that and we think that it applies quite well to extreme programming. Extreme programming –aka XP, (and other flexible methodologies) are an extreme attempt to dramatically simplify the process of developing software systems, focusing on what delivers value: the requirements for the system and the code that implements the system. There isn't much else!

In extreme programming everything starts with the requirements in the form of user stories. The customers deliver and prioritize the user stories. The developers analyses such stories and write tests for them.

... and everything ends with code. The code is developed in pairs of developers to increase quality. The code is refactored to make it simpler. The code is tested against requirements, constantly.

... and there is nothing in between!

Both requirements and code are subject to a careful scrutiny: as mentioned, the code does exactly what the user stories tell and nothing more and is always maintained to highest possible form.

This collection contains experiences in extreme programming and other flexible methodologies. It discusses what is in extreme programming -requirements and code, and how we can improve it.

The flow of the topics in the volume is top down. We start with the foundations, then we move to process, practices, tool support, experiences, to end with possible new avenues for exploration.

The volume starts with a discussion of the essence of XP and other flexible methodologies. Martin Fowler argues about the role of design. Peter Merel synthesizes the principles of XP.

 

The second section focuses on methodologies and processes. After a discussion of the value system of XP by Dirk Riehle and other methodologies and of the role of just-in-time software development by Alistair Cockburn, a comprehensive analysis of frameworks and other large software development practice take place through the contributions of Lars-Göran Andersson, Mark Collins-Cope, Carsten Jacobi, Even-André Karlsson, Martin Lippert, Hubert Matthews, Stefan Roock, Bernhard Rumpe, Henning Wolf, and Heinz Züllighoven.

In the third section, several authors attempt to combine what other people consider not compatible: flexible methodologies with UML. Jutta Eckstein and Rolf Katzenberger compare the Unified Software Development Proces (USDP) to XP; Michele Marchesi and Giuliano Armano present experience in the field inside newly created companies. Marko Boger, Toby Baier, and Frank Wienberg detail an interesting approach to fast modeling software systems. Focardi and the two of us explain why XP is different using the formalism of stochastic graphs. Joshua Kerievsky conciliates design patterns with XP.

The fourth section contains experiences and consideration on three key practices of XP: pair programming (Alistair Cockburn and Laurie Williams), testing (Philip Craig, Steve Freeman, Peter Gassmann, Tim Mackinnon, and Kevin Rutherford), and refactoring (Neelam Soundarajan).

The fifth section reviews existing tools to support pair programming with focus on refactoring (Ralph Johnson); XP specific team support (Jim des Rivières, Erich Gamma, Ivan Moore, Kai-Uwe Mätzel, Jan Schümmer, Till Schümmer, André Weinand, and John Wiegand) testing – (Renato Cerqueira and Roberto Ierusalimschy).

Karl Boutin, Michael Kircher, Manfred Lange David Levine, Peter Sommerlad, and Don Wells present their experiences in XP in section 6.

Champagne at the end! Sparkling ideas on how to address some terrifying aspects of XP are presented in the end of the book! Christian Wege and Frank Gerhardt outline their approach to teaching XP. Arie van Deursen, Tobias Kuipers, and Leon Moonen address the issue of legacy code. Paolo Predonzani, Giancarlo Succi, and Tullio Vernazza discuss how to handle the management of variants in an extreme environment. The inherent extreme flexibility of software agents is discussed by Luigi Benedicenti, Raman Paranjape, Kevin Smith. Jason Yip, Giancarlo Succi, Eric Liu explain how several products developed using XP can be organized in a line of production, without becoming heavy weighted.

 

From the Back Cover

Extreme Programming (XP) is a flexible programming discipline that emphasizes constant integration, frequent small releases, continual customer feedback, and a teamwork approach. With considerable fanfare, XP has taken the mainstream of software engineering by storm. It has been adopted by an increasing number of development organizations worldwide. At the first annual Conference on Extreme Programming and Flexible Processes in Software Engineering, held in Italy in June of 2000, leading theorists and practitioners came together to share principles, techniques, tools, best practices for XP, and other flexible methodologies.

Extreme Programming Examined gathers the 33 most insightful papers from this conference into one volume. With contributions from several visionaries in the field, these papers together represent the state-of-the-art in XP methodology as well as a glimpse at the future of XP.

Individual articles are organized into cohesive categories that allow the reader to learn and apply this material easily. Extreme Programming Examined addresses some of the most vital issues facing XP developers. It offers a high-level examination of XP programming theory and discusses specific methodologies, processes, techniques, tools, and case studies. You will find articles exploring specific—and often misunderstood—topics, including:

• The role of design in XP
• Just-in-time software development
• XP frameworks
• Combining flexible methodologies with the UML, including a novel approach to fast modeling software systems
• Design patterns and XP
• Tools to support pair programming, testing, and refactoring
• Case studies illustrating the transition to XP, XP in R&D, and the integration of XP into an existing C++ project
• An innovative approach to teaching XP
• Bringing legacy code into XP
• Flexible manufacturing for software agents
• Management of variants in an extreme environment
• Integrating XP with software product lines

Extreme Programming Examined is a valuable resource that offers the practical techniques and deeper understanding that developers and programmers need to initiate and implement successful XP projects.

0201710404B06042001

See all Editorial Reviews

Product Details

• Paperback: 592 pages
• Publisher: Pearson Education; 1st edition (May 23, 2001)
• Language: English
• ISBN-10: 0201710404
• ISBN-13: 978-0201710403
• Product Dimensions: 9.2 x 7.4 x 1 inches
• Shipping Weight: 1.8 pounds
• Average Customer Review: 4.0 out of 5 stars  See all reviews (4 customer reviews)
• Amazon Best Sellers Rank: #2,656,714 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

28 of 29 people found the following review helpful:

4.0 out of 5 stars A collection of papers that will sway you to XP, June 16, 2001

By 

Charles Ashbacher (Marion, Iowa United States) - See all my reviews
(TOP 500 REVIEWER)    (VINE VOICE)    (HALL OF FAME REVIEWER)   

This review is from: Extreme Programming Examined (Paperback)

When I first read a book about Extreme Programming (XP) a little over a year ago, I was unimpressed. Part of this was due to what I viewed as the inaccuracy of the title, but most of my skepticism was based on scalability and personality conflicts. XP is a style of development where programmers are paired and the program is built by iterating the sequence: small change, construct test, perform test, debug. In projects that involve millions of lines of code, I could not see how this would work. Granted, it is possible for the team to test the actions of their code, but performing such iteration testing on a package where the work of several programming teams has been merged seemed to be too tall an order.
The second and more fundamental difficulty I see is the act of pairing the programmers so that they can work together. In any set of developers, there will generally be a wide set of skills and personalities. Splitting that set into pairs that are matched so that they can effectively work together requires a wisdom that exceeds that of Solomon combined with a stick much bigger around than your thumb. As a veteran observer of the "style wars" at several companies, I have seen fierce arguments over where to put a curly brace, so the idea of paired teams of programmers working together all day every day seemed beyond expectations.
However, as I continue to read more, my skepticism fades and I am slowly moving to a conversion, although I am not there yet. The articles in this book moved me a good deal closer to that level, as some of the papers address those very concerns. Several of them deal very specifically with the problem of using XP in very large projects, describing in detail how it can be used and where it is of dubious value. The other problem, that of personal differences, is also examined but the arguments are not as convincing. One paper in particular describes a situation where the programmers were initially skeptical but after being paired, spontaneously began working well together. While I certainly will accept that it is possible, my experience indicates otherwise. I need to see more evidence before I will be convinced that this is an obstacle that can easily be overcome.
The basic principles of XP make a great deal of sense, although some of the arguments in favor have been known for many years. Evidence is put forward that pairing programmers causes an increase in productivity in both that is higher than if they worked separately. I have yet to meet a programmer who has not struggled for hours trying to find a bug only to show it to a colleague and have them find it in a matter of seconds. Sometimes, the action of simply talking about the problem is enough for our mental guards to be dropped long enough for the solution to appear.
Despite having already read three books on XP, I learned a great deal from the papers in this one. XP holds a great deal of promise, but like all other development strategies, it has limitations. If you are considering adopting it in your shop or are simply interested in what it is, then this book will help show you the way.

8 of 10 people found the following review helpful:

4.0 out of 5 stars A welcome look beyond evangelism, August 5, 2001

By 

"gbenett" (West Newton, MA United States) - See all my reviews

This review is from: Extreme Programming Examined (Paperback)

This is the book to read after you understand enough XP to question its radicalism. Does it really make sense to abandon UML-style modeling? No, suggests OO guru Martin Fowler in an essay reconciling XP with heavyweight design. Is XP's Planning Game the ideal way to bring customers and IT management together? Maybe, but at Ford Motor Company it was "a total disaster."

Nearly all of the essays in this uneven but illuminating text advance XP's cause, not through blunt evangelism, but by questioning the new process and building bridges to it from traditional practice.

I happen to believe in class diagrams and other OO model artifacts. In contrast to other books in the Addison-Wesley XP Series, Examined shows that there plenty of smart, like-minded professionals out there striving to gain XP's benefits without jettisoning their tried-and-true belief systems. The sections "Methodology and Practice," "Flexible Techniques and UML" and "Practical Experiences," consisting of five essays each, were especially useful in this regard. I found other sections, notably the one on "Tools for XP Development," less distinctive.

While XP's 'extremity' may be a selling point in some circles, in others it is sure to provoke the same kind of immune response as 'hacker'. If you feel itchy at the prospect of spike solutions and pair programming, "Extreme Programming Examined," with its collection of balanced voices seeking rapproachement, is the book for you.

3 of 5 people found the following review helpful:

5.0 out of 5 stars Many outstanding contributions, July 6, 2001

By A Customer

This review is from: Extreme Programming Examined (Paperback)

Unlike the other books of Addison Wesley's The XP Series, this is a collection of 33 papers, presented at an XP conference held in 2000. As one might expect, not all 33 papers are of the highest quality, and some of them are of interest only to a few specialists.

However, the book includes many outstanding contributions covering more advanced aspects of XP than the other books of the XP series. In my opinion, these are the chapters written by M. Fowler, P. Merel, D. Riehle, M. Collins-Cope, J. Eckstein, J. Kerievsky, A. Cockburn, T. Mackinnon, R. Johnson, T. Schummer, D. Wells, K. Boutin and A van Deursen (I quote only the first author). Many of them will become XP classics.

Also the Parts on XP and UML, Testing, and Practical Experiences are full of useful ideas and hints.

Overall, I found the book very helpful: it gave me all what expected, and more.