XP in a Nuthouse (Oops, We Mean Nutshell)

https://www.link.springer.com/content/pdf/10.1007%2F978-1-4302-0810-5_1.pdf

Software development projects can be fun, productive, and even daring. Yet they can consistently deliver value to a business and remain under control.Extreme Programming (XP) was conceived and developed to address the specific needs of software development conducted by small teams in the face of vague and changing requirements. This new lightweight methodology challenges many conventional tenets, including the long-held assumption that the cost of changing a piece of software necessarily rises dramatically over the course of time. XP recognizes that projects have to work to achieve this reduction in cost and exploit the savings once they have been earned.Fundamentals of XP include: Distinguishing between the decisions to be made by business interests and those to be made by project stakeholders. Writing unit tests before programming and keeping all of the tests running at all times. Integrating and testing the whole system--several times a day. Producing all software in pairs, two programmers at one screen. Starting projects with a simple design that constantly evolves to add needed flexibility and remove unneeded complexity. Putting a minimal system into production quickly and growing it in whatever directions prove most valuable.Why is XP so controversial? Some sacred cows don't make the cut in XP: Don't force team members to specialize and become analysts, architects, programmers, testers, and integrators--every XP programmer participates in all of these critical activities every day. Don't conduct complete up-front analysis and design--an XP project starts with a quick analysis of the entire system, and XP programmers continue to make analysis and design decisions throughout development. Develop infrastructure and frameworks as you develop your application, not up-front--delivering business value is the heartbeat that drives XP projects. Don't write and maintain implementation documentation--communication in XP projects occurs face-to-face, or through efficient tests and carefully written code.You may love XP, or you may hate it, but Extreme Programming Explained will force you to take a fresh look at how you develop software. 0201616416B04062001

/pdf/extreme-programming-explained-embrace-change-bu7gfti9qv.pdf

Extreme Programming Explained: Embrace Change

From the Book:
Preface How much would you pay for a software development team that would do what you want? Wait, don't answer yetwhat if they could also tell you how much it would cost, so that you could decide what to do and what to defer, on your way to your deadline? You also get quality software, a robust array of tests that support the project through its entire lifecycle, and an up-to-date, clear view of project status. Best of all, you get the ability to change your mind about what you want, at any time. 
There aren't any silver bullets in software development, and there probably never will be. However, Extreme Programming is a simple set of common-sense practices that, when used together, really can give you much of what you just read in the paragraph above. In this book, we tell you what the XP practices are, and how to install them in your project. 

We are software developers. We have been involved in many successful projects, and even in some that weren't so successful. The successful ones were a lot more fun, for us, and for our customers. The unsuccessful ones have taught us a great deal about software development. 

We have had the privilege of working on a great project, with a great teacher, Kent Beck. We helped shape the software process named Extreme Programming, XP for short. Since then, we have been helping everyone who will listen to learn from our experience. 

The first book in the Extreme Programming series, Extreme Programming Explained , covers the reasoning behind the XP process. Based on our experience on the original XP project (and others), this book describes what makes XP work, day to day and monthto month. 

Successful software development is a team effortnot just the development team but the larger team consisting of customers, management, and developers. Extreme Programming is a simple process that brings these people together and helps them to succeed together. XP is aimed primarily at object-oriented projects using teams of a dozen or fewer programmers in one location. We would use XP for both in-house development and development of shrink-wrapped software. The principles of XP apply to any moderately sized project that needs to deliver quality software rapidly and flexibly. 

XP is about balancing the needs of customers with the abilities of programmers, and about steering (managing the project to success). If you're a customer, a programmer, or a manager, here's what this book offers you: 

Customerswho have software that needs to be developed: you will learn simple, effective ways to communicate what you need, to be sure that you are getting what you need, and to steer the project to success. You will learn that you can change your mind and still get what you need on time. 

Programmerswho, on an XP project, define the architecture, design the system, and write the tests and the code that support them: you will learn how to deliver business value quickly, how to deal with changing requirements, and how to build customer confidence and support. You will learn to build for tomorrow by building only what you need today. 

Managerswho control the project resources: you will learn how to measure project progress, how to measure quality, and how to answer the all-important question, "When will you be done?" You will learn an important truth of managementto use the programmers' actual performance to predict completion. 

Customers, programmers, and managers must all work together to build the system that's needed. Chapter 1, Extreme Programming, will describe the roles, rights, and responsibilities, and provide a road map for the book. Dig right in. We're sure that the XP practices can improve your projects, as they have ours.

Extreme Programming Installed

Use Case Driven Object Modeling with UML: a Practical Approach (Addison-Wesley Object Technology Series)

Preface. Theory, in Practice. The Premise. Acknowledgments. 1. Introduction. A Walk (Backwards) Through the ICONIX Process. Key Features of the ICONIX Process. Process Fundamentals. The Process in a Nutshell. 2. Domain Modeling The Key Elements of Domain Modeling. The Top 10 Domain Modeling Errors. Exercises. 3. Use Case Modeling. The Key Elements of Use Case Modeling. The Top 10 Use Case Modeling Errors. Exercises. 4. Requirements Review. The Key Elements of Requirements Review. The Top 10 Requirements Review Errors. 5. Robustness Analysis. The Key Elements of Robustness Analysis. The Top 10 Robustness Analysis Errors. Exercises. 6. Preliminary Design Review (PDR). The Key Elements of Preliminary Design Review (PDR). The Top 10 PDR Errors. 7. Sequence Diagrams. The Key Elements of Sequence Diagrams. The Top 10 Sequence Diagramming Errors. Exercises. 8. Critical Design Review (CDR). The Key Elements of Critical Design Review (CDR). The Top 10 CDR Errors. Appendix. Index. 0201432897T04092002

Use case driven object modeling with UML: a practical approach

From the Book:
Extreme Programming sounds great—can we do it without changing our process?

When I first heard about Extreme Programming in May 1998 I could see that it was going to be controversial. It was immediately obvious from the wide range of reactions that were expressed to two talks given by Kent Beck and Ron Jeffries at a seminar on “Developing Software with Objects” in Oslo. (Hosted by Den Norske Dataforening on 13 May, 1998) Many developers seemed to be attracted to it, but others in the room challenged the ideas and concepts behind Extreme Programming.

Personally my reactions were mixed. It sounded like it would be a fun approach to software development and it didn’t sound like it was applicable to the kinds of projects that I was involved in. Admittedly, my initial reservations were about how easy it would be to sell the approach, but as I inquired deeper into Extreme Programming I came to realize that there are fairly stringent preconditions for teams that wish to adopt and use XP. It seems to me that many of the reactions to Extreme Programming can be explained by the fit between these preconditions and the particular project circumstances that a person has experienced.

This book sets out to question Extreme Programming in an attempt to understand and explain the controversy that surrounds Extreme Programming. My goal for this book is to allow you, the reader, to determine if Extreme Programming is applicable and appropriate for your projects, to investigate what lessons can be learned from Extreme Programming and to enable you to be more reflective about your software development practices.

Before getting down to that I must firstexplain my biases. As a developer I am attracted towards the ideas behind XP, mainly because most of the developers I have talked to that have worked on XP projects have really enjoyed the experience. I am also a strong fan of XP style unit testing and have introduced JUnit (www.junit.org) to many project teams. Although I have never worked on a full XP project, I have worked in a team that initially claimed that it was going to be doing XP, but actually turned out to be doing something that was vaguely related to some of the XP practices.

As much as is possible I have tried to present both sides of the debate surrounding Extreme Programming without getting into the continual flame-fest that discussions on usenet newsgroups and email lists often contain. 

I have written this book as a practical guide for four different audiences:
people who are thinking of adopting Extreme Programming 
people who are resisting the idea of adopting Extreme Programming, 
people who are looking for alternatives to Extreme Programming
people who are interested in improving their current software development process



As a practical guide this book is focused on identifying issues surrounding software development and discussing how Extreme Programming interacts with these issues. As this is a practical guide, you will not find much in the way of detailed studies and experimental data. This book focuses on clarifying the issues so that you, the reader, can determine the fit between Extreme Programming and your specific circumstances.
Adopting Extreme Programming
All processes are situational. Software development is not a mechanical process and as such you will never be able to adopt a process without doing some adapting to fit with your circumstances and team. Before adopting Extreme Programming you need to have a deep understanding of the values that drive it so that the adaptations you make match the overall spirit of XP.

This book looks back to the roots of XP to enable you to understand the underlying software development issues so that you can better assess how XP will fit your organization. This book will also expose you to alternate approaches that might be a better fit.
Resisting Extreme Programming
Extreme Programming is a different kind of software development process, it is one that many programmers actually want to use. All too often however this means that some programmers end up pushing the idea of adopting XP when for one reason or another it does not really fit the organization. 

This book provides the questions you need to ask to determine whether XP really does fit the needs and circumstances of your organization. Hopefully it will also allow you to identify the issues with your current process that caused XP to be raised as a potential alternative in the first place. Then, rather than shooting the messenger or dismissing the message, the book asks the question “What can we learn from XP?”
Looking For Alternatives To Extreme Programming
Extreme Programming is a great fit for some projects and organizations, but one size does not fit all. There are many other software development approaches, and with all of the exposure that Extreme Programming is getting, these alternatives are getting somewhat lost. Using an Agile Methodology does not necessarily mean using Extreme Programming.

Questioning Extreme Programming attempts to uncover the issues that are driving the creation of new approaches to software development. By exposing these issues I hope to spur software developers and their managers to create alternative approaches that build on the strengths of Extreme Programming while incorporating the strengths of the other approaches.
Improving Your Current Software Development Process
Adopting a new software development process can be hard. The organization has to learn how to effectively apply the new process and there is the transition period when some projects are using the new process while the rest are still using the old process. Sometimes it just makes sense to retain your existing process and to try to improve it by dropping parts, changing parts and adding new parts. 

By continually asking the question “What can we learn from XP?” this book highlights different ideas that could potentially be applied within the context of a different process. The resulting hybrid will not be XP, but then again, that is not the goal. By adopting the Extreme Programming mindset of continually reflecting on, and tinkering with, the process, you open up the possibility of creating your own optimized process.
Why You Should Read This Book
The way that we develop software is changing. Yes, people have always claimed that the IT industry has been a real driver for change, but until recently that change has only really shown up in the hardware and software. The way that we develop software has been remarkably resistant to change. 

Indeed Watts S. Humphrey spoke for many methodologists in his article, “Why Don't They Practice What We Preach? ” when he said

“One of the most intractable problems in software is getting engineers to use effective methods.” http://www.sei.cmu.edu/publications/articles/practice-preach/practice-preach.html

Many proponents of Extreme Programming would claim that the problem is no longer intractable - lots of programmers would jump at the chance of using XP. Indeed many developers are very keen to experiment with and try out new ways of developing software. It seems as if developers are beginning to see that things have changed. Jim Highsmith probably summed this up best when he said 

“We must challenge our most fundamental assumptions about software development.” Highsmith, 2000, p13

Questioning Extreme Programming invites you to take up that challenge.
Acknowledgments
First I would like to thank Kent Beck, Ward Cunningham and Ron Jeffries for starting the conversation around eXtreme programming. If nothing else they have managed to make software development methodologies interesting again. 

As usual, the team at Addison-Wesley was extremely supportive and enthusiastic about this projectRoss Venables, Mike Hendrickson, et. al. My reviewers seemed particularly gleeful this time, and although one expressed regrets that the book is not the flame-fest material he hoped for, all helped me to clarify my thoughts about Extreme ProgrammingAlastair Handley, Andy Hunt, Dave Thomas, Greg Klafki, Jens Coldewey, Jim Highsmith, Kent Beck, Miroslav Novak, Ron Jeffries and Rudy Wrench.

http://www.mcbreen.ab.ca/talks/ICE2002Questioning.pdf

XP in a Nuthouse (Oops, We Mean Nutshell)

References

Extreme Programming Explained: Embrace Change

Extreme Programming Installed

Use Case Driven Object Modeling with UML: a Practical Approach (Addison-Wesley Object Technology Series)

Use case driven object modeling with UML: a practical approach

Questioning Extreme Programming

Related Papers (5)

Cowboy: An Agile Programming Methodology for a Solo Programmer

Java Extreme Programming Cookbook

JDuck: building a software engineering tool in Java as a CS2 project

Comparing Selected Criteria of Programming Languages Java, PHP, C++, Perl, Haskell, AspectJ, Ruby, COBOL, Bash Scripts and Scheme Revision 1.0 - a Team CPLgroup COMP6411-S10 Term Report

Java in a Nutshell