12 Practices That Make Up Extreme Programming In Agile Software Development Methodology

Extreme Programming is a term that refers to a software development methodology in Agile Development to implement a product and is aimed to improve code quality, and quality product delivery There are 12 major development practices that make up extreme programming.

  1. Pair Programming – Code is produced by two programmers working at one workstation. 
  2. Planning Game – The meeting that occurs once per iteration and focuses on Release Planning and Iteration Planning and is aimed to guide the product into delivery
  3. Test Driven Development (TDD) – Write a failing unit test first, then code and pass the test. Refactor as needed. Also called red-green-refactor.
  4. Whole Team – The customer or end user should be a part of the team (or be on hand) to answer any questions or clarifications during the process of product design and development.
  5. Continuous Integration – The developers should always be working on the latest versions of the software, thus they should commit the code often for other developers to obtain. Integration of the code should happen frequently.
  6. Refactoring or Design Improvements – With TDD of eXtreme Programming, the design and development is kept simple and the coding is done based on what is known at that time, not designing for potential future changes. As the future requirements are known, designed and developed, the refactoring is done frequently to adjust the latter changes to produce a better piece of software.
  7. Small Releases – Releases are done frequently, thus making them smaller and providing a chance to obtain feedback from the end users. The released product should provide some value to the customers.
  8. Coding Standard – Developers follow coding conventions either obtained from programming language standards or defined by the team. Those conventions and standards are followed. Static code analysis tools like checkstyle can enforce that the teams follow coding standards.
  9. Collective Code Ownership – Everyone is responsible for the code. Anyone can modify any part of the code. If developer pair A introduce some errors to the product, developer pair B can and should be able to modify the code to fix the errors, not just depend on pair A to go back and make the changes.
  10. Simple Design – Always ask a question, can this be done in a simpler way? If so follow the simpler way of doing things. Find any existing complex code, feel free to refactor them in order to make them simple. Simple designs are understood by other team members and any future developers.
  11. System Metaphor – Name you methods, variables, classes in such a way that even non programmers (e.g. customers, managers, product owners) can at least say how the system is working – for example by looking at the class diagrams or sequence diagrams.
  12. Sustainable Pace – The development process should not take you extra hours to complete or deliver. It can occasionally happen from one iteration to another but should not repeat in most of the iterations. Simply designed, continuously integrated, thoroughly tested application should be easy to maintain without getting into complex situations where it needs your over time.