22 September 2021

Extreme Programming

Extreme Programming (XP)

  • Extreme Programming or eXtreme Programming (XP) is an agile software development framework with an extreme focus on programming and taking engineering practice to an extreme in order to create and release high quality code.
    • eXtreme Programming (XP) is a programmer-centric agile framework that focuses on small, ongoing releases.
    • eXtreme Programming (XP) is generally considered to be the originator of User Stories. [User Stories Applied: For Agile Software Development. Mike Cohn.]
    • The best role for a customer in eXtreme Programming (XP) is to write well-defined User Stories. [User Stories Applied: For Agile Software Development. Mike Cohn.]

Extreme Programming (XP) values

  • Extreme Programming (XP) is based on 5 values :
    • Communication
    • Simplicity
    • Feedback
    • Courage
    • Respect.
  • Just like Scrum, EXTREME PROGRAMMING values Courage and Respect.

eXtreme Programming (XP) principles

  • eXtreme Programming (XP) highlights several principles :
    • whole team,
    • pair programming,
    • sustainable pace,
    • ongoing automated testing,
    • effective communication,
    • collective ownership,
    • continuous integration,
    • energized work,
    • shared workspaces,
    • on-site customer representation,
    • and the use of metaphor to describe concepts.
    • [Agile Software Development: The Cooperative Game – 2nd Edition. Alistair Cockburn.]

Whole Team

  • Whole Team means that all skills that are required to turn the selected User Stories into a releasable software must be on the team, present across all the team members.

Energized work

  • (work only as many hours as you can be productive and only as many hours as you can sustain.)

Extreme Programming practices

  • Extreme Programming takes the engineering practices to an extreme, in order to create and release high quality code.
  • Agile software development practices popularized by Extreme Programming :
    • Pair Programming
    • Refactoring
    • User Stories
    • Collective Code Ownership

Continuous Integration (CI)

  • Continuous Integration (CI) is a software development practice where members of a development team integrate and verify their work frequently, often multiple times each day to detect integration errors as quickly as possible.
    • Continuous Integration and Build
      • The goal of Continuous Integration (CI) is to provide rapid feedback of build and test results so that if a defect is introduced into the code base, it can be identified and corrected as soon as possible.
      • So, with any check in of new or changed code into version control, the build should be executed
      • Newly checked-in code is built, integrated, and tested frequently, generally multiple times a day.
      • When a Continuous Integration (CI) build fails with a check in, the person who is in the context and knows what is happening is the best one to fix it.
        • Hence, the person who broke the build is the ideal source to fix the failure.
        • In addition, the person who is in the context and knows what is happening is the best one to fix it.

Pair Programming

  • Pair programming is a technique in Agile Software Development where two engineers share a single workstation.
    • In this technique, one engineer is the driver, who has control of the mouse and keyboard to write the code, while the other serves as the navigator, reviewing the code that the other is writing while providing tactical and analytical feedback.
    • This pair will trade‐off on these roles at regular intervals, giving each other equal chance to both execute on the work or direct it.
  • Pair programming is two developers writing code together, providing constant peer review.

Pair Programming practices

  • Pair programming is an agile software development technique in which two programmers work together at one workstation.
    • One, the driver, writes code while the other, the observer or navigator, reviews each line of code as it is typed in.
    • The two programmers switch roles frequently.
  • Pair programming configuration may be two developers working with one machine or a programmer and a tester working together.
  • Pair programming is just two people programming using one computer.
  • Pair programming is a micro feedback loop.
    • Pair programming is about live code review.
    • EXTREME PROGRAMMING teams want to capture problems or dirtiness in their code earlier by having a live code review.
    • Pair programming is about two people collaborating to solve a problem together because two heads are better than one.

Pair Programming benefits

  • Fewer Coding Mistakes
  • An effective way to share knowledge
  • Solve Problems Faster and Quicker
  • Train New People Joins
  • Improve Interpersonal and Social Skills.


  • Code Refactoring is an agile software development practice popularized by Extreme Programming in which code is adjusted within the code base without impacting the external, functional behavior of that code.
    • Refactoring is a disciplined technique for restructuring an existing body of code, altering its internal structure without changing its external behavior.
  • In addition, there are no special Sprints in Scrum such as Hardening Sprint, Stabilization Sprint, and Refactoring Sprint …

Refactoring benefits

  • There are two general categories of benefits to the activity of refactoring :
    • Maintainability :
      • It is easier to fix bugs because the source code is easy to read, and the intent of its author is easy to grasp.
      • This might be achieved by reducing large monolithic routines into a set of individually concise, well-named, single-purpose methods.
      • It might be achieved by moving a method to a more appropriate class, or by removing misleading comments.
    • Extensibility :
      • It is easier to extend the capabilities of the application if it uses recognizable design patterns, and it provides some flexibility where none before may have existed.
  • Advantages also include improved code readability and reduced complexity.

Refactoring practice

  • Code Refactoring is the process of clarifying and simplifying the design of existing code, without changing its behavior
    • Refactoring does “not” include :
      • Rewriting the entire code
      • Fixing bugs
      • Improving observable aspects of software such as its interface
  • Refactoring is included in Test Driven Development (TDD)

User Story

  • Agile software development practice to express requirements from an enduser perspective, emphasizing verbal communication.
    • User Stories often used to express functional items on the Product Backlog.
    • User Stories are requirements or feature which has to be implemented.

User Story practice

  • User Stories typically have a format like :
    As a
    I want to
    To achieve

Collective Code Ownership

  • A software development principle popularized by Extreme Programming holding that all contributors to a given code base are jointly responsible for the code in its entirety.
  • Collective Code Ownership practice

    • Extreme Programming does not allow the iteration to be more than one week.
      • Extreme Programming mandates the iteration to be only one week long.
    • Extreme programming (XP) is highly complementary to the Scrum framework.
    • While Scrum does not require the customer to be on-site, Extreme Programming requires the customer on-site and continuously test with the team.
      • For Scrum Team practicing EXTREME PROGRAMMING, during Sprint Review the customer, Product Owner and Developers will review the product that is already in production.
      • The Sprint Review will not be the first time the Product Owner and the customer has seen the product.
      • Scrum Team will assess what is possible for the next week Sprint based on what has already been delivered to production.

    Ten Minute Build

    • Ten-minutes Build Principle is non-negotiable rule from EXTREME PROGRAMMING.
      • When the build runs more than ten minutes, the developers may need to refactor their tests code.
      • When the build runs longer than ten minutes, developers are reluctant to continuously integrate their code.
      • When developers are not continuously integrating their code, they will lose feedback.
      • EXTREME PROGRAMMING highly values feedback, faster build means faster feedback.

    Technical debt

    • Technical Debt is not an eXtreme Programming (XP) practice.
      • Technical Debt is total sum of less than perfect design and implementation decisions in the product,
      • Technical Debt needs to be monitored and controlled.

    Sit together

    • eXtreme Programming (XP) advocates an open space big enough for the whole team.


    • eXtreme Programming (XP) recommends that in any plan it is better to include some minor tasks that can be dropped if you get behind.
      • You can always add more stories later and deliver more than you promised.

    More informations for the Scrum PSD certification here.

    More informations at PMI-ACP exam

    Updated : 18/09/2021

    Leave a Reply

    Your email address will not be published. Required fields are marked *