Extreme Programming: Definition, Values, and Practices


The next step in programming is software development which involves project management. There are many tools, frameworks, and practices that team managers can choose from. Extreme programming, the main focus of this article, is an important software development framework for agile project managers.

Programming is the art of creating instructions by using machine-understandable code, like assembly code or machine code. High-level programming languages help to simplify the process. Although extreme programming has the term “programming” in its name, it’s not entirely about programming, it’s about management.

In this article, we will discuss the definition of extreme programming, its values, and practices.

What is Extreme Programming (XP)?

Extreme programming is a popular agile software development framework that aims to improve software quality and responsiveness to evolving customer requirements. It is most useful when:

            -> The software requirements are evolving, i.e. changing dynamically.

            -> The team is small.

            -> Automated unit and functional tests are available.

Because the use of extreme programming is specific, there are many situations when you should not use XP as it might be unproductive or even counterproductive. However, that shouldn’t deter you from implementing as many XP practices as possible.

What is Agile SDLC?

Agile is one of the most popular software development methodologies that prioritizes producing as many iterations as possible and frequent delivery of product releases depending on the evolving requirements and feedback.

It aims to deliver a product faster by avoiding going through an extended laborious effort and sticking to adding features with subsequent iterations and releases of the product.

Other than agile, waterfall, lean, and DevOps are some of the most widely used software development techniques. Each one offers different benefits and has its own distinct limitations.

Poor documentation, no specified endpoint, and poor resource planning are some of the major drawbacks of agile methodologies. By using variations in the agile approach, these drawbacks, however, can be minimized.

The Five Values of XP Programming

Extreme programming follows five values that are communication, courage, feedback, respect, and simplicity. Let’s know each one in detail down below:


Communication is an essential aspect of software development as it is a joint effort, a synergy of individual efforts. In XP, knowledge transfer (KT) should be smooth among the team members. Usually, one-on-one or one-on-many discussions are conducted using a whiteboard.

2. Courage

According to Kent Back, courage in extreme programming is “effective action in the face of fear.” You need to raise issues that are not working or wrong, which can include everything from raising organizational issues that reduce the effectiveness of the team and discontinuing doing something that isn’t working to accepting and acting on difficult feedback.

3. Feedback

Feedback is essential for going forward with software development. Continuous feedback is an important aspect of extreme programming, and hence, it is one of the five values of XP programming. It helps XP and agile teams to identify areas of improvement and modify practices to increase their effectiveness.

4. Respect

Mutual respect among team members is important in XP programming. Exchanging feedback is one of the most vital aspects of extreme programming. Respect helps to develop synergy in working together whether it is to identify simple designs or find issues.

5. Simplicity

This extreme programming value aims to keep things simple. It means to do only things that are absolutely necessary. For example, keep the design simple so that it can be maintainable and easy to revise. Simplicity also refers to addressing only those requirements that are completely known. Thus, it helps to avoid doing anything rash.

Practices of Extreme Programming

XP programming follows a wide set of software development practices, and some of them are more stringent than others. Although it is possible to perform these practices independent of one another, many of these practices reinforce one another and thus, should be performed together for best results.

Since their introduction, extreme programming practices have evolved. The original 12 XP practices are:

  1. 40-hour Week
  2. Coding Standard
  3. Collective Ownership
  4. Continuous Integration
  5. Metaphor
  6. On-site Customer
  7. Pair Programming
  8. Refactoring
  9. Simple Design
  10. Small Releases
  11. Testing
  12. The Planning Game

Although these practices are still applicable, experiences of extreme programming teams over the years have resulted in modification of them. Let’s know in detail about the modern practices of XP.

1) You need to “Sit Together”

Your team needs to sit together without any barriers to get the most out of communication in the form of face-to-face interaction. Instead of working individually from cubicles, XP teams sit collectively in an open space.

2) Going forward the the “Whole Team”

All members working on an XP project must be together. This is because the agile approach to software development necessitates a cross-functional team. To satisfy the requirements, every team member depends on other members of the team. So, there is an undeniable factor of interdependence here to accomplish the goals.

3) “Informative Workspace” is a must have

The workspace must be informative and supportive to the team members. Moreover, XP teams need to use Information Radiators for communicating updated information. The workspace should allow face-to-face communication and make the work transparent so that any member can know what other team members are up to.

As privacy is an important right for every individual, the workspace should facilitate team members to have it when they need it.

4) Keep up the “Energized Work”

This simply means taking steps to ensure that the team members are both mentally and physically capable of entering a focused state. For your team to be the most efficient, it should be fully focused and free from distractions.

Hence, the members of any extreme programming team should be physically and mentally healthy, and aware of burning out.

5) Embrace the art of “Pair Programming”

It is a new practice in software development that focuses on software development by two people. In pair programming, the two people work on the same codebase. The simple mantra behind the strategy is that two are better than one. In other words, problems that might challenge one person might be easy to champion by the other person.

The most fascinating aspect of pair programming that is responsible for its immense popularity is that it has shown that teams sticking to this XP practice are able to not only improve the quality of the software but also develop software faster than each member of the pair individually can.

6) Make captivating “Stories”

This is not about putting up some imaginary things or fiction on a paper, rather it is the technical term for short descriptions that describe specific features of the product to customers and stakeholders. XP promotes the use of stories. These help to add functionality to a product directly via user feedback.

7) Follow the “Weekly Cycle”

An iteration is known as the weekly cycle in terms of extreme programming practices. The routine starts with a team meeting on the first day of the week to discuss the progress and the further course of action.

The customer(s) chooses the stories that they would require in that week, and the XP team then decides how to work on and accomplish those stories. The end goal for the week is to run rigorous tests to realize the chosen stories. This is intended to produce something that the customer can provide feedback for, which can be subsequently used for the next set of stories.

8) Stick to the “Quarterly Cycle” routine

A quarterly cycle in XP is equivalent to a release. The main aim here is to ensure that the work completed in every weekly cycle aligns with the overall project.

Like with a weekly cycle, the customers choose features that they require in a particular quarter. This not only helps the XP team but also assures stakeholders and customers of the features (stories) that they can expect in that particular quarter.

Although features are selected before the start of a quarterly cycle, the order of delivery, as well as the features might change during the cycle. Hence, to minimize unexpected changes, it is advised to review the plan after each weekly cycle.

9) Cut some “Slack”

Slack in extreme programming means adding a few low priority stories in the weekly and quarterly cycles so that they can be intentionally dropped if the team lags behind on priority and high priority stories.

The main idea behind this extreme programming practice is to take the inherent variability in estimates into account.

10) All it should take is a “Ten-Minute Build”

As the name suggests, ten-minute build is an extreme programming practice where the system is built automatically and all the tests are run on it in 10 minutes. This helps to reduce the time between the occurrence of errors.

Test-first development supports the ten-minute build practice, which, in turn, supports the continuous integration practice. The idea behind this XP practice is that if a build takes longer than 10 minutes then it is unsuitable to be run frequently.

This practice encourages extreme programming teams to automate the build process so that it can be performed regularly and can be used to run all the tests.

11) “Continuous Integration” is effective

Continuous integration (CI) is a popular agile practice, along with continuous testing (CT) and continuous development (CD). The success of this XP practice is highly dependent on test-first development and ten-minute build XP practices.

In this extreme programming practice, the code changes are tested immediately while being added to the codebase. This hastens the process of detecting and fixing integration issues.

Non-XP teams loath the code integration step as it discovers conflicts and issues. Hence, they follow the approach of, “if it hurts, avoid it as long as possible.” Contrarily, XP practitioners suggest, “if it hurts, do it more often.”

The thought behind this practice is that experiencing issues while integrating code is unavoidable and identifying and locating issues take time. Therefore, it’s better to do it often so that it takes less time and fewer changes to fix integration issues.

12) Reduce bugs with “Test-First Programming”

Test-first programming ditches the traditional cycle of developing code, writing tests, and then running them on the code for running tests first and then ensuring that the code works. The steps to test-first programming are:

  1. Write failing automated test
  2. Run failing test
  3. Develop code to pass the test
  4. Run test on the developed code
  5. Modify code if not passed
  6. Continue repeating until the code passes

The main idea behind this XP practice is to shorten the feedback cycle for developers to detect and resolve issues. This ultimately leads to decreasing the total number of bugs in the codebase.

13) Take small steps in “Incremental Design”

Incremental design is one of the most important practices of XP programming. This extreme programming practice suggests that instead of working on a final design that takes a lot of time, come up with a minimal design and work incrementally on it.

This XP practice not only minimizes the cost of changes but also allows teams to make decisions based on the most recent information available. Refactoring, which is one of the original 12 extreme practices, is a part of incremental design.

Refactoring is important in designing as it helps to keep the design simple as well as eliminate the duplicity of processes.

Extreme Programming vs Dynamic Programming

Both XP programming and dynamic programming, even though sharing the word programming, are completely different concepts. Both are related to programming but in different ways.

Dynamic programming, unlike extreme programming, is a programming technique to solve optimization problems. It follows the approach of breaking a problem into multiple, smaller subproblems, and then targeting each one of them individually.

While dynamic programming is strictly for programmers, extreme programming is for programmers, non-programmers, and team managers.


For agile project managers, XP programming is an ideal solution when teams are small and requirements are evolving quickly. The many advantages of extreme programming are offset by its strict specificity of applying a full set of software engineering practices.

Nonetheless, extreme programming is among the most popular agile frameworks. Faster delivery, avoiding unnecessary programming, and fewer bugs are just some of the many advantages that XP brings to the table.

Share Your Thoughts, Queries and Suggestions!