AGILE PROCESS MODELS

Introduction
• An agile philosophy for software engineering stresses four key issues –
– The importance of self-organizing teams that have control over the
work they perform
– Communication and collaboration between team members and
between practitioners & their customers
– A recognition that change represents an opportunity
– An emphasis on rapid delivery of software that satisfies the
customer
• Agile process models have been designed to address each of these
issues.
 What is “Agility”?
• Agility means effective (rapid and adaptive) response to change,
effective communication among all stockholder.
• Drawing the customer onto team and organizing a team so that it is in
control of work performed. -The Agile process, light-weight methods
are People-based rather than plan-based methods.
• The agile process forces the development team to focus on software
itself rather than design and documentation.
• The agile process believes in iterative method.
• The aim of agile process is to deliver the working model of software
quickly to the customer For example: Extreme programming is the best
known of agile process.
 Principles to achieve agility – by the Agile
Alliance (1)

1. Highest priority ==> satisfy the customer

2. Welcome changing requirements
3. Deliver working software frequently
4. Business people and developers must work together
5. Build projects around motivated individuals
6. Emphasize face-to-face conversation
 Principles to achieve agility – by the
Agile Alliance (2)
7. Working software is the primary measure of progress
8. Agile processes promote sustainable development
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 designs emerge from self-organizing teams
12. The team tunes and adjusts its behavior to become more
effective
 Agile Software Process
• An agile process must be adaptable
• It must adapt incrementally
• Requires customer feedback
• An effective catalyst for customer feedback is an operational
prototype or a portion of an operational system
– An incremental development strategy should be instituted.
• Software increments must be delivered in short time periods
– Enables the customer to evaluate the software increment
regularly
– Provide necessary feedback to the software team
UGCNET-DEC2018-II-59
UGCNET-DEC2018-II-59
 UGCNET-DEC2018-II-59
Agile Software Development is based on twelve principles:
1. Customer satisfaction by early and continuous delivery of valuable software.
2. Welcome changing requirements, even in late development.
3. Deliver working software frequently (weeks rather than months)
4. Close, daily cooperation between business people and developers
5. Projects are built around motivated individuals, who should be trusted
6. Face-to-face conversation is the best form of communication (co-location)
7. Working software is the primary measure of progress
8. Sustainable development, able to maintain a constant pace
9. Continuous attention to technical excellence and good design
10. Simplicity—the art of maximizing the amount of work done—is essential
11. Best architectures, requirements, and designs emerge from self-organizing teams
12. Regularly, the team reflects on how to become more effective, and adjusts accordingly
UGCNET-June2013-III-3
UGCNET-June2013-III-3
 Agile Process Models
• Extreme Programming (XP)
• Adaptive Software Development (ASD)
• Dynamic Systems Development Method (DSDM)
• Scrum
• Crystal
• Feature Driven Development (FDD)
• Agile Modeling (AM)
 Extreme Programming (XP)
• The most widely used agile process, originally proposed by
Kent Beck.
• XP uses an object-oriented approach as its preferred
development paradigm.
• XP suggests a number of innovative & powerful techniques
that allow an agile team to create frequent software releases
delivering features & functionality described & prioritized by
the customer.
 Extreme Programming (XP)

 XP defines four framework activities:

1) Planning
2) Design
3) Coding
4) Testing
 XP – Planning
• Begins with the creation of a set of stories (also called user stories)
• Each story is written by the customer and is placed on an index card
• The customer assigns a value (i.e. a priority) to the story
• Agile team assesses each story and assigns a cost
• Stories are grouped together for a deliverable increment
• A commitment is made on delivery date, and the XP team orders the stories
to be developed
• After the first software increment, the XP team computes ―project velocity‖
which is used to help define subsequent delivery dates for other increments.
 XP – Design
• Follows the KIS (keep it simple) principle
• Encourages the use of CRC (class-responsibility-collaborator) cards as an
effective mechanism for thinking about the software in an object-oriented
context.
• For difficult design problems, XP suggests the creation of ―spike
solutions‖—a design prototype.
• A spike solution is a very simple program to explore potential solutions.
Build the spike to only addresses the problem under examination and
ignore all other concerns.
• Encourages ―refactoring‖—an iterative refinement of the internal program
design.
• Design occurs both before and after coding commences.
 XP – Coding
• Recommends the construction of a series of unit tests for each of the
stories before coding commences
• Encourages ―pair programming‖
– Mechanism for real-time problem solving and real-time quality
assurance
– Keeps the developers focused on the problem at hand
• Needs ―continuous integration‖ with other portions (stories) of the s/w,
which provides a ―smoke testing‖ environment that helps to uncover
errors early.
 XP – Testing
• Unit tests should be implemented using a framework to make testing
automated. This encourages a regression testing strategy.
• Integration and validation testing can occur on a daily basis.
• Acceptance tests, also called customer tests, are specified by the
customer and focus on overall system features & functionality that are
visible & reviewable by the customer.
• Acceptance tests are derived from user stories.
 Adaptive Software Development
(ASD)
• ASD stresses human collaboration and team self-organization.
• ASD uses an iterative process that incorporates adaptive cycle planning ,
relatively rigorous requirements gathering methods, and an iterative
development cycle that incorporates customer focus groups & FTRs as
real-time feedback mechanism.
Adaptive Software Development
(ASD)
 Adaptive Software Development
(ASD)
• ASD is organized as three framework activities –
1) Speculation ==> Project initiation, Adaptive Cycle
Planning(Customer’s mission statement, Project constraints, Basic
requirements, Time-boxed release plan)
2) Collaboration ==>Motivated people work together in a way that
multiplies their talent and creative output beyond their absolute
number.
3) Learning ==> learning will help team to improve level of
understanding regarding problem.
ASD teams learn in three ways –Focus groups for feedback, FTRs,
Postmortems
 Adaptive Software Development
(ASD)
Focus groups :- The customer and/or end users provide feedback on
software increments that are being delivered. This process is direct
indication of whether or not product is satisfying business needs.
Formal technical review – ASD team members review the software
components that are developed, improving quality and learning as
they proceed.
Postmartems – The ASD team becomes introspective, addressing its own
performance and process.
 Dynamic Systems Development Method
(DSDM)
• An agile software development approach that provides a framework for
building & maintaining systems which meet tight time constraints through
the use of incremental prototyping in a controlled project environment.
• Similar in some respects the RAD process.
• Suggests a philosophy that is borrowed from a modified version of the
Pareto principle ( 80 % of an application can be delivered in 20% of the
time).
• Like XP & ASD, DSDM suggests an iterative software process.
• Advocates the use of time-box scheduling and suggests that only enough
work is required for each software increment to facilitate movement to the
next increment.
 Dynamic Systems Development Method
(DSDM)
 DSDM defines three different iterative cycles –
1) Functional model iteration:- produces a set of
incremental prototypes that demonstrate functionality
for the customer.
2) Design and build iteration :- Revisits the prototype
built in functional model to ensure business values
implementation.
3) Implementation:- Places latest software increments
 Dynamic Systems Development Method
(DSDM)
• These three cycles are preceded by two
additional life cycle activities –
a) Feasibility study:- Establish the basic business
requirements and constraints
b) Business study :- Establish the functional and
informational requirements ,defines the basic
architecture and identifies the maintainability
requirement for the application.
 Scrum
• Scrum is an iterative and incremental agile
software development method.
• Scrum incorporates a set of process patterns that
emphasize:
– Project priorities
– Compartmentalized work units
– Communication
– Frequent customer feedback
 Scrum
• Scrum emphasizes the use of a set of software process patterns that have
proven effective for projects with tight timelines, changing requirements,
and business criticality.
• Framework activities –Requirements, Analysis, Design, Evolution,
Delivery. Within each framework activity, work tasks occur within a
process pattern called a sprint.
• Each process pattern defines a set of development tasks and allows the
Scrum team to construct a process that is adapted to the needs of the
project.
 Scrum
• Scrum emphasizes the use of a set of software process patterns that have
proven effective for projects with tight timelines, changing requirements,
and business criticality.
• Framework activities –Requirements, Analysis, Design, Evolution,
Delivery. Within each framework activity, work tasks occur within a
process pattern called a sprint.
• Each process pattern defines a set of development tasks and allows the
Scrum team to construct a process that is adapted to the needs of the
project.
– Backlog
– Sprint
– Scrum meeting
Feature Driven Development (FDD)
 Feature Driven Development (FDD) was originally conceived by Peter
Coad and his colleagues as a practical process model for object-oriented
software engineering.
 .
Feature Driven Development (FDD)
Feature Driven Development (FDD)
 Like other agile approaches, FDD adopts a philosophy that

(1) emphasizes collaboration among people on an FDD team;

(2) manages problem and project complexity using feature-based
decomposition followed by the integration of software increments, and
(3) communication of technical detail using verbal, graphical, and text-based
means.
FDD emphasizes software quality assurance activities by encouraging an
incremental development strategy, the use of design and code inspections, the
application of software quality assurance audits the collection of metrics, and
the use of patterns (for analysis, design, and construction).
Feature Driven Development (FDD)
In the context of FDD, a feature ―is a client-valued function that can be
implemented in two weeks or less‖ .
The emphasis on the definition of features provides the following benefits:

• Because features are small blocks of deliverable functionality, users can

describe them more easily; understand how they relate to one another more
readily; and better review them for ambiguity, error, or omissions.

• Features can be organized into a hierarchical business-related grouping.

Since a feature is the FDD deliverable software increment, the team develops
operational features every two weeks
.
Feature Driven Development (FDD)
• Because features are small, their design and code representations are easier to
inspect effectively.
• Project planning, scheduling, and tracking are driven by the feature
hierarchy, rather than an arbitrarily adopted software engineering task set.
 Crystal
 The Crystal family is actually a set of example agile processes that have
been proven effective for different types of projects. The intent is to allow
agile teams to select the member of the crystal family that is most
appropriate for their project and environment.

 The concept is to achieve maneuverability. a planned and regulated

movement.

 To achieve maneuverability, Cockburn and Highsmith have defined a set of

methodologies, each with core elements that are common to all, and roles,
process patterns, work products, and practice that are unique to each.
 Agility vs. Software Engineering

 So…..What you gonna choose?

 Agility, or Software Engineering?
 Agility vs. Software Engineering
• You don’t have to choose between agility and
software engineering!
• Instead, define a software engineering approach that
is agile.
Dec 2019
UGCNET-June2015-III-60
UGCNET-June2015-III-60
UGCNET-Nov2017-II-43
 UGCNET-Nov2017-II-43

Agile software development testing is completed in the same iteration as

programming. One phase is completed in its entirety before moving on to the next
phase because testing is done in every iteration which develops a small piece of
the software users can frequently use those new pieces of software and validate
the value.