How unit 4 is examined
This unit covers the XP lifecycle, team, practices (refactoring, pair programming, stories, velocity, planning, release, development) and adoption; no past questions are tagged, so all topics are unasked.
XP Lifecycle
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>The XP lifecycle is a series of short, timeboxed iterations, grouped into releases, in which the team plans, develops, tests and delivers working software continuously.</mark>
Key points.
- Work starts with an exploration phase where the customer writes stories and the team estimates them.
- Release planning then picks stories for a release of a few months.
- Each iteration of one to three weeks delivers tested, working software from the chosen stories.
- The cycle ends with release and maintenance, and the loop repeats with feedback from the customer.
The XP Team
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>An XP team is a small, co-located, cross-functional group of programmers, customers, a coach and a tracker who share responsibility for the whole product.</mark>
Key points.
- The customer (on-site) writes stories, sets priorities and answers questions.
- Programmers estimate, design, test and code in pairs.
- The coach guides the team in following XP practices.
- The tracker records velocity and progress, and the team sits together in an open workspace.
XP Concepts: Refactoring
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>Refactoring is improving the internal structure of code without changing its external behaviour.</mark>
Key points.
- It is done in small steps, such as renaming, extracting a method or removing duplication.
- Automated tests are run after every step to prove behaviour is unchanged.
- It keeps the design simple and prevents code from decaying as features are added.
- In XP it is done continuously, not as a separate phase.
Technical Debt
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>Technical debt is the future cost of rework caused by choosing a quick, poor solution now instead of a better design.</mark>
Key points.
- Like financial debt, it accrues interest: the longer it stays, the harder changes become.
- It comes from rushed code, missing tests, duplication and code smells.
- XP pays it down through refactoring, test-driven development and collective code ownership.
- Making the debt visible to the team and customer helps decide when to repay it.
Timeboxing
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>Timeboxing fixes the length of an iteration or activity in advance, so scope is adjusted to fit the time rather than time stretched to fit the scope.</mark>
Key points.
- XP iterations are fixed, usually one to three weeks.
- When work will not fit, stories are dropped or deferred, never the deadline.
- It gives a steady rhythm and regular feedback.
- It stops over-engineering and makes progress predictable.
Stories
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>An XP story is a short description, written on a card by the customer, of a feature valuable to the user.</mark>
Key points.
- It is written in customer language, often as "As a user, I want ... so that ...".
- Stories are small enough to finish within one iteration and are estimated by the team.
- The card is a promise for a conversation, so details come from talking with the customer.
- Each story has acceptance tests that show when it is done.
Velocity
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>Velocity is the amount of work (story points) a team completes in one iteration.</mark>
Formula. $\text{Velocity} = \dfrac{\text{Story points completed}}{\text{Iterations}}$, for example 60 points in 3 iterations gives 20 points per iteration.
Key points.
- Only fully finished stories are counted.
- Past velocity is used to forecast how many stories fit in the next iteration or release.
- It measures the team's capacity, not individual performance, and should not be compared across teams.
Adopting XP: Pre-requisites
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>The pre-requisites of XP are the conditions an organisation needs before XP can work.</mark>
Key points.
- Management support and willingness to change are needed.
- An on-site customer must be available to the team.
- The team must be small, co-located and skilled in automated testing.
- Tools for version control, build and continuous integration must be in place.
Challenges
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>XP challenges are the cultural and practical barriers that make adopting XP difficult.</mark>
Key points.
- Teams find it hard to give up up-front design and detailed documents.
- Customers may be unable to stay on site full-time.
- Pair programming and collective ownership can meet resistance from developers.
- Fixed-price contracts and large or distributed teams fit XP poorly.
Applying XP: Thinking- Pair Programming
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>Pair programming is a practice in which two programmers work together at one computer, one writing code (driver) and the other reviewing it (navigator).</mark>
Key points.
- The pair swaps roles often and changes partners regularly.
- Continuous review catches defects early and improves quality.
- Knowledge is shared across the team, supporting collective code ownership.
- It costs some short-term productivity but reduces rework.
Collaborating
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>Collaborating in XP means the whole team works closely, communicating openly and continuously with each other and the customer.</mark>
Key points.
- The team shares an open workspace with an informal, information-rich environment.
- Daily stand-up meetings share status and problems.
- Collective ownership lets anyone improve any code.
- Face-to-face talk replaces heavy documents.
Release
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>A release in XP is a small, working, deployable version of the software delivered to customers at frequent intervals.</mark>
Key points.
- Releases are kept small, often every few weeks to months, to get early feedback.
- The release plan lists which stories go into each release.
- Each release passes acceptance tests and is built with continuous integration.
- Frequent releases reduce risk and deliver value early.
Planning
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>The planning game is the XP practice in which the customer and developers jointly plan releases and iterations.</mark>
Key points.
- The customer decides business value and priority; developers give estimates.
- Release planning selects stories for the release using velocity.
- Iteration planning breaks chosen stories into tasks that programmers accept.
- The plan is revisited after each iteration as feedback arrives.
Development
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>XP development is the set of engineering practices, such as test-driven development, pair programming, refactoring and continuous integration, used to build each story.</mark>
Key points.
- Tests are written before code in test-driven development.
- Simple design implements only what the current story needs.
- Code is integrated and tested several times a day.
- The team follows a coding standard and works at a sustainable pace.
XP Case Study
<span style="display:inline-block;padding:.16em .6em;border:1.5px solid currentColor;border-radius:999px;font-size:.68em;font-weight:700;letter-spacing:.06em;text-transform:uppercase;opacity:.75">Not asked since 2022</span>
Definition. <mark>An XP case study shows XP applied to a real project, such as the Chrysler C3 payroll system where XP originated.</mark>
Key points.
- The customer writes stories, and the team plans short iterations from them.
- Developers pair-program, test first and integrate continuously.
- Velocity from earlier iterations guides commitments for later ones.
- Frequent releases give early feedback and adaptation to changing requirements.
Last-minute revision
- XP lifecycle: exploration, release planning, iterations, release, maintenance.
- Team roles: customer, programmers, coach, tracker.
- Refactoring changes structure, not behaviour, and is protected by tests.
- Technical debt is the future cost of quick, poor solutions.
- Timeboxing fixes time and flexes scope.
- A story is a customer-written card, small, estimable, with acceptance tests.
- Velocity = story points completed per iteration.
- Pre-requisites: on-site customer, management support, tooling, small co-located team.
- Pair programming: driver and navigator swap roles.
- Planning game: customer sets priority, developers estimate.
- Development practices: TDD, simple design, continuous integration, sustainable pace.
Memory hooks
- Debt hooks: "borrow now, pay interest later".
- Timebox: the box is fixed, contents change.
- Driver types, navigator thinks.
- Customer says what and when, developers say how much.
Coverage checklist
- XP Lifecycle: covered (no past questions).
- The XP Team: covered (no past questions).
- XP Concepts: Refactoring: covered (no past questions).
- Technical Debt: covered (no past questions).
- Timeboxing: covered (no past questions).
- Stories: covered (no past questions).
- Velocity: covered (no past questions).
- Adopting XP: Pre-requisites: covered (no past questions).
- Challenges: covered (no past questions).
- Applying XP: Thinking- Pair Programming: covered (no past questions).
- Collaborating: covered (no past questions).
- Release: covered (no past questions).
- Planning: covered (no past questions).
- Development: covered (no past questions).
- XP Case Study: covered (no past questions).