AGILE PROJECT MANAGEMENT WITH SCRUM FRAMEWORK
SESSION – V: Agile Methodologies
Wednesday, 10 July 2024 INSTRUCTOR: DR. RAHUL SINDHWANI / DR. SHWETA SINGH 1
SESSION
FLOW
Extreme
Examples
Programming
(XP)
Lean
7/10/2024 1:24 AM 2
Extreme Programming (XP)
XP is a lightweight methodology for small to medium-
sized teams developing software in the face of rapidly
changing requirements
By: Kent Back
➢ Took traditional software development to an extreme
level.
➢ Aims to improve product quality.
https://www.youtube.com/watch?v=hbFOwqYIOcU&list=PLCku-ULHIQvnWyghG0JnYbVQm35DvJi29
Principles of Extreme
Programming
➢ Coding is the core activity.
➢ XP teams do lots of testing during development, not at the end
➢ Communication between customer and programmer is direct
➢ For complex systems, some level of overall design, beyond any
specific function, is necessary
Extreme Programming Practices
XP Practices Underpinning Assumption
Whole team The customer needs to be collocated (physically located together) with the development team and
be available. This accessibility enables the team to ask more minor questions, quickly get answers,
and ultimately deliver a product more aligned with customer expectations.
Planning game All members of the team should participate in planning. No disconnect exists between business and
technical people.
Customer tests As part of presenting each desired feature, the XP customer defines one or more automated
acceptance tests to show that the feature is working. Customer (i) Make a checklist for each feature
ii) going to check in automated environment (means payment struggle in low bandwidth etc.)
Small releases Release value to the customer as often as possible. Some organizations release multiple times daily.
Avoid building up large stores of unreleased code requiring extensive risky regression and
integration efforts. Get feedback from your customer as early and as often as possible.
Simple design The simpler the design, the lower the cost to change the software code.
Pair Two people work together on a programming task. One person is strategic (the driver) and the other
programming person is tactical (the navigator). They explain their approach to each other. They take turns as
driver and navigator. No piece of code is understood by only one person. Defects can be more
easily found and fixed before the code is merged and integrated with the system.
Test-driven Write automated customer acceptance and unit tests before you code anything. Write a test, run it,
development and watch it fail. Then write just enough code to make the test pass, refactoring until it does . Test
(TDD) your success before you claim progress.
Extreme Programming Practices
XP Practices Underpinning Assumption
Design improvement Continuously improve design by refactoring code — removing duplications and
(refactoring) inefficiencies within the code. A lean code base is simpler to maintain and operates more
efficiently.
Continuous Team members should be working from the latest code. Integrate code components across
integration the development team as often as possible to identify issues and take corrective action
before problems build on each other. XP teams promote multiple builds each day.
Collective code The entire team is responsible for the quality of code. Shared ownership and accountability
ownership bring about the best designs and highest quality. Any engineer can modify another
engineer’s code to enable progress to continue.
Coding standard Use coding standards to empower developers to make decisions and to maintain consistency
throughout the product; don’t constantly reinvent the basics of how to develop products in
your organization. Standard code identifiers and naming conventions are two examples of
coding standards.
Metaphor When describing how the system works, use an implied comparison, a simple story that is
easily understood.
Sustainable pace Overworked people are not effective. Too much work leads to mistakes, which leads to
more work, which leads to more mistakes. Avoid working more than 40 hours per week for
an extended period of time.
TDD (Test Driven Development)
Red-Green-Refactor Cycle:
o Red: Write a failing test that defines a new function or improvement. The test
should fail because the functionality is not yet implemented.
o Green: Write the minimal amount of code necessary to pass the test. The code
should be simple and sufficient to make the test pass.
o Refactor: Clean up the code, improving its structure and readability without
changing its external behavior. The goal is to maintain code quality while
ensuring all tests still pass.
Example of TDD
Developing a Calculator Application
Step 1: Write a Failing Test (Red)
• Requirement: The calculator should add two numbers.
Test Code:
Expectation: The test should fail because the add method is not implemented yet.
Step 2: Write Minimal Code to Pass the Test (Green)
Implementation Code:
Expectation: The test should now pass because the add method returns the correct
result.
Step 3: Refactor the Code
In this simple example, the code is already clean, so there might not be much to refactor.
However, in more complex scenarios, you would improve the code structure while
ensuring the tests still pass.
Metaphor
Example: Metaphor: "The Online Library as a
Physical Library
• Bookshelves (Database)
• Library Cards (User Accounts)
• Librarian (Search Engine)
• Checkout Desk (Borrowing Process)
• Reading Room (User Interface)
• Return Box (Return Process)
During planning sessions, the team refers to the metaphor
to clarify features and requirements.
Benefits of Using the
Metaphor
• Shared Understanding:
o All team members, regardless of their technical expertise, can
easily understand and communicate about the system using
the physical library metaphor.
• Simplified Communication:
o Stakeholders and developers can discuss the system’s
components and features in a way that is intuitive and
familiar, reducing misunderstandings.
• Guidance for Design and Development:
o The metaphor provides a guiding vision for the architecture
and user experience, helping the team make consistent design
decisions.
Key Concepts of Refactoring in XP
Incremental • Refactoring is done in small steps, making minor changes that collectively improve the
codebase over time.
Improvement
Continuous Process • It is an ongoing activity integrated into the daily development workflow, not a separate phase.
Preservation of • Refactoring ensures that the existing functionality of the code remains unchanged while its
structure is improved.
Behaviour
• Developers identify "code smells," which are indicators of potential issues in the code that
Code Smells may benefit from refactoring, such as duplicated code, long methods, and large classes.
Steps following XP
Whole Team, Planning game,
Metaphor, Sustainable pace
Planning
TDD, Customer test
Refactoring,
Test Design Simple design
Small releases, Continuous
integration, Coding Standard, Coding
Collective ownership, Pair
programming
Examples of XP in Non-Software
Sectors
• Manufacturing:
o Pair Work: Engineers and technicians working together on assembly
lines to enhance quality control.
o Continuous Feedback: Regular quality checks and team meetings to
address issues and optimize processes.
o Iterative Development: Developing new products through prototyping
and iterative testing, incorporating feedback from initial production runs.
Lean Methodology
✓ Lean software development originates from lean manufacturing principles.
✓ The concept was brought into manufacturing to improve profits by reducing costs instead of
solely relying on increased sales.
✓ Unlike traditional waterfall project management, which dictates a set plan laid out by a project
manager, lean strives to reduce all tasks and activities that do not provide real value.
✓ This helps ensure everyone involved in a project or product development can work optimally.
Principles of Lean Manufacturing
Map Value
Define Value
Stream
Create Flow Establish Pull
Percue
Perfection
Lean
Software
Development
- Principles
https://appinventiv.com/blog/how-we-integrate-lean-principles-in-software-development/
1. Eliminate Waste
Waste of work-in-progress i.e., the partial work
.
Waste of overproduction waste
Processes waste
Software defects
https://appinventiv.com/blog/how-we-integrate-lean-principles-in-software-development/
Types of Waste
Lean philosophy regards everything not
adding value to the customer as waste (muda).
Such waste may include:
• Partially done work
• Extra features
• Task switching
• Waiting
• Defects
• Extra Documentation
https://en.wikipedia.org/wiki/Lean_software_development#Eliminate_waste
2. Create Knowledge
It is about capturing valuable insights and experiences to
share and retain them for future projects. Here's how it's
done:
➢ Code Reviews
➢ Documentation
➢ Knowledge Sharing Sessions
➢ Training and Mentorship
➢ Wiki or Knowledge Base
➢ Thorough Code Comments
https://appinventiv.com/blog/how-we-integrate-lean-principles-in-software-development/
3. Build Quality In
There are various lean agile software
development approaches that we apply to
better the product quality:
➢Pair programming
➢Testing criteria
➢Incremental development
➢Automation
https://appinventiv.com/blog/how-we-integrate-lean-principles-in-software-development/
4. Fast Delivery
• By breaking down projects into small, manageable increments and delivering
them as soon as they're ready, teams can provide immediate customer value.
• This iterative approach allows for quick adaptations to changing
requirements, reducing the risk of delivering a product that doesn't meet user
needs.
https://appinventiv.com/blog/how-we-integrate-lean-principles-in-software-development/
5. Empower Your Team
➢This means giving them the autonomy and
responsibility to make decisions, plan work,
and continuously improve their processes.
➢This sense of ownership fosters a motivated
and engaged team, which leads to higher-
quality products and faster delivery.
https://appinventiv.com/blog/how-we-integrate-lean-principles-in-software-development/
6. Delay in Making Decision
➢ Sometimes, deciding late is not equal to becoming irresponsible.
➢In fact, it encourages the team to keep their options open for a long period of
time so that they can gather data that can help make important decisions.
➢The result of this is that our project never suffers from negative impacts that
emerge because of bad decision-making.
https://appinventiv.com/blog/how-we-integrate-lean-principles-in-software-development/
7. Optimize the whole
• Rather than focusing on individual tasks
or components, Lean Software Development
encourages teams to optimize the entire
development process.
• This holistic approach ensures that each
part of the process is aligned with the overall
goal of delivering value to the customer.
• It also helps identify bottlenecks and
improvement areas across the workflow.
https://appinventiv.com/blog/how-we-integrate-lean-principles-in-software-development/
https://www.linkedin.com/pulse/lean-software-development-building-efficient-customer-centric/
MCQs
Q1. Which of the following is NOT a key principle of Extreme Programming (XP)?
A) Communication
B) Simplicity
C) Hierarchy
D) Feedback
Q1. Which of the following is NOT a key principle of Extreme Programming (XP)?
A) Communication
B) Simplicity
C) Hierarchy
D) Feedback
Q2: Which XP practice involves two team members collaborating closely on a task?
A) Continuous Integration
B) Pair Work
C) User Stories
D) Refactoring
Q2: Which XP practice involves two team members collaborating closely on a task?
A) Continuous Integration
B) Pair Work
C) User Stories
D) Refactoring
Q3: Which XP practice emphasizes defining success criteria before starting work and can
be adapted to product design?
A) Pair Work
B) Test-Driven Development (TDD)
C) Continuous Feedback
D) Iterative Development
Q3: Which XP practice emphasizes defining success criteria before starting work and can
be adapted to product design?
A) Pair Work
B) Test-Driven Development (TDD)
C) Continuous Feedback
D) Iterative Development
Q4: In XP, what is the purpose of the "metaphor" practice?
A) To reduce the complexity of code
B) To provide a simple shared story that guides the development and design
C) To write tests before the code
D) To ensure code is continuously integrated
Q4: In XP, what is the purpose of the "metaphor" practice?
A) To reduce the complexity of code
B) To provide a simple shared story that guides the development and design
C) To write tests before the code
D) To ensure code is continuously integrated
Q5: What is a key benefit of automated testing in XP?
A) It eliminates the need for manual coding
B) It provides immediate feedback on code changes, reducing bugs
C) It replaces the need for continuous integration
D) It makes documentation unnecessary
Q5: What is a key benefit of automated testing in XP?
A) It eliminates the need for manual coding
B) It provides immediate feedback on code changes, reducing bugs
C) It replaces the need for continuous integration
D) It makes documentation unnecessary
“Work hard, be kind,
and amazing things
will happen."
Conan O'Brien
7/10/2024 1:24 AM 36
7/10/2024 1:24 AM 37
