Chapter 5 – Agile Development

Download 26.87 Kb.
Date conversion23.12.2016
Size26.87 Kb.
Chapter 5Agile Development


  • Agile software engineering represents a reasonable compromise between to conventional software engineering for certain classes of software and certain types of software projects

  • Agile development processes can deliver successful systems quickly

  • Agile development stresses continuous communication and collaboration among developers and customers

  • Agile software engineering embraces a philosophy that encourages customer satisfaction, incremental software delivery, small project teams (composed of software engineers and stakeholders), informal methods, and minimal software engineering work products

  • Agile software engineering development guidelines stress on-time delivery of an operational software increment over analysis and design (the only really important work product is an operational software increment)

Manifesto for Agile Software Development

  • Proposes that it may be 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


  • An agile team is able to respond to changes during project development

  • Agile development recognizes that project plans must be flexible

  • Agility encourages team structures and attitudes that make communication among developers and customers more facile

  • Eliminates the separation between customers and developers
  • Agility emphasizes the importance of rapid delivery of operational software and de-emphasizes importance of intermediate work products

  • Agility 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

  • The costs of change increase rapidly as a project proceeds to completion, the earlier a change is made the less costly it will be

  • Agile processes may flatten the cost of change curve by allowing a project team to make changes late in the project at much lower costs

Agile Processes

  1. It is difficult to predict in advance which requirements or customer priorities will change and which will not

  2. For many types of software design and construction activities are interleaved (construction is used to prove the design)

  3. Analysis, design, and testing are not as predictable from a planning perspective as one might like them to be

  • Agile processes must be adapt incrementally to manage unpredictability

  • Incremental adaptation requires customer feedback based on evaluation of delivered software increments (executable prototypes) over short time periods

Agility Principles

  1. Highest priority is to satisfy customer through early and continuous delivery of valuable software

  2. Welcome changing requirements even late in development, accommodating change is viewed as increasing the customer’s competitive advantage

  3. Delivering working software frequently with a preference for shorter delivery schedules (e.g. every 2 or 3 weeks)

  4. Business people and developers must work together daily during the project
  5. Build projects around motivated individuals, given them the environment and support they need, trust them to get the job done

  6. Face-to-face communication is the most effective method of conveying information within the development team

  7. Working software is the primary measure of progress

  8. Agile processes support sustainable development, developers and customers should be able to continue development indefinitely

  9. Continuous attention to technical excellence and good design enhances agility

  10. Simplicity (defined as maximizing the work not done) is essential

  11. The best architectures, requirements, and design emerge from self-organizing teams

  12. At regular intervals teams reflects how to become more effective and adjusts its behavior accordingly

Agile Process Models

  • Extreme Programming (XP)

  • Scrum

  • Dynamic Systems Development Method (DSDM)

  • Agile Modeling (AM)

  • Agile Unified Process (AUP)

Extreme Programming

  • Relies on object-oriented approach

  • Values

    • Communication (close, informal between developers and stakeholders)

    • Simplicity (developers design for current needs, not future needs)

    • Feedback (implemented software – unit tests, customer – user stories guide acceptance tests, software team – iterative planning)

    • Courage (design for today not tomorrow)

    • Respect (stakeholders and team members for the software product)

  • Key activities

    • Planning (user stories created and ordered by customer values)

    • Design (simple designs preferred, CRC cards and design prototypes are only work products, encourages use of refactoring)
    • Coding (focuses on unit tests to exercise stories, emphasizes use of pairs programming to create story code, continuous integration and smoke testing is utilized)

    • Testing (unit tests created before coding are implemented using an automated testing framework to encourage use of regression testing, integration and validation testing done on daily basis, acceptance tests focus on system features and functions viewable by the customer)

Industrial XP

  • Readiness acceptance

    • Does an appropriate development environment exists to support IXP?

    • Will the team be populated by stakeholders?

    • Does the organization have a distinct quality program that support continuous process improvement?

    • Will the organizational culture support new values of the agile team?

    • Will the broader project community be populated appropriately?

  • Project community (finding the right people for the project team)

  • Project chartering (determining whether or not an appropriate business justification exists to justify the project)

  • Test-driven management (used to establish measurable destinations and criteria for determining when each is reached)

  • Retrospectives (specialized technical review focusing on issues, events, and lessons-learned across a software increment or entire software release)

  • Continuous learning (vital part of continuous process improvement)

XP Issues

  • Requirement volatility (can easily lead for scope creep that causes changes to earlier work design for the then current needs)

  • Conflicting customer needs (many project with many customers make it hard to assimilate all customer needs)

  • Requirements expressed informally (with only user stories and acceptance tests, its hard to avoid omissions and inconsistencies)
  • Lack of formal design (complex systems may need a formal architectural design to ensure a product that exhibits quality and maintainability)


  • Scrum principles

    • Small working team used to maximize communication, minimize overhead, and maximize sharing of informal knowledge

    • Process must be adaptable to both technical and business challenges to ensure bets product produced

    • Process yields frequent increments that can be inspected, adjusted, tested, documented and built on

    • Development work and people performing it are partitioned into clean, low coupling partitions

    • Testing and documentation is performed as the product is built

    • Provides the ability to declare the product done whenever required

  • Process patterns defining development activities

    • Backlog (prioritized list of requirements or features the provide business value to customer, items can be added at any time)

    • Sprints (work units required to achieve one of the backlog items, must fir into a predefined time-box, affected backlog items frozen)

    • Scrum meetings (15 minute daily meetings)

      • What was done since last meeting?

      • What obstacles were encountered?

      • What will be done by the next meeting?

    • Demos (deliver software increment to customer for evaluation)

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% required to deliver the entire project)
  • Each increment only delivers enough functionality to move to the next increment

  • Uses time boxes to fix time and resources to determine how much functionality will be delivered in each increment

  • Guiding principles

    • Active user involvement

    • Teams empowered to make decisions

    • Fitness foe business purpose is criterion for deliverable acceptance

    • Iterative and incremental develop needed to converge on accurate business solution

    • All changes made during development are reversible

    • Requirements are baselined at a high level

    • Testing integrates throughout life-cycle

    • Collaborative and cooperative approach between stakeholders

  • Life cycle activities

    • Feasibility study (establishes requirements and constraints)

    • Business study (establishes functional and information requirements needed to provide business value)

    • Functional model iteration (produces set of incremental prototypes to demonstrate functionality to customer)

    • Design and build iteration (revisits prototypes to ensure they provide business value for end users, may occur concurrently with functional model iteration)

    • Implementation (latest iteration placed in operational environment)

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
  • Requirements gathering and analysis modeling

    • Work collaboratively to find out what customer wants to do

    • Once requirements model is built collaborative analysis modeling continues with the customer

  • Architectural modeling

    • Derives preliminary architecture from analysis model

    • Architectural model mist be realistic for the environment and must be understandable by developers

Agile Unified Process

  • Adopts classic UP phased activities (inception, elaboration, construction, transition) to enable team to visualize overall software project flow

  • Within each activity team iterates to achieve agility and delivers meaningful software increments to end-users as rapidly as possible

  • Each AUP iteration addresses

    • Modeling (UML representations of business and problem domains)

    • Implementation (models translated into source code)

    • Testing (uncover errors and ensure source code meets requirements)

    • Deployment (software increment delivery and acquiring feedback)

    • Configuration and project management (change management, risk management, persistent work product control)

    • Environment management (standards, tools, technology)

The database is protected by copyright © 2017
send message

    Main page