CSC/ECE 517 Fall 2009/wiki3 7 dEaN

What are agile practices

One can summarize the Agile practices in a nutshell by asserting the following characteristics: [1] [2]

• Agile methodology could be described as "iterative" and "incremental"
• Each iteration (also known as sprints or time-limited modules or timeboxes) involves a team working through a full software development cycle. In other words, each iteration has it own self-contained stages of analysis, design, production, testing and documentation.
• An iteration may not warrant a market release. Elaborating further: in theory, a new software release could be done at the end of each iteration, but in practice the progress made in one iteration may not be worth a release and it will be carried over and incorporated into the next iteration. The project's priorities, direction and progress are re-evaluated at the end of each iteration.
• Using the agile approach, tasks are broken into small increments with minimal planning. This is again achieved through iterations. Goal is to have an available release (with minimal bugs) at the end of each iteration.
• Teamwork, collaboration, and process adaptability throughout the life-cycle of the project are other important features in Agile development.
• Project requirements and solutions evolve through collaboration between self-organizing cross-functional teams. Agile teams tend to work as a team in a bullpen - an open floor-plan work area that makes face-to-face communications easy. In a brief session, team members report to each other what they did yesterday, what they intend to do today, and what their roadblocks are.
• Agile emphasizes working software as the primary measure of progress. A software project is often measured with the five dimensions - duration, risk, novelty, effort, and interaction.
• Rapid delivery of high-quality software is achieved, since the prototypes are delivered in increments.
• Agile methods are adaptive as compared to predictive when contrasted with other plan-driven methodologies. Refer Appendix for definition of terms

The Agile Manifesto is based on the following principles: [3] [4]
1. Customer satisfaction by rapid, continuous delivery of useful software
2. Working software is delivered frequently (weeks rather than months)
3. Working software is the principal measure of progress
4. Even late changes in requirements are welcomed
5. Close, daily cooperation between business people and developers
6. Face-to-face conversation is the best form of communication (co-location)
7. Projects are built around motivated individuals, who should be trusted
8. Continuous attention to technical excellence and good design
9. Simplicity
10. Self-organizing teams
11. Regular adaptation to changing circumstances

Example of agile practices

• It appeared under different names and flavours such as: Scrum (in management), Crystal Clear, Extreme Programming (XP), Adaptive Software Development, Feature Driven Development, and DSDM.

Scrum is an iterative incremental framework for managing complex work (such as new product development) commonly used with agile software development. One agile software solution is ScrumWorks Pro, a Scrum-specific project management tool. [5]	Image taken from www.1dot0.com
Extreme Programming (XP) is a software development methodology which is intended to improve software quality and responsiveness to changing customer requirements. As a type of agile software development, it advocates frequent "releases" in short development cycles (timeboxing), which is intended to improve productivity and introduce checkpoints where new customer requirements can be adopted. [6]	Image taken from www.aimtec.cz

Agile methodology lifecycle in pictures

Image taken from www.ibm.com

Image taken from www.michaelnygard.com

Image taken from www.leadinganswers.typepad.com

A brief overview on other methodologies

1. Waterfall model - The waterfall model is a sequential software development process, in which progress is seen as flowing steadily downwards (like a waterfall) through the phases of Conception, Initiation, Analysis, Design (validation), Construction, Testing and maintenance. [7]
2. RAD - Rapid Application Development refers to a type of software development methodology that uses minimal planning in favor of rapid prototyping. The "planning" of software developed using RAD is interleaved with writing the software itself. The lack of extensive pre-planning generally allows software to be written much faster, and makes it easier to change requirements. [8]
3. Prototyping model - The prototyping paradigm begins with requirements gathering. Developer and customer meet and define the overall objectives for the software, identify whatever requirements are known, and outline areas where further definition is mandatory. A "quick design" then occurs. The quick design focuses on a representation of those aspects of the software that will be visible to the customer/user (e.g. input approaches and output formats). The quick design leads to the construction of a prototype. The prototype is evaluated by the customer/user and used to refine requirements for the software to be developed. Iteration occurs as the prototype is tuned to satisfy the needs of the customer, while at the same time enabling the developer to better understand what needs to be done. Reference: Software Engineering - Roger Pressman
4. Spiral - The spiral model is a software development process combining elements of both design and prototyping-in-stages, in an effort to combine advantages of top-down and bottom-up concepts. Also known as the spiral lifecycle model (or spiral development), it is a systems development method (SDM) used in information technology. This model of development combines the features of the prototyping model and the waterfall model. The spiral model is intended for large, expensive and complicated projects. [9]

How can Agile complement other design methodologies

Agile development differs from other development models: in this model time periods are measured in weeks rather than months and work is performed in a highly collaborative manner. Most agile methods also differ by treating their time period as a timebox.

• The waterfall model is the most structured of the methods, stepping through requirements-capture, analysis, design, coding, and testing in a strict, pre-planned sequence. Progress is generally measured in terms of deliverable artifacts: requirement specifications, design documents, test plans, code reviews and the like. [10]
  • The main problem with the waterfall model is the inflexible division of a project into separate stages, so that commitments are made early on, and it is difficult to react to changes in requirements. Iterations are expensive. This means that the waterfall model is likely to be unsuitable if requirements are not well understood or are likely to change in the course of the project.
  • For some scenarios, Waterfall model was too slow and did not comfortably accommodate the ways systems/software engineers actually work best. Agile, put simply, is where software is developed progressively with each new release adding more capabilities.
  • In Agile methodology, the emphasis is on obtaining the smallest workable piece of functionality to deliver business value early, and continually improving it and adding further functionality throughout the life of the project. If a project being delivered under the waterfall method is canceled at any point up to the end, there is nothing to show for it beyond a huge resources bill. With the agile method, being canceled at any point will still leave the customer with some worthwhile code that has likely already been put into live operation.

• Agile methods have features in common with RAD.[11]
  • RAD and Agile are both short iterative processes that deliver a reduced feature set.
    • RAD = prototypes, reduced features.
    • Agile = iterations.
  • Traditionally the rapid application development approach involves compromises in usability, features, and/or execution speed. Agile on the other hand doesn't aim to achieve that. The iterations aren't prototypes, rather, each iteration introduces changes and/or enhancements into the product and these are reviewed by all parties involved.

• Another advantage of frequent iterations is that you expose the client to the new features gradually. They can provide feedback much quicker which can resolve any misconceptions that may have been harbored in the requirements. This feature of Agile can complement other process models like Waterfall and RAD.
  • The difference here between RAD and Agile is that in RAD you do not have immediate feedback from the client between iterations. It is up to the developers to split the development into iterations that are useful and logical. For example, you'd probably split 1 into some more iterations, for example, add an advanced search, etc. same with Iteration 2, add validation, feedback, etc.

Research results and experience reports

In this section we decided to focus on the following frequently used agile methodologies.

Extreme Programming

There is a lot of research taking place currently on extreme programming. Most of the papers published in this regard focus on the user experience of using extreme programming. A study conducted by Maurer and Martel(2000) on productivity gains reports an increase of 66.3% in the number of lines of code produced, 302.1% increase in the number of new methods developed and 282.6% increase in number of new classes implemented in a development effort.

Scrum

Research efforts in this area have mostly been focused on integrating XP and Scrum. It is believed that Scrum provides a project management framework that can increase the scalability of extreme programming. A report by Rising and Janof(2000) spoke about the successful application of Scrum to three software development projects. They mention that although Scrum was not a suitable approach for large and complex team structures, even in such cases isolated teams could make use of the Scrum methodology.

Conclusion

Agile methodology adheres to a rapid prototyping approach that builds the software in small bursts or sprints (iterations). Such an approach can complement other conventional software development life-cycle models where the stages are pre-planned and the software release spans a period of months as opposed to prototypes that are developed in weeks in Agile.

Agile home ground Low criticality Senior developers Requirements change often Small number of developers Culture that thrives on chaos

Plan-driven home ground High criticality Junior developers Requirements do not change often Large number of developers Culture that demands order

Appendix

• Adaptive methods focus on adapting quickly to changing realities. When the needs of a project change, an adaptive team changes as well.
• Predictive methods, in contrast, focus on planning the future in detail. A predictive team can report exactly what features and tasks are planned for the entire length of the development process.

References

1. http://en.wikipedia.org/wiki/Agile_software_development
2. http://agilemethodology.org/
3. http://www.agilemanifesto.org/
4. http://www.extremeprogramming.org/
5. http://en.wikipedia.org/wiki/Waterfall_model
6. http://en.wikipedia.org/wiki/Rapid_application_development
7. http://en.wikipedia.org/wiki/Spiral_model
8. http://agileintro.wordpress.com/2008/01/04/waterfall-vs-agile-methodology/
9. http://www.mckinnonsc.vic.edu.au/vceit/models/index.htm
10. Maurer,F. and Martel,S. (2002).Extreme programming: Rapid development for Web-based applications. IEEE Internet Computing 6(1):86-90.
11. Rising, L. and Janoff, N.S.(2000).The Scrum software development process for small teams. IEEE Software 17(4):26-32.
12. Software Engineering - Roger Pressman