What is Extreme Programming?
Extreme Programming (XP) is a discipline of software development based on values of simplicity, communication, feedback, and courage. It works by bringing the whole team together in the presence of simple practices, with enough feedback to enable the team to see where they are and to tune the practices to their unique situation. As a type of agile software development, it advocates frequent “releases” in short development cycles, which is intended to improve productivity and introduce checkpoints where new customer requirements can be adopted.
The Rules of Extreme Programming
- User stories are written.
- Release planning creates the release schedule.
- Make frequent small releases.
- The project is divided into iterations.
- Iteration planning starts each iteration.
- Give the team a dedicated open work space.
- Set a sustainable pace.
- A stand up meeting starts each day.
- The Project Velocity is measured.
- Move people around.
- Fix XP when it breaks.
- Choose a system metaphor.
- Use CRC cards for design sessions.
- Create spike solutions to reduce risk.
- No functionality is added early.
- Refactor whenever and wherever possible.
- The customer is always available.
- Code must be written to agreed standards.
- Code the unit test first.
- All production code is pair programmed.
- Only one pair integrates code at a time.
- Integrate often.
- Set up a dedicated integration computer.
- Use collective ownership.
- All code must have unit tests.
- All code must pass all unit tests before it can be released.
- When a bug is found tests are created.
- Acceptance tests are run often and the scoreis published.
The Values of Extreme Programming
Extreme Programming (XP) is based on values. XP isn’t really a set of rules but rather a way to work in harmony with your personal and corporate values. Start with XP’s values listed here then add your own by reflecting them in the changes you make to the rules.
Simplicity: Extreme Programming encourages starting with the simplest solution. Extra functionality can then be added later. This will maximize the value created for the investment made to date. We will take small simple steps to our goal and mitigate failures as they happen. We will create something we are proud of and maintain it long term for reasonable costs.
Communication: Everyone is part of the team and we communicate face to face daily. We will work together on everything from requirements to code. We will create the best solution to our problem that we can together.
Feedback: We will take every iteration commitment seriously by delivering working software. We demonstrate our software early and often then listen carefully and make any changes needed. We will talk about the project and adapt our process to it, not the other way around.
Respect: Everyone gives and feels the respect they deserve as a valued team member. Everyone contributes value even if it’s simply enthusiasm. Developers respect the expertise of the customers and vice versa. Management respects our right to accept responsibility and receive authority over our own work.
Courage: We will tell the truth about progress and estimates. We don’t document excuses for failure because we plan to succeed. We don’t fear anything because no one ever works alone. We will adapt to changes when ever they happen.
Tha advantages of Extreme Programming
Extreme Programming improves a software project in five essential ways; communication, simplicity, feedback, respect, and courage. Extreme Programmers constantly communicate with their customers and fellow programmers. They keep their design simple and clean. They get feedback by testing their software starting on day one. They deliver the system to the customers as early as possible and implement changes as suggested. Every small success deepens their respect for the unique contributions of each and every team member. With this foundation Extreme Programmers are able to courageously respond to changing requirements and technology.
Watts S. Humphrey, a widely respected authority on software process improvement, and a long-time senior manager of software development at IBM, is a Fellow at the Software Engineering Institute at Carnegie Mellon University. He enumerates a list of the advantages for using XP.
- Emphasis on customer involvement: A major help to projects where it can be applied.
- Emphasis on teamwork and communication: As with the TSP, this is very important in improving the performance of just about every software team.
- Programmer estimates before committing to a schedule: This helps to establish rational plans and schedules and to get the programmers personally committed to their schedules-a major advantage of XP and TSP.
- Emphasis on responsibility for quality: Unless programmers strive to produce quality products, they probably won’t.
- Continuous measurement: Since software development is a people-intensive process, the principal measures concern people. It is therefore important to involve the programmers in measuring their own work.
- Incremental development: Consistent with most modern development methods.
- Simple design: Though obvious, worth stressing at every opportunity.
- Frequent redesign, or refactoring: A good idea but could be troublesome with any but the smallest projects.
- Having engineers manage functional content: Should help control function creep.
- Frequent, extensive testing: Cannot be overemphasized.
- Continuous reviews: A very important practice that can greatly improve any programming team’s performance (few programmers do reviews at all, let alone continuous reviews).
Tha disadvantages of Extreme Programming
Extreme programming’s initial buzz and controversial tenets, such as pair programming and continuous design, have attracted particular criticisms, such as the ones coming from McBreen and Boehm and Turner. Many of the criticisms, however, are believed by Agile practitioners to be misunderstandings of agile development.
In particular, extreme programming is reviewed and critiqued by Matt Stephens’s and Doug Rosenberg’s Extreme Programming Refactored.
- A methodology is only as effective as the people involved, Agile does not solve this
- Often used as a means to bleed money from customers through lack of defining a deliverable
- Lack of structure and necessary documentation
- Only works with senior-level developers
- Incorporates insufficient software design
- Requires meetings at frequent intervals at enormous expense to customers
- Requires too much cultural change to adopt
- Can lead to more difficult contractual negotiations
- Can be very inefficient—if the requirements for one area of code change through various iterations, the same programming may need to be done several times over. Whereas if a plan were there to be followed, a single area of code is expected to be written once.
- Impossible to develop realistic estimates of work effort needed to provide a quote, because at the beginning of the project no one knows the entire scope/requirements
- Can increase the risk of scope creep due to the lack of detailed requirements documentation
- Agile is feature driven; non-functional quality attributes are hard to be placed as user stories
Extreme Programming is a discipline of software development based on values of simplicity, communication, feedback, and courage. It implements a simple, yet effective environment enabling teams to become highly productive. The team self-organizes around the problem to solve it as efficiently as possible.
- Don Wells, ExtremeProgramming.org. http://www.extremeprogramming.org/
- Ronald E. Jeffries, XProgramming.com. http://xprogramming.com/