Extreme Programming – Crib Notes

Crib Notes: Extreme Programming (XP) in Kotlin Project

Key XP Practices

• Planning Game: Customer prioritizes features; developers estimate and inform technical risks.
• On-site Customer: Continuous availability for quick decisions and clarifications.
• Small Releases: Frequent, incremental deployments to obtain rapid feedback.
• Pair Programming: Two developers per workstation for immediate code review and knowledge sharing.
• Test-Driven Development (TDD): Writing tests first; ensures code is robust and clear.
• Continuous Integration: Regularly integrate and test code multiple times daily.
• Refactoring: Continuously improve code structure without changing behavior.
• Collective Code Ownership: Any team member can work on any code area.
• Sustainable Pace: Maintain steady, productive work hours (no routine overtime).
• Coding Standards: Uniform code conventions for easy understanding and maintenance.

XP Iteration Process (1-week cycles)

1. Planning Game: Select iteration stories collaboratively (customer & developers).
2. Development (TDD & Pair Programming): Implement and continuously test.
3. Iteration Review (Small Release): Demo completed features, deploy increment.
4. Next Iteration Planning: Cycle repeats.

Handling Specific Feature Scenarios

Feature 1 (Unclear Scope):

• Immediately clarify with on-site customer.
• Conduct a short “Spike” (research or prototype) to resolve uncertainty.
• If still unclear or too complex, swap out for simpler work this iteration.
• Re-plan for next iteration once scope is clear.

Feature 2 (Mid-Iteration Change):

• Immediately discuss with on-site customer.
• Re-plan iteration: modify or swap out story as needed.
• TDD and continuous integration allow quick adaptation.
• Accept unfinished work rollover if needed; minimal delay to implement change.

Feature 3 (External Dependency Delay):

• Immediately create stubs/mocks to simulate the external dependency.
• Continue implementation and testing without delay.
• Communicate actively with the external team.
• When dependency ready, quickly integrate real component, run tests.
• Adjust iteration scope by swapping stories if heavily delayed.

Feature 4 (Smooth Implementation):

• Clear user story and acceptance criteria upfront.
• Pair programming & TDD ensure clean, bug-free code.
• Continuous integration maintains system stability.
• Quick customer validations throughout.
• Smooth delivery and immediate small release at iteration end.

Strengths & Best Practices

• Instant Clarification: On-site customer reduces waiting times dramatically.
• High Responsiveness: Short iterations and flexibility allow rapid adjustments.
• Technical Excellence: TDD, refactoring, pair programming, and continuous integration keep codebase adaptable.
• Collective Ownership: Eliminates bottlenecks; team can respond flexibly.
• Simplicity & Flexibility: Design simplicity allows easy handling of changing requirements.
• Sustainable Pace: Ensures long-term team productivity and project health.

XP excels in scenarios needing rapid adaptation, continuous customer engagement, and consistent, high-quality software delivery.