Differences between Scrum and XP

Scrum and eXtreme Programming (XP) are both Agile approaches on software development, and for that reason, are very much aligned. They share the concepts of iterative development, working software, release and iteration planning, daily meetings, retrospective, all elements of an Agile process. The are so aligned, that sometimes is difficult to distinguish between a team who is doing Scrum and another team who is doing XP.

There are however differences, some of them very subtle. One particular difference, which I consider the most important is related to their scope.

Scrum is in essence a set of management principles, practices and processes working together to complete a project (not just a software project although initially was developed for this purpose, but also for other types of projects). For that matter, Scrum does not prescribe any engineering practices.

On the other hand XP is a dedicated approach to software development. The name actually comes from the fact it takes all common aspects of a software development process and takes them to extreme (in a positive way). In this context XP comes with a set of engineering practices that it  prescribes like Test-Driven Development, Refactoring, Pair Programming, Continuous Integration.

Currently, all these practices eventually were adopted by teams which are using Scrum or Kanban, or other software development methodologies because they are so powerful and provide so much added value to the developed software. However, they were initially part of XP.

This generates a contradiction: on one hand, XP inherits everything that an Agile process is, including self-organization, self-coordination, team empowerment. On the other hand, it mandates some engineering practices, which comes in conflict with the previous statement. Although the practices have proven their value, it is important that each team discovers this value on their own; this is the only way they will actually produce the expected added value.

Another subtle difference between Scrum and XP is related to the way they are handling the product backlog.

XP has a  rigid approach, items are implemented in a strict priority order. Features are prioritized by the Customer (equivalent of Scrum Product Owner) and the team is required to work on them in that order.

On the other hand, Scrum Product Owner, although also sets priorities to the items, the team is actually deciding what will be implemented. Of course, following Agile principles, teams will almost always choose to implement the items in the order of their priority. However, a team has the flexibility to choose to implement other items further down the list for different reasons: perhaps they are tightly related to a high priority item already in development, or are small enough to complete the iteration plan, since the next item in the order of priority might be to big to fit the current iteration, or maybe the team already is working on the section of the code on which the lower priority item will also be implemented, so they are doing all the changes to that section at once.

Which of the two approaches is better is a long discussion. The flexibility introduced by Scrum might have positive effect in the sense that work is done more coherently, developing related items together, but also might encourage the teams to choose lower priority items and so affecting the whole purpose of the agile process and that is to deliver as much added value to the customer as possible, with every iteration.

Although both processes are using iteration there is an important difference between them: Scrum teams typically work in iterations (also called sprints) of 2-4 weeks, while XP teams work in iterations of one or two weeks long. This gives more flexibility to XP, because it can accommodate new changes more rapidly (is just a matter of few days) into working software, while Scrum team needs to wait sometimes a month before taking in consideration the new change.

Moreover, Scrum teams are not allowed to accept changes during their sprint. Whatever is planned at the beginning of the sprint is implemented (depending on the velocity), but nothing else is permitted to be added. XP teams are allowed to substitute items from iteration plan as long as the development has not been started yet on them, and the new feature has an equivalent size.

In essence, both approaches are following closely Agile principles. Elements from one methodology are used in the other without to a problem. The differences are mentioned because not to make a ranking (which one is better) but to see where each one fits better, or how to combine them. You can start with Scrum and adopt XP practices along the way.