Extreme Programming

Owned by Computer Science Department
Last updated: Jul 19, 2023
3 min read

Extreme programming (XP) is an agile development method that uses on-site customer collaboration, paired programming, and automated testing processes. XP is a widely used agile method focusing on simplicity, internal communications, and customer feedback. XP, presented by Beck in 1999, is one of the oldest agile methods. The advantages of XP are short iteration cycles, direct communication with an on-site customer, and continuous integration and testing. The disadvantages are that the practice requires minimal documentation and the method is unsuitable for reengineering projects. As a note, the XP method is challenging to use on large projects and projects of a critical nature. Although practiced before the concept of agile was defined, XP is an agile development process. 

 

Extreme Programming (XP) is a software development methodology that is intended to improve software quality and responsiveness to changing customer requirements. XP, like Scrum, is a type of Agile methodology which emphasizes close collaboration between the development team and the customer, frequent delivery of software, and flexibility to adapt to changing requirements.

XP involves several key practices:

  1. Pair Programming: In XP, developers work in pairs, with one developer writing code while the other observes and reviews. The two developers periodically switch roles. This approach is believed to increase code quality by facilitating immediate review and feedback.

  2. Test-Driven Development (TDD): In XP, developers write automated tests for a new feature before they write the code itself. They then write the minimum amount of code needed to pass the test. This practice helps ensure that all code is tested and promotes simplicity and confidence in the codebase.

  3. Continuous Integration: Developers integrate their work frequently, often multiple times a day, to detect integration issues as soon as possible. Each integration is verified by an automated build and automated tests.

  4. Refactoring: This is the practice of improving the design of existing code without changing its behavior. Refactoring is done regularly to improve the understandability of the code and reduce complexity.

  5. Simple Design: The focus here is on keeping the design of the system as simple as possible at all times. Unnecessary complexity is avoided. The design is allowed to evolve as the system grows.

  6. Collective Code Ownership: In XP, any developer can change any part of the codebase at any time. This is contrary to the practice of individual code ownership, where only the original developer can make changes. This practice promotes team-wide responsibility for the codebase.

  7. Customer Collaboration: An on-site customer or user representative is involved throughout the development process to provide feedback and steer the project based on business or market requirements.

  8. Sustainable Pace: Work hours should be kept at a level that is sustainable in the long run. Overly long hours of work can lead to burnout and mistakes.

  9. Planning Game: The planning game is an iterative approach to long-term and short-term planning conducted by the whole team and the customer representative. It includes determining the scope of the next release, breaking down features into small, estimable tasks, and planning the work for the next iteration.

These practices are intended to be used together. Removing any one practice can affect the efficacy of the others. The objective is to reduce the cost of changes in requirements by having multiple short development cycles, rather than one long one.

Paired programming can have an advantage over developers working independently. In paired programming, the driver and the navigator often change roles throughout the project. The benefits of paired programming are constant code review and the brainstorming of approaches during the code’s development. Programmers can quickly catch and resolve errors, thus producing better code using a collaborative approach. Additionally, pairing an expert programmer with an average or novice programmer provides mentorship to the novice. However, teaming individuals who have the same expertise can cause counterproductive work. Therefore, the benefits of paired programming can be more significant when developers have different skill levels or experience.