The XP Process - Exam Notes

Overview of Extreme Programming (XP)

Extreme Programming (XP) is an agile software development
methodology that uses an object-oriented approach for software
development. It emphasizes adaptability, customer collaboration, and
continuous improvement through iterative cycles.

Four Framework Activities in XP Process

The XP process consists of four core framework activities:
1. Planning
2. Design
3. Coding
4. Testing

1. Planning Phase
• Begins with the creation of user stories
• Each story is written by the customer and placed on an index
card
• Customer assigns a value (priority) to each story
• The agile team assesses each story and assigns a cost
• A commitment is made on delivery date
• After the first increment, "project velocity" is used to define
subsequent delivery dates for other increments
Key Concept: Project velocity helps predict how much work can be
completed in future iterations based on past performance.
2. Design Phase
• Follows the "Keep It Simple" (KIS) principle
• Encourages use of CRC (Class-Responsibility-Collaborator)
cards for design discussions
• For difficult design problems, suggests creating "spike
solutions" (design prototypes)
• Encourages "refactoring" — iterative refinement of internal
program design
• Design occurs both before and after coding commences
Important: Refactoring is the continuous improvement of code
structure without changing its external behavior.

3. Coding Phase
• Recommends construction of unit tests for each story before
coding
• Encourages "pair programming"
– Developers work in pairs, checking each other's work
– Provides support to always do a good job
– Mechanism for real-time problem solving and quality
assurance
– Keeps developers focused on the problem at hand
• Requires continuous integration with other portions (stories) of
the software
• Provides a "smoke testing" environment for early detection of
integration issues

4. Testing Phase
• Creation of unit tests before coding is the key element of XP
approach
• Unit tests should be implemented using a framework that
enables automation
• Encourages regression testing strategy whenever code is
modified
 • Individual unit tests are organized into a "Universal Testing
Suite"
• Integration and validation testing can occur on a daily basis
• Provides continual indication of progress and raises warning
flags early if things go wrong
Critical Point: Test-driven development (TDD) is central to XP —
write tests first, then write code to pass those tests.

Industrial XP (IXP)
Overview
• IXP is an organic evolution of XP
• Imbued with XP's minimalist, customer-centric, test-driven spirit
• Differs from original XP in:
– Greater inclusion of management
– Expanded role for customers
– Upgraded technical practices
• Incorporates six new practices designed for significant projects
within large organizations

Six New Practices in IXP

1. Readiness Assessment
The organization should conduct a readiness assessment before
initiating an IXP project to ascertain:
(i) An appropriate development environment exists
(ii) The team will be populated by the proper set of stakeholders
(iii) The organization has a distinct quality program and
supports continuous improvement
(iv) The organizational culture will support new agile team
values
(v) The broader project community will be populated
appropriately
2. Project Community
• People must be well-trained, adaptable, skilled, and have
proper temperament for self-organizing teams
• For significant projects in large organizations, the concept of
"team" morphs into "community"
• Community includes technologists, customers (central to
success), and many other stakeholders

3. Project Chartering
• IXP team assesses the project to determine:
– Whether the project exists
– Whether it furthers organizational goals and objectives
– How it complements, extends, or replaces existing
systems/processes

4. Test-Driven Management
• Establishes a series of measurable "destinations"
• Defines mechanisms for determining whether destinations have
been reached

5. Retrospectives
• IXP team conducts technical review after software increment is
delivered
• Examines "issues, events, and lessons-learned" across
software increments and/or entire releases
• Intent is to improve the IXP process

6. Continuous Learning
• Learning is vital for continuous process improvement
• Team members encouraged to learn new methods and
techniques
• Leads to higher quality products
IXP Modifications to Existing XP Practices
Story-Driven Development (SDD)

• Insists that stories for acceptance tests be written before any

code is developed

Domain-Driven Design (DDD)

• Improvement on the "system metaphor" concept

• Suggests creation of a domain model that accurately represents
how domain experts think
Pairing

• Extends XP pair-programming concept to include managers and

stakeholders
• Intent: improve knowledge sharing among team members not
directly involved in technical development
Iterative Usability

• Discourages front-loaded interface design

• Favors usability design that evolves as software increments
are delivered
• Based on users' interaction with the software

The XP Debate
Overview
Extreme Programming has sparked heated debate about new
process models and methods.

Strengths and Weaknesses

• Many XP practices are worthwhile, but some have been
overhyped
• A few practices are problematic
• The codependent nature of XP practices is both its strength
and weakness
Key Challenges
1. Requirements Volatility
• Customer is an active member of XP team
• Changes to requirements are requested informally
• Project scope can change, requiring modification of earlier
work to accommodate current needs

2. Conflicting Customer Needs

• Many projects have multiple customers, each with their own
needs
• Requirements are expressed informally
• Can lead to conflicting priorities and requirements

3. Lack of Formal Design

• XP deemphasizes architectural design
• Suggests design should be relatively informal
• Critics argue: Complex systems need design emphasis for
quality and maintainability
• XP proponents argue: Incremental nature limits complexity
(simplicity is core value), reducing need for extensive design

Other Agile Process Models

1. Adaptive Software Development (ASD)
2. Dynamic Systems Development Method (DSDM)
3. Scrum
4. Crystal
5. Feature Driven Development (FDD)
6. Agile Modeling (AM)
7. Lean Software Development (LSD)
8. Agile Unified Process (AUP)
1. Adaptive Software Development (ASD)
Overview
• Technique for building complex software systems
• Incorporates three phases: Speculation, Collaboration, and
Learning
• Focuses on human collaboration and team self-organization

Three Phases
Speculation
• Refers to the "planning paradox"
• Outcomes are unpredictable
• Endless suppositions on product look/feel unlikely to lead to
business value
• Planning → Speculation as Intention → Need
• If we can't predict outcomes, traditional project management
theory suffers

Collaboration
• Represents balance between managing work and
creating/maintaining collaborative environment

Learning
• Challenges all stakeholders and project team members
• Based on short iterations of design, build, and testing
• Knowledge accumulates from small mistakes due to:
– False assumptions
– Poorly stated or ambiguous requirements
– Misunderstanding stakeholders' needs
2. Dynamic Systems Development Method
(DSDM)
Overview
• Agile approach providing framework for building/maintaining
systems under tight time constraints
• Uses incremental prototyping in controlled project
environment
• Iterative software process following the 80 percent rule

80 Percent Rule
• Only enough work required for each increment to facilitate
movement to next increment
• Remaining detail completed later when more requirements are
known or changes requested

DSDM Life Cycle Activities

Pre-Iterative Activities:

1. Feasibility Study

• Establishes basic business requirements and constraints

• Assesses whether application is viable candidate for DSDM
process
2. Business Study

• Establishes functional and information requirements for

business value
• Defines basic application architecture
• Identifies maintainability requirements

Followed by three different iterative cycles for development.

3. Scrum
Overview
• Principles consistent with agile manifesto
• Guides development within five framework activities:
Requirements, Analysis, Design, Evolution, and Delivery

Sprint Process
• Work tasks occur within a process pattern called a "sprint"
• Work conducted within sprint is adapted to the problem at
hand
• Defined and modified in real time by the Scrum team
• Number of sprints varies depending on product complexity and
size

4. Crystal
Overview
• One of the most lightweight, adaptable approaches
• Actually a family of methodologies: Crystal Clear, Crystal
Yellow, Crystal Orange, etc.
• Unique characteristics driven by:
– Team size
– System criticality
– Project priorities

Key Tenets
• Teamwork
• Communication
• Simplicity
• Reflection to frequently adjust and improve the process
Philosophy
Each project may require a slightly tailored set of policies, practices,
and processes to meet unique characteristics.

5. Feature Driven Development (FDD)

Overview
• Features are small, "useful in the eyes of the client" results
• Designs development process around feature delivery

Eight Practices
1. Domain Object Modelling
2. Developing by Feature
3. Component/Class Ownership
4. Feature Teams
5. Inspections
6. Configuration Management
7. Regular Builds
8. Visibility of progress and results

6. Agile Modeling (AM)

Overview
• Practice-based methodology for effective modeling and
documentation
• Collection of values, principles, and practices for lightweight
software modeling

Unique Core Principles

1. Use Multiple Models

• Many different models and notations can describe software

• Each model should present a different aspect of the system
• Use only models that provide value to their intended audience

2. Travel Light
 • Keep only models that provide long-term value
• Jettison the rest as work proceeds

3. Content is More Important Than Representation

• Modeling should impart information to its audience

• Syntactically perfect model with little content < flawed notation
with valuable content
4. Know the Models and Tools

• Understand strengths and weaknesses of each model

• Understand the tools used to create models

5. Adapt Locally

• Modeling approach should be adapted to agile team needs

7. Lean Software Development (LSD)

Overview
• Adapted principles of lean manufacturing to software
engineering

Seven Lean Principles

1. Eliminate waste
2. Build quality in
3. Create knowledge
4. Defer commitment
5. Deliver fast
6. Respect people
7. Optimize the whole

Eliminate Waste in Agile Context

• Adding no extraneous features or functions
• Assessing cost and schedule impact of newly requested
requirements
• Removing superfluous process steps
 • Establishing mechanisms to improve information finding
• Ensuring testing finds as many errors as possible

8. Agile Unified Process (AUP)

Overview
• Adopts "serial in the large" and "iterative in the small"
philosophy
• Adopts classic UP phased activities: Inception, Elaboration,
Construction, and Transition
• Enables visualization of overall process flow

Activities in Each AUP Iteration

1. Modeling

• Represents business and problem domains

2. Implementation

• Models translated into source code

3. Testing

• Executes tests to uncover errors

• Ensures source code meets requirements

4. Deployment

• Focuses on delivery of software increment

• Acquisition of feedback from end users
5. Configuration and Project Management

• Addresses change management

• Risk management
• Control of persistent work products

6. Environment Management

• Coordinates process infrastructure including:

 – Standards
– Tools
– Support technology available to the team

Agile Methods Applicability

Where Agile Works Well
• Product development: Small or medium-sized products by
software companies
• Custom system development: Within organizations with:
– Clear commitment from customer to be involved
– Not many external rules and regulations affecting software

Limitations
• Focus on small, tightly-integrated teams
• Problems scaling agile methods to large systems

Problems with Agile Methods

1. Difficult to keep customer interest involved throughout the
process
2. Maintaining simplicity requires extra work
3. Contracts may be problematic as with other iterative
development approaches

Quick Reference Summary

 Concept Key Points
XP Core Activities Planning, Design, Coding, Testing
User stories, customer priority, cost
Planning
estimation, project velocity
KIS principle, CRC cards, spike solutions,
Design
refactoring
Unit tests first, pair programming,
Coding
continuous integration
Automated unit tests, regression testing,
Testing
Universal Testing Suite
Readiness assessment, project community,
IXP Additions chartering, test-driven management,
retrospectives, continuous learning
Requirements volatility, conflicting needs,
XP Challenges
lack of formal design

Table 1: XP Process Quick Reference

Exam Tips
Memorize the four XP framework activities in order
Understand pair programming benefits: real-time problem
solving, quality assurance, focus
Know the six new IXP practices and their purposes
Be able to compare and contrast different agile methodologies
Understand the XP debate: know both criticisms and defenses
Remember the 80 percent rule for DSDM
Know lean principles and how they apply to software
Understand sprint concept in Scrum
Be familiar with agile applicability and limitations