Extreme Programming

Extreme Programming Overview

Influential agile method developed in the late 1990s that introduces a range of agile dev techniques.
Some XP practices are in common use today.
"Extreme" approach to iterative development:
- New versions may be built several times per day.
- Increments delivered to customers every two weeks.
- All tests are run for every build; the build is accepted only if tests succeed.

Steps in Release Cycle:
- Select user stories for this release.
- Break down stories into tasks.
- Plan release.
- Develop, integrate, and test software.
- Release software.
- Evaluate system.

Set of software engineering practices that produce high-quality software with limited effort.
Lightweight software development process
- Replaces documentation with communication.
- Focuses on source code and testing.
- Strong productivity improvements.
Developed by industry practitioners.

Distinguish between decision made by business stakeholders and developers.
Simplistic design: "Design for today, not for tomorrow".
Write automated test code before writing production code and keep all tests running.
Pair programming.
Very short iterations with fast delivery.

No specialists: every programmer participates in architecture, design, test, integration.
No up-front detailed analysis and design.
No up-front development of infrastructure.
Not much writing of design and implementation documentation beside tests and code.

Simplicity: "The simplest thing that could possibly work" (YAGNI: You Aren't Gonna Need It).
Communication: Essential among developers, users, customers, testers, code.
Feedback: Via testing, experimenting, delivering.
Courage: Trust in practices and processes, history.

XP emphasizes technical focus and is not easy to integrate with management practices.
Key themes: user stories for specifications, refactoring, test-first development, pair programming, and continuous integration.

Recognition: You can’t know everything when you start. Customers will learn about what they want by looking at what you’ve done so far. Developers will learn about the domain and tech as the project progresses and what questions to ask.
Release Planning: Define and estimate higher-level features down to 5-10 days effort each. Customer lays features in fixed-length iteration schedule.
Iteration Planning: Define and estimate higher-level features down to 3 or less days effort each and detailed story cards within next iteration. Customer lays features in fixed-length iteration schedule.
User Stories: Written on a card. Chunk of functionality that is coherent to customers. Given priority/ value by the customer based on business value. Given estimate and risk by developers.

Unit Tests: Code it first in small increments. When releasing new code run all the unit tests on the integration machine. Must run at 100% before checking in feature. If any test fails, figure out why and the fix. The problem has to be in something they did as the tests ran at 100% at the last release.
Acceptance Tests: Test cases extracted from customer. Test system end to end. Tells the customer and the developers if the system has the features its supposed to. Don’t have to run at 100%. Progress used t o measure Project Velocity.
Junit Testing: A small testing framework written in Java. Series of extensible classes that do much of the testing grunt work. Handy for XP.

Tests are written as executable components before the task is implemented.
Components should be stand along, stimulate the submission of input to be tested and check that the result meets the output spec.
Automated test framework is a system that makes it easy to write executable tests and submit a set of tests for execution.