Agile Notes

The most widely-used Agile methodologies include:

 Agile Scrum Methodology

 Lean Software Development
 Kanban
 Extreme Programming (XP)
 Crystal
 Dynamic Systems Development Method (DSDM)
 Feature Driven Development (FDD)

Lean Software Development

Lean Software Development   is an iterative Agile methodology that focuses the
team on delivering value to the customer through effective value stream
mapping. It is a highly flexible, evolving methodology without rigid guidelines,
rules, or methods.

The main principles of the Lean methodology include:

 Eliminating Waste
 Amplifying Learning
 Deciding as Late as Possible
 Delivering as Fast as Possible
 Empowering the Team
 Building Integrity In
 Seeing the Whole

Lean development eliminates waste by asking users to select only the truly valuable
features for a system , prioritize those features, and then work to deliver them in small
batches. It relies on rapid and reliable feedback between programmers and
customers, emphasizing the speed and efficiency of development workflows. Lean
uses the idea of a work product being “pulled” via customer request. It gives decision-
making authority to individuals and small teams since this has been proven to be a
faster and more efficient method than a hierarchical flow of control. Lean also
concentrates on the efficient use of team resources, trying to ensure that everyone is
as productive as possible for the maximum amount of time. It strongly recommends
that automated unit tests be written at the same time the code is written.

Kanban
Kanban  is a highly visual workflow management method  that is popular among
Lean teams. In fact, 83% of teams practicing Lean use Kanban to visualize and
actively manage the creation of products with an emphasis on continual
delivery, while not adding more stress to the software development life cycle.
Like Scrum, Kanban is a process designed to help teams work together more
effectively.
Kanban is based on 3 basic principles:

 Visualize what you’ll do today (workflow automation): Seeing all the items within
the context of each other can be very informative
 Limit the amount of work in progress (WIP): This helps balance the flow-based
approach so teams don‘t start and commit to too much work at once
 Enhance flow: When something is finished, the next highest priority item from the
backlog is pulled into play

Kanban promotes continuous collaboration and encourages active, ongoing

learning and improvement by defining the best possible team workflow.

Extreme Programming (XP)

Extreme Programming  (XP), originally described by Kent Beck, has emerged
as one of the most popular and controversial Agile models. XP is a disciplined
approach for high-quality agile software development, focused on speed and
continuous delivery . It is intended to improve software quality
and responsiveness in the face of changing customer requirements . It
promotes high customer involvement, rapid feedback loops, continuous testing,
continuous planning, and close teamwork to deliver working software at very
frequent intervals, typically every 1-3 weeks.

The methodology takes its name from the idea that the beneficial elements of
traditional software engineering practices are taken to “extreme” levels. As an
example, code reviews are considered a beneficial practice. Taken to the
extreme, code can be reviewed continuously through the practice of pair
programming.

The original XP method is based on four simple values: simplicity,

communication, feedback, and courage.

It also has twelve supporting practices:

 Planning Game
 Small Releases
 Customer Acceptance Tests
 Simple Design
 Pair Programming
 Test-Driven Development
 Refactoring
 Continuous Integration
 Collective Code Ownership
 Coding Standards
 Metaphor
 Sustainable Pace

Don Wells has depicted the XP process in this popular diagram:

In XP, the customer works closely with the development team to define and
prioritize user stories. The development team estimates, plans, and  delivers
the highest priority user stories  in the form of working, tested software on an
iteration-by-iteration basis. In order to maximize productivity, the practices
provide a supportive, lightweight framework to guide a team and ensure high-
quality enterprise software.

Pair Programming

All code to be sent into production is created your team with experience to show everyone what
by two people working together at a single it should feel like.
computer. Pair programming increases software One thing pair programming is not is
quality without impacting time to deliver. It is mentoring. A teacher-stundent relationship feels
counter intuitive, but 2 people working at a single very different from two people working together as
computer will add as much functionality as two equals even if one has significantly more experience.
working separately except that it will be much It takes time to get used to pair programming so
higher in quality. With increased quality comes big don't worry if it feels awkward at first. 
savings later in the project.
The best way to pair program is to just sit
side by side in front of the monitor. Slide the key
board and mouse back and forth. Both programmers
concentrate on the code being written.
Pair programming is a social skill that takes
time to learn. You are striving for a cooperative way
to work that includes give and take from both
partners regardless of corporate status. The best
pair programmers know when to say "let's try your
idea first." Don't expect people to be good at it from
the start. It helps if you have someone on
Crystal
The Crystal methodology  is one of the most lightweight, adaptable approaches
to software development.

Crystal is actually comprised of a family of Agile process models, including

Crystal Clear, Crystal Yellow, Crystal Orange and others. Each has unique
characteristics driven by several factors, such as team size, system criticality,
and project priorities. This Crystal family addresses the realization that each
project may require a slightly tailored set of policies, practices, and processes
in order to meet the product ‘s unique characteristics.

Introduced by Alistair Cockburn, Crystal focuses primarily on people and the

interaction among them while they work on an agile software development
project. There is also a focus on business-criticality and business-priority of the
system under development .

Unlike traditional development methods, Crystal doesn’t try to fix the tools and
techniques of development but keeps people and processes at the core of the
process. However, it is not only the people or the processes that are important,
rather the interaction between them that is most important.

Several key tenets of Crystal include teamwork, communication, and simplicity,

as well as reflection to frequently adjust and improve the process. Like other
Agile frameworks, Crystal promotes early, frequent delivery of working
software, high user involvement, adaptability, and the removal of bureaucracy
or distractions.
Dynamic Systems Development Method (DSDM)
The Dynamic Systems Development Method  (DSDM) is an Agile approach that
grew out of the need to provide a common industry framework for rapid
software delivery . Since 1994, the DSDM methodology has evolved to provide
a comprehensive foundation for planning, managing, executing, and scaling
Agile process and iterative software development projects.

DSDM is based on eight key principles that direct the team and create a
mindset to deliver on time and within budget. These agile principles primarily
revolve around business needs/value, active user involvement, empowered
teams, frequent delivery, integrated testing, and stakeholder collaboration.
DSDM specifically calls out “fitness for business purpose” as the primary
criteria for delivery and acceptance of a system, focusing on the useful 80% of
the system that can be deployed in 20% of the time.

Compromising any of the following principles undermines the philosophy of

DSDM and introduces risk to the successful outcome of the project .

DSDM’s Eight Key Principles: 

1. Focus on the business need

2. Deliver on time
3. Collaborate
4. Never compromise quality
5. Build incrementally from firm foundations
6. Develop iteratively
7. Communicate continuously and clearly
8. Demonstrate control

Business Requirements are baselined at a high level early on in the project.

Rework is built into the process, and all development changes must be
reversible. System requirements are planned and delivered in short, fixed-
length time-boxes  – also known as sprints or iterations – and prioritized using
MoSCoW Rules.

MoSCoW Rules:

M – Must have requirements

S – Should have if at all possible
C – Could have but not critical
W – Won‘t have this time, but potentially later

All critical work must be completed in a DSDM project’s defined time-box. It is

also important that not every requirement in a project or time-box is considered
critical . Within each time-box, less critical items are also included so that they
can be removed to keep from impacting higher priority requirements on the
schedule.

Refer- https://www.agilebusiness.org/page/TheDSDMAgileProjectFramework
Feature Driven Development (FDD)
Feature Driven Development   is a model-driven, short-iteration process that
was built around software engineering best practices such as domain object
modeling, developing by feature, and code ownership. The blending of these
practices that resulted in a cohesive whole is the best characteristic of FDD.

Feature Driven Development consists of five basic activities:

 Development of an overall model

 Building a feature list
 Planning by feature
 Designing by feature
 Building by feature

FDD begins by establishing an overall model shape, which will result in a

feature list. It then continues with a series of two-week “plan by feature, design
by feature, build by feature” iterations. The features are small, “useful in the
eyes of the client” results. If they will take more than two weeks to build, then
they will have to be broken down into smaller features.

FDD’s main purpose is to deliver tangible, working software in a timely

manner, repeatedly. The advantage of using FDD is that it is scalable even to
large teams  due to the concept of ‘just enough design initially’ (JEDI). Because
of its feature-centric process, FDD is a great solution to maintain control for
incremental and inherently complex Agile project management.

Feature-Driven Development (FDD) is a client-centric, architecture-centric, and pragmatic software

process. The term "client" in FDD is used to represent what Agile Modeling (AM) refers to as project
stakeholders or eXtreme Programming (XP) calls customers. FDD was first introduced to the world in
1999 via the book Java Modeling In Color with UML, a combination of the software process followed
by Jeff DeLuca's company and Peter Coad's concept of features. FDD was first applied on a 15
month, 50-person project for a large Singapore bank in 1997, which was immediately followed by a
second, 18-month long 250-person project. A more substantial description is published in the book A
Practical Guide to Feature-Driven Development as well as the Feature Driven Development web site.

As the name implies, features are an important aspect of FDD. A feature is a small, client-valued

function expressed in the form <action><result><object>. For example, "Calculate the total of a sale",
"Validate the password of a user", and "Authorize the sales transaction of a customer". Features are
to FDD as use cases are to the Rational Unified Process (RUP) and user stories are to Scrum -
they're a primary source of requirements and the primary input into your planning efforts.

As you see in Figure 1 there are five main activities in FDD that are performed iteratively. The first is
Develop An Overall Model, the initial result being a high-level object model and notes. At the start of a
project your goal is to identify and understand the fundamentals of the domain that your system is
addressing, and throughout the project you will flesh this model out to reflect what you're building. The
second step is Build A Features List, grouping them into related sets and subject areas. These first
two steps map to the initial envisioning effort of AMDD (see Figure 2). Next you Plan By Feature, the
end result being a development, the identification of class owners (more on this in a minute), and the
identification of feature set owners. The majority of the effort on an FDD project, roughly 75%, is
comprised of the fourth and fifth steps: Design By Feature and Build By Feature. These two activities
are exactly what you'd expect, they include tasks such as detailed modeling, programming, testing,
and packaging of the system.
Figure 1. The FDD project lifecycle.

Figure 2. The lifecycle of AMDD.

An FDD project starts by performing the first three steps in the equivalent of the
DAD's Inception phase or XP's "iteration 0", the goal being to identify the scope
of the effort, the initial architecture, and the initial high-level plan. Construction
efforts occur in two-week (or less) iterations, similar to XP or DAD teams, with
the team iteratively working through all five steps as needed. As with other agile
software development processes, systems are delivered incrementally by FDD
teams.

There are six primary roles on an FDD project: Project Manager, Chief Architect,
Development Manager, Chief Programmer, Class Owner, and Domain Expert.
An individual will take on one or more roles on a project as you would expect.
The concept of a class owner is where FDD differs from XP. XP includes a
practice called Collective Ownership the idea of which is that any developer can
update any artifact, including source code, as required. FDD takes a different
approach in that it assigns classes to individual developers, so if a feature
requires changes to several classes then the owners of those classes must work
together as a feature team to implement it. Just like programming pairs
will model storm to think something through before they code it, so will feature
teams.

FDD also defines a collection of supporting roles, including:

 Domain Manager
 Release Manager
 Language Guru
 Build Engineer
 Toolsmith
 System Administrator
 Tester
 Deployer
 Technical Writer

FDD's five steps are supported by several practices. The first is domain object modeling, the creation
of a high-level class diagram and supporting artifacts that describes the problem domain. Developing
by feature and individual class ownership are also good practices, as is having developers work
together in feature teams. Inspections are an important aspect of FDD. FDD also insists on regular
builds, similar to XP, and configuration management. Finally, FDD promotes a best practice called
reporting/visibility of results, similar to XP and AM's philosophy of open and honest communication.

How would Agile Modeling (AM) be applied on an FDD project? The principles and practices can be
clearly applied to FDD's two modeling-oriented steps - develop an overall model and design by
feature. The only apparent mismatch between the two processes is FDD's practice of class ownership
and AM's practice of collective ownership, but I would argue that this isn't the case. FDD's practice
pertains to coding but does not to modeling, on a FDD project people work together in teams to
model, along the lines of AM's model with others practice, and therefore several people will be
working on your shared collection of modeling artifacts.