The Flavors of Agile

There are various forms of agile methodologies, but they all share similar characteristics. You can think of these various methodologies as branches of the same religion. The cornerstone of each branch is the idea of customer satisfaction. They also feature many of the key ideas listed previously, as well as the practices and principles laid out in the Agile Manifesto. The key thing to remember about all the agile flavors is that every one of them is iterative.

Scrum
The Scrum methodology consists of a series of �sprints,� typically lasting two to four weeks, each delivering some working, potentially shippable software. The workload of each of these sprints is driven from the �product backlog.� The product backlog consists of new features, bug fixes, technical debt, and anything else that will contribute to the end deliverable. A product owner, with help from the customer, prioritizes the product backlog and works closely with the team via regular stand-up meetings and sprint retrospectives. The iterative aspect of Scrum is that this cycle is repeated over and over until the project is complete.


eXtreme Programming (XP)
eXtreme Programming (XP) is strongly focused on customer interaction and involvement. It has the following five values:
� Simplicity
� Communication
� Feedback
� Courage
� Respect

It also follows these twelve practices:
1. Planning Game
2. Small Releases
3. Customer Acceptance Tests
4. Simple Design
5. Pair Programming
6. Test-Driven Development
7. Refactoring
8. Continuous Integration
9. Collective Code Ownership
10. Coding Standards
11. Metaphor
12. Sustainable Pace

In XP, user stories are created to capture requirements from customers. These stories are then estimated by the developers, prioritized by the customer, and then developed into working software on an iteration-by-iteration basis. Continuous planning and delivery underpin the disciplined XP process. It is also worth noting that many of the practices in XP are shared by other branches of agile, like Scrum.


Crystal
The Crystal group of agile methodologies focuses more on people rather than process. It has a simple set of principles that enhances teamwork by concentrating on communication and the removal of project management noise. It also concentrates teams on the priorities and critical paths of the software development. Like Scrum and XP, it also encourages frequent delivery of working software.


Dynamic Systems Development Method (DSDM)
The Dynamic Systems Development Method (DSDM) is based on the 80/20 rule, in that 80 percent of the benefit a system will be derived from only 20 percent of the systems requirements. With this in mind, only work that is deemed critical for the system to operate is prioritized; that is, the first 20 percent of requirements. DSDM is prioritized using the so-called MoSCoW method, which is as follows:

M: Must have
S: Should have, if at all possible
C: Could have, but not critical
W: Won�t have this time, but potentially later

All �must have� work is committed to being completed in the course of the project; all other work is deemed a �nice to have� and is picked up only when the core requirements have been implemented.


Feature-Driven Development (FDD)
Feature-driven development (FDD) begins by creating a model of the domain under development. Once this is completed, an iterative process of feature design and implementation begins. Features represent a useful grouping of functionality to the customer. FDD is made up of the following five simple activities:

1. Develop the Domain Object Model
2. Create a feature list
3. Plan by feature
4. Design by feature
5. Build by feature


Lean Software Development
Lean software development comes from the Lean manufacturing principles that were derived mostly from the production system created by Toyota. Lean focuses on customer value and the elimination of waste. It achieves this by following these next seven principles:

1. Eliminate waste: Selects only the most valuable features for a customer.
2. Amplify learning: Learn by doing and testing things rather than documenting.
3. Decide as late as possible: Delay decisions in order to enable more facts to be gathered and changes to take place.
4. Deliver as fast as possible: The sooner software is delivered, the sooner feedback is received and incorporated into the next release, giving fast return on investment to the business.
5. Empower the team: Make the team responsible and increase motivation by including all members in the decision-making process.
6. Build integrity in: Re-factor regularly to keep code flexible and adaptable to change.
7. See the whole: Ensure that domain knowledge is spread throughout the team in order for problems to be identified at any level of the system.

Source of Information : Pro Agile .NET Development with SCRUM