Extreme
Programming
(XP)
Presentation
Created by: Paukšte Sanda, Khrustalev Andrei,
Atanazarov Saburjon.
• Extreme Programming (XP) - Agile
software development methodology that
focuses on delivering high-quality software
through frequent and continuous feedback,
collaboration, and adaptation.
• XP emphasizes a close working relationship
between the development team, the
customer, and stakeholders, with an
emphasis on rapid, iterative development
and deployment.
• Coding: the coding activity includes drawing
Basic diagrams (modeling) that will be transformed into
code, scripting a web-based system, and choosing
Principles among several alternative solutions.
• Testing: The XP model gives high importance to
of Extreme testing and considers it to be the primary factor in
developing fault-free software.
programmi • Listening: The developers need to carefully
ng listen to the customers if they have to develop
good quality software.
• Designing: Without a proper design, a system
implementation becomes too complex, and very
difficult to understand the solution, thus making
maintenance expensive.
Basic • Feedback: One of the most important aspects of the
XP model is to gain feedback to understand the exact
Principles customer needs.
• Simplicity: The main principle of the XP model is to
of Extreme develop a simple system that will work efficiently in the
present time, rather than trying to build something that
programmi would take time and may never be used.
ng • Pair Programming: XP encourages pair
programming where two developers work together at
the same workstation.
• Continuous Integration: In XP, developers integrate
their code into a shared repository several times a day.
This helps to detect and resolve integration issues early
on in the development process.
• Refactoring: the process of restructuring existing code to
Basic make it more efficient and maintainable. Refactoring helps to
keep the codebase clean, organized, and easy to understand.
Principles • Collective Code Ownership: there is no individual ownership
of code. Instead, the entire team is responsible for the
of Extreme codebase.
• Planning Game: XP follows a planning game, where the
programmi customer and the development team collaborate to prioritize
and plan development tasks.
ng • On-site Customer: XP requires an on-site customer who
works closely with the development team throughout the
project. This approach helps to ensure that the customer’s
needs are understood and met, and also facilitates
communication and feedback.
• Planning: During this phase, clients define their needs
in concise descriptions known as user stories. The team
Life Cycle
calculates the effort required for each story and
schedules releases according to priority and effort.
of • Design: The team creates only the essential design
Extreme
needed for current user stories, using a common analogy
or story to help everyone understand the overall system
architecture and keep the design straightforward and
Program clear.
ming (XP) • Coding: XP promotes pair programming. They write
tests before coding to ensure functionality from the start,
and frequently integrate their code into a shared
repository with automated tests to catch issues early.
Life Cycle of
Extreme
Programming (XP)
• Testing: Unit tests, which are automated,
check if specific features work correctly.
Acceptance tests, conducted by customers,
ensure that the overall system meets initial
requirements. This continuous testing
ensures the software’s quality and alignment
with customer needs.
• Listening: In the listening phase regular
feedback from customers to ensure the
product meets their needs and to adapt to
any changes.
Advantages (Compared to Other Agile
Frameworks)
1. Rapid Feedback Loops: XP emphasizes continuous customer
feedback, making it one of the most customer-centric Agile
frameworks. This allows quicker identification and resolution of
issues.
2. Pair Programming: A unique feature of XP, this technique
enhances collaboration and reduces errors through real-time peer
review, a practice not emphasized in frameworks like Scrum.
3. Emphasis on Testing: XP prioritizes Test-Driven Development
(TDD) and frequent testing (unit and acceptance), which leads to
higher-quality, fault-free software compared to frameworks that
don’t enforce testing as strictly.
4. Simplicity: XP encourages developers to focus on delivering the
simplest solution that works, avoiding overengineering, which can
sometimes be a problem in other frameworks like Kanban or Scrum.
5. Adaptability: XP’s iterative approach allows for easier adaptation
to changing requirements during development, whereas some
frameworks like Scrum may need more structured change
management.
Disadvantages (Compared to Other
Agile Frameworks)
1. High Learning Curve: Practices like pair programming, continuous
integration, and test-driven development can be challenging for
teams unfamiliar with XP, whereas frameworks like Scrum are more
straightforward to adopt.
2. Not Suitable for Large Teams: XP is typically best suited for
small, co-located teams. For large distributed teams, frameworks
like Scrum or SAFe provide more scalability.
3. Requires On-Site Customer: XP mandates the presence of an on-
site customer, which can be impractical, especially for remote teams
or those without consistent customer access. Other frameworks like
Scrum don't enforce this as strictly.
4. Time-Consuming Practices: Practices like pair programming and
constant testing, while improving quality, can slow down
development speed compared to frameworks like Kanban, which
emphasizes flow without pairing.
5. Limited Focus on Project Management: XP emphasizes technical
practices but offers less guidance on project management and roles
compared to frameworks like Scrum, which has specific roles for
managing workflow and stakeholder engagement.
Roles
1. Developer: The core role in XP. Developers not only write code
but also engage in all aspects of the project such as pair
programming, refactoring, and testing. Everyone shares
collective code ownership.
2. Customer: The customer is always available on-site to provide
immediate feedback and clarify requirements. They are
responsible for creating and prioritizing user stories.
3. Tracker: This role monitors progress by tracking metrics such
as project velocity, ensuring that the team stays on track and
delivers within expected timelines.
4. Coach: The XP Coach ensures that the team follows XP
principles and practices. They guide the team in implementing
XP effectively, similar to a Scrum Master in Scrum.
5. Tester: While all developers contribute to testing, a dedicated
tester (or testing team) focuses on writing and executing
acceptance tests to validate that the product meets customer
expectations.
Responsibilities - 1
• Developer: The core role in XP.
Developers not only write code but also
engage in all aspects of the project such
as pair programming, refactoring, and
testing. Everyone shares collective code
ownership.
• Customer: The customer is always
available on-site to provide immediate
feedback and clarify requirements. They
are responsible for creating and
prioritizing user stories.
Responsibilitie
s2
• Tracker: This role monitors progress by
tracking metrics such as project velocity,
ensuring that the team stays on track
and delivers within expected timelines.
• Coach: The XP Coach ensures that the
team follows XP principles and practices.
They guide the team in implementing XP
effectively, similar to a Scrum Master in
Scrum.
• Tester: While all developers contribute
to testing, a dedicated tester (or testing
team) focuses on writing and executing
acceptance tests to validate that the
product meets customer expectations.
Practical Example
XP in Action: Building a Ride-Sharing App
User Story Customer Involvement Week 1: Kickoff
A user story serves as a concise Direct customer involvement The first week focuses on
description of a feature from ensures that the development defining the user story,
the user's perspective, team understands the real- gathering customer feedback,
capturing the desired world needs and priorities of and setting the stage for the
functionality. the users. development process.
Day 1: Pair Programming
and Test-Driven
Development
1 Pair Programming
Two developers work together on the same code, enhancing code
quality and knowledge sharing.
2 Test-Driven Development (TDD)
Tests are written before the code, ensuring the code meets the
desired functionality and catches bugs early on.
3 Iteration 1
The first iteration focuses on implementing the user story's initial
functionality, starting with the ride request and estimated arrival
time.
Day 2: Simple Design and
Refactoring
1 Simple Design
Prioritize simplicity and focus on delivering core
functionality without unnecessary complexity.
2 Refactoring
Continuously improve the code structure and
maintainability without changing its functionality.
3 Iteration 1 Continued
The team continues to refine the code, addressing any
issues and making it more efficient.
Day 3: Continuous Integration
Continuous Integration (CI)
Code is integrated into the main codebase frequently,
triggering automated tests to ensure the software remains
stable.
Automated Tests
Automated tests catch bugs early, reducing the risk of
regressions and ensuring high code quality.
Iteration 1 Complete
By the end of the day, the team has a working prototype,
enabling users to request rides and see driver ETA.
Day 4: Code Review and
Collective Ownership
Code Review
The team reviews the code, ensuring everyone understands the
changes made and identifying areas for improvement.
Collective Code Ownership
All team members are responsible for all parts of the codebase,
encouraging collaboration and knowledge sharing.
Refactoring
Based on the code review, the team refactors the code, making it
cleaner and more maintainable for future iterations.
Day 5: Customer Feedback and Iteration
Customer Feedback Team Action
Make the ETA more prominent Adjust the visual design to make the ETA more
noticeable.
Add a countdown timer for the ETA Implement a countdown timer to enhance the user
experience.
Key Takeaways
Quick Feedback
Early and continuous customer feedback drives rapid iteration and ensures the
software meets user needs.
Code Quality
XP practices like pair programming, TDD, and refactoring maintain clean, tested,
and maintainable code.
Simplicity and Flexibility
Avoiding over-engineering allows the team to adapt to changing requirements
quickly and efficiently.
Thank you for your
attention!
