1. Agile Process: Overview
Agile software engineering represents a reasonable compromise to conventional software engineering for certain classes of software
Agile development processes can deliver successful systems quickly
Agile development stresses continuous communication and collaboration among developers and customers

2. Manifesto for Agile Software Development
Better 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
While the items on the right are still important the items on the left are more valuable under this philosophy

3. What is “Agility”? 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

4. Agile Teams are responsive to changes during project development
recognize that project plans must be flexible
eliminates the separation between customers and developers

5. Agility
encourages team structures that make communication among developers and customers easier
emphasizes importance of rapid delivery of operational software and de-emphasizes importance of intermediate work products
can be applied to any software process as long as the project team is allowed to streamline tasks and conduct planning in way that eliminate non-essential work products

6. 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 implementation
Delivers multiple ‘software increments’
Adapts as changes occur

7. Human Factors
Traits that need to exist in members of agile development teams:
Competence
Common focus
Collaboration
Decision-making ability
Fuzzy-problem solving ability
Mutual trust and respect
Self-organization

8. Agile Process Models Extreme Programming (XP)
Adaptive Software Development (ASD)
Dynamic Systems Development Method (DSDM)
Scrum
Crystal
Feature Driven Development (FDD)
Agile Modeling (AM)

9. Extreme Programming (XP)
One of the first proposed agile processes
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
Probably not practical, but introduced many agile practices

10. Adaptive Software Development (ASD)
Self-organization arises when independent agents cooperate to create a solution to a problem that is beyond the capability of any individual agent
Adaptive cycle characteristics
Mission-driven planning
Component-based focus
Uses “time-boxing”
Explicit consideration of risks
Emphasizes collaboration for requirements gathering
Emphasizes “learning”

11. Dynamic Systems Development Method
Provides a framework for building and maintaining systems which meet tight time constraints using incremental prototyping in a controlled environment
Uses Pareto principle (80% of project can be delivered in 20% time required to deliver the entire project)
Each increment only delivers enough functionality to move to the next increment

12. Dynamic Systems Development Method
Guiding principles
Active user involvement
Teams empowered to make decisions
Fitness for business purpose is criterion for deliverable acceptance
Iterative and incremental development needed to converge on accurate business solution
All changes made during development are reversible
Requirements are baselined at a high level
Testing throughout life-cycle

13. Agile Modeling
Practice-based methodology for effective modeling and documentation of software systems in a light-weight manner
Modeling principles
Model with a purpose
Use multiple models
Travel light (only keep models with long-term value)
Content is more important than representation
Know the models and tools you use to create them
Adapt locally