Extreme Programming (XP)
Extreme Programming (XP) is an agile software development framework that aims to produce higher quality software and higher quality of life for the development team. It is the most specific of the agile frameworks regarding appropriate engineering practices for software development.
1. Core Values
XP is built upon five values that guide the team's behavior:
- Communication: Everyone is part of the team and we communicate face to face daily.
- Simplicity: We will do what is needed and asked for, but no more. "You Aren't Gonna Need It" (YAGNI).
- Feedback: Teams deliver software frequently, get feedback, and adapt.
- Courage: We tell the truth about progress and estimates. We don't document excuses for failure because we plan to succeed.
- Respect: Everyone gives and feels the respect they deserve as a valued team member.
2. Key Practices
XP prescribes a set of engineering practices that support these values.
Fine-Scale Feedback
- Pair Programming: All production code is written with two programmers at one machine.
- Test-Driven Development (TDD): Write unit tests before code.
- Whole Team: The customer is part of the team and available daily to answer questions.
Continuous Process
- Continuous Integration: Integrate and build the system many times a day.
- Small Releases: Put a simple system into production quickly, then release new versions on a very short cycle.
- Refactoring: Restructure the system without changing its behavior to remove duplication and improve communication.
Shared Understanding
- Coding Standards: Programmers write code in accordance with rules emphasizing communication through code.
- Collective Code Ownership: Anyone can change any code anywhere in the system at any time.
- Simple Design: The system should be designed as simply as possible at any given moment.
3. The "Extreme" Concept
Why is it called "Extreme"? It takes common sense principles and practices to extreme levels.
- If code reviews are good, we'll review code all the time (Pair Programming).
- If testing is good, everybody will test all the time (TDD).
- If simplicity is good, we'll always leave the system with the simplest design that supports its current functionality (Refactoring).
programming/agile-methodology programming/pair-programming programming/test-driven-development programming/ci-cd-pipelines