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.
Extreme Programming (XP) is a flexible programming discipline that emphasizes constant integration, frequent small releases, co 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 specificand often misunderstoodtopics, 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 About the Author
Giancarlo Succi has applied the XP methodology to various projects. He is an organizer of the main XP conferences held thus far. Michele Marchesi has applied the XP methodology to various projects. He is an organizer of the main XP conferences held thus far. 0201710404AB08072002
Excerpt. © Reprinted by permission. All rights reserved.
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.
