Agile Software Development

Need of Agile software development

History of Agile
 Introduction
Agile is a well-known development methodology and the
approach of choice for many development teams, especially those
trying to create an environment of continuous delivery.

Agile software development is a group of software development

methods based on iterative and incremental development, where
requirements and solutions evolve through collaboration
between self-organizing, cross-functional teams.
• Methods
• Iterative
• incremental
• It promotes adaptive planning, evolutionary
development and delivery, a time-boxed iterative
approach, and encourages rapid and flexible response
to change.

• It is a conceptual framework that promotes foreseen

interactions throughout the development cycle.
Iterative and Incremental Development
Iterative and Incremental development is at the heart of a cyclic
software development process developed in response to the
weaknesses of the waterfall model.

It starts with an initial planning and ends with deployment with

the cyclic interactions in between.

Iterative and incremental development are essential parts of the

Rational Unified Process, Extreme Programming and generally
the various agile software development frameworks.

It follows a similar process to the “plan-do-check-act” cycle of

business process improvement.
• High levels of collaboration

• Flexibility

• An Iterative environment in which requirements

evolve alongside changing needs.

• An approach that helps development teams across

various industries deliver new features faster.
 Waterfall model/ Agile Software
Development
Most teams used the Waterfall approach, a development
methodology that follows a set path in which teams:
• Set project requirements and the scope of work
• Design a product based on those pre-determined
requirements
• Build the product
• Test the product
• Fix any problems discovered during testing
• Launch a finished product
Waterfall required teams to stick to the requirements and scope
of work set out at the very beginning of the project and not make
any changes or additions along the way.

If the nature of the problem would often change (but the project
requirements would not), rendering the planned solution out of
date by the time it finally got to market.
 The History of Agile
Several software development teams began to change their
approach to planning and delivering new products throughout
the 1990s.

The development of Agile is started in the spring of 2000,

when a group of 17 software developers, to discuss how they
could speed up development times in order bring new software
to market faster.
They recognized two key opportunities that achieving this goal
would make possible:

• Shortening the delay of benefits to users in order to resolve

the product-market fit and development graveyard problems

• Getting feedback from users quickly to confirm the

usefulness of new software and continue to improve on it
accordingly.
A Manifesto is Born: Agile Comes into Focus

The history of Agile came into focus when the same

group of 17 developers met again, during this meeting,
they hoped to further expand on their progress and land
on a more concrete solution to the major development
problems of the time.

Within three days, the group produced the “Manifesto

for Agile Software Development” (known more
commonly as the Agile Manifesto).
A true turning point in the history of Agile, this
manifesto laid out four key values:
• Individuals and interactions over processes and tools
• Working software over comprehensive
documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan
• We are uncovering better ways of developing
• software by doing it and helping others do it.
• Through this work we have come to value
 Agile principles
The Agile Manifesto is based on 12 principles:
1. Customer satisfaction by rapid delivery of useful software
2. Welcome changing requirements, even late in development
3. Working software is delivered 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 principal 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 not done—is essential
11. Self-organizing teams
12. Regular adaptation to changing circumstance
 Important Characteristics
1. The Agile methodology allows for changes to be made
after the initial planning. Rewrites to the program, as the
client decides to make changes, are expected.

2. Because the Agile methodology allows you to make

changes, it’s easier to add features that will keep you up to
date with the latest developments in your industry.

3. At the end of each sprint, project priorities are

evaluated. This allows clients to add their feedback so that
they ultimately get the product they desire.
4. The testing at the end of each sprint ensures that the
bugs are caught and taken care of in the development
cycle. They won’t be found at the end.

5. Because the products are tested so thoroughly with

Agile, the product could be launched at the end of any
cycle. As a result, it’s more likely to reach its launch
date
Agile software development
Benefits
Agile’s continuous delivery approach has many advantages
versus a linear, Waterfall methodology. Here’s an overview:
1. Manage Change More Effectively
By creating smaller iterations, the team is able to focus on
providing value without needing to get all the requirements up
front. At the end of each iteration the team will review the
backlog of features and re prioritize where they should invest
time in the next sprint.
2. Improved Customer Engagement
Agile requires that the clients are significantly involved in the
development process. The development team is going to look to
the clients to prioritize what is going into the next sprint and to
review work product during review sessions. This continual
interaction reduces the confusion between what the client wants
and what the developers are going to provide.
3. Focus on the Highest Priorities First
In a software development environment, you have to make many
decisions and it’s tough to keep it all straight. Your backlog
becomes your ultimate, prioritized to-do list that lives out in the
open for all to see.

4. Increased Productivity
Agile makes better use of your resources, allowing them to get
started faster and remain productive throughout. With work
broken into iterations, there is always a milestone and deadline.
Developers are always focused on re factoring and moving
forward. They won’t be sitting idle, waiting for work during the
discovery and design phase.
5. Product Owner Feedback
With work broken into sprints, it is possible for you to provide
feedback before, during and after each one. This collaboration
provides frequent opportunities to ensure that the team is on
course to achieving the established business goals.

6. A Highly Collaborative Environment

Agile values individuals, interactions and customer collaboration.
All team members have buy-in the entire way. The success of the
project relies on acknowledging and optimizing each person’s
subject matter expertise.
7. Visibility
Agile lets you see and become intimately familiar with the
product from inception to completion. While watching the
application grow, you can provide feedback as it progresses.

8. Accuracy
After a sprint, the team will know their velocity. This allows for
better planning. In future sprints, this will serve as a guide for
what they will be able to accomplish.

9. Key Features First

Agile allows us to prioritize and focus on the items that provide
the biggest impact to the business to provide value faster.
10. Agree on Clear Definitions
Do the words “ready” and “done” create confusion for your IT
team? In the Agile world, you set the parameters for these
definitions. “Done” can mean fully tested, or it can mean that it is
ready for the client to test. Clear definitions give developers more
accountability, and everyone agrees on goals.

11. Improved Transparency

Agile is highly transparent. Everyone from stakeholders to the
development team knows what’s getting done, what’s not and
who is making decisions. When the entire team understands the
big picture, projects tend to move forward faster.