Chapter 3

 AGILITY AND PROCESS

Software Engineering: A Practitioner’s Approach, 9/e

1
The Manifesto for
Agile Software Development
“We are uncovering better ways of
developing software by doing it and
helping others do it. Through this work
we have come to value:
•Individuals and interactions over
processes and tools
•Working software over
comprehensive documentation
•Customer collaboration over contract
negotiation
•Responding to change over following
a plan
That is, while there is value in the items
on the right, we value theKent Beck
items onetthe
al
left more.”
2
What is “Agility”?
 Effective (rapid and adaptive) response to
change
 Effective communication among all stakeholders
 Drawing the customer onto the team
 Organizing a team so that it is in control of the
work performed
Yielding …
 Rapid, incremental delivery of software

3
Agility and the Cost of Change

4
An Agile Process
 Is driven by customer descriptions of what is
required (scenarios)
 Recognizes that plans are short-lived
 Develops software iteratively with a heavy
emphasis on construction activities
 Delivers multiple ‘software increments’
 Adapts as changes occur

5
Agility Principles - I
1. Our highest priority is to satisfy the customer through
early and continuous delivery of valuable software.
2. Welcome changing requirements, even late in
development. Agile processes harness change for the
customer's competitive advantage.
3. Deliver working software frequently, from a couple of
weeks to a couple of months, with a preference to the
shorter timescale.
4. Business people and developers must work together
daily throughout the project.
5. Build projects around motivated individuals. Give them
the environment and support they need, and trust them
to get the job done.
6. The most efficient and effective method of conveying
information to and within a development team is face–
to–face conversation.

6
Agility Principles - II
7. Working software is the primary measure of
progress.
8. Agile processes promote sustainable
development. The sponsors, developers, and
users should be able to maintain a constant
pace indefinitely.
9. Continuous attention to technical excellence
and good design enhances agility.
10. Simplicity – the art of maximizing the amount
of work not done – is essential.
11. The best architectures, requirements, and
designs emerge from self–organizing teams.
12. At regular intervals, the team reflects on how
to become more effective, then tunes and
adjusts its behavior accordingly. 7
Human Factors
 the process molds to the needs of the
people and team, not the other way around
 key traits must exist among the people on
an agile team and the team itself:
 Competence.
 Common focus.
 Collaboration.
 Decision-making ability.
 Fuzzy problem-solving ability.
 Mutual trust and respect.
 Self-organization.

8
Scrum
 Originally proposed by Schwaber and Beedle
 Scrum—distinguishing features
 Development work is partitioned into “packets”
 Testing and documentation are on-going as the
product is constructed
 Work occurs in “sprints” and is derived from a
“backlog” of existing requirements
 Meetings are very short and sometimes conducted
without chairs
 “demos” are delivered to the customer with the time-
box allocated

9
Scrum : Scrum process flow

10
Scrum: Scrum Meeting
 15-minute event scheduled at the start of each workday
> plan for next 24 hours
 Three key questions are asked and answered by all team
members:
∙ What did you do since the last team meeting?
∙ What obstacles are you encountering?
∙ What do you plan to accomplish by the next
team meeting?
 The sprint review is often time-boxed as a 4-hour
meeting for a 4-week sprint.
 Sprint Retrospective > before beginning another
sprint planning meeting, 3-hour meeting (for a 4-
week sprint)

11
Extreme Programming (XP)
 The agile process, originally proposed by Kent
Beck
 XP Planning
 Begins with the creation of “user stories”
 Agile team assesses each story and assigns a cost
 Stories are grouped to for a deliverable increment
 A commitment is made on delivery date
 After the first increment “project velocity” is used to
help define subsequent delivery dates for other
increments

12
Extreme Programming (XP)
 XP Design
 Follows the KIS principle
 Encourage the use of CRC cards (see Chapter 8)
 For difficult design problems, suggests the creation of “spike
solutions”—a design prototype
 Encourages “refactoring”—an iterative refinement of the internal
program design
 XP Coding
 Recommends the construction of a unit test for a story before
coding commences
 Encourages “pair programming”
 XP Testing
 All unit tests are executed daily
 “Acceptance tests” are defined by the customer and executed to
assess customer visible functionality

13
Extreme Programming (XP)

14
Kanban

15
DevOps

16
DevOps
The DevOps approach involves several stages:
Continuous development: multiple sprints
with increments delivered
Continuous testing: Automated testing tools
Continuous integration: Code pieces with
new functionality > added to the existing code.
Continuous deployment: Integrated code
deployed (installed) to production environment.
Continuous monitoring: improve software
quality.

17
Comparing agile techniques

18
Key Points:

 Agile philosophy and its key issues