CSC/ECE 517 Fall 2007/wiki3 10 10

The Agile debate. Perhaps the most prominent controversy in o-o design today is whether it is possible to do a robust design with as little advance planning as agile methodologies recommend. Research this issue, on the Web and in the ACM DL, and report (fairly) on the major arguments of both sides, and on the evidence for both positions.

Introduction

About every ten years give or take five, the software community redefines “the problem” by shifting its focus from product issues to process issues. Thus, we have embraced structured programming languages (product) followed by structured analysis methods (process) followed by data encapsulation (product) followed by the current emphasis on the Software Engineering Institutes Software Development Capability Maturity Model (process) followed by object-oriented methods, followed by agile software development.

Discipline vs Agility

No doubt the ideal system, if it were attainable, would be a code at once so flexible and minute, as to supply in advance for every conceivable situation a just and fitting rule. But life is too complex to bring the attainment of this idea within the compass of human power.

Discipline is the foundation for any successful endeavor. Athletes train, musicians practice, craftsmen perfect techniques, and engineers apply processes. Without these basic skills there may be an occasional success using natural talent, but professional consistency and long term prospects are limited. The strength and comfort which come from discipline support the endeavor when things are difficult, when the body or mind is under the weather, or when something new or unexpected arises and a response is required. Discipline creates well-organized memories, history, and experience.

Agility is the counterpart of discipline. Where discipline ingrains and strengthens, agility releases and invents. It allows the athlete to make the unexpected play, musicians to improvise and ornament, craftsmen to evolve their style, and engineers to adjust to changing technology and needs. Agility applies memory and history to adjust to new environments, react and adapt, take advantage of unexpected opportunities, and update the experience base for the future.

Agile Software development

Agile software development in general is characterized by the following attributes: incremental, cooperative, straightforward, and adaptive. Incremental refers to small software releases, with rapid development cycles. Cooperative refers to a close customer and developer interaction. Straightforward implies that the method itself is easy to learn and to modify and that it is sufficiently documented. Adaptive refers to the ability to make and react to last moment changes.

Menifesto

Value - Individuals and interactions over processes and tools, Working software over comprehensive documentation, Customer collaboration over contract negotiation and Responding to change over following a plan.

Principles

• Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
• Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
• Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
• Business people and developers must work together daily throughout the project.
• Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
• The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
• Working software is the primary measure of progress.
• Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
• Continuous attention to technical excellence and good design enhances agility.
• Simplicity--the art of maximizing the amount of work not done--is essential.
• The best architectures, requirements, and designs emerge from self-organizing teams.
• At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

[1]

Comparison

Predictive methods

The waterfall model [2] is still in common use. The waterfall model is the most predictive of the methodologies, 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 etc.

Capability Maturity Model Integration (CMMI) [3] is a process improvement approach that provides organizations with the essential elements of effective processes. It can be used to guide process improvement across a project, a division, or an entire organization. CMMI helps integrate traditionally separate organizational functions, set process improvement goals and priorities, provide guidance for quality processes, and provide a point of reference for appraising current processes. Some of the benefits and business reasons for implementing process improvement are:

• The quality of a system is highly influenced by the quality of the process used to acquire, develop, and maintain it.
• Process improvement increases product and service quality as organizations apply it to achieve their business objectives.
• Process improvement objectives are aligned with business objectives.

RUP [4] - The software life-cycle is broken into cycles, each cycle working on a new generation of the product. The Rational Unified Process divides one development cycle in four consecutive phases Inception phase: establish the business case for the system and delimit the project scope. Elaboration phase: analyze the problem domain, establish a sound architectural foundation, develop the project plan, and eliminate the highest risk elements of the project. Construction phase: All the components and application features are developed and integrated into the product, and all features are thoroughly tested. Transition phase: transition the software product to the user community.

Benefits

The main benefits typically seen are:

• Improved predictability of project budgets and schedules
• Improved management awareness of problems
• Reduced re-work, which improves predictability, cost, and schedule
• Greater productivity & higher quality
• Increased customer satisfaction

Limitations

The problem may arise some times when the organizations are driven to achieve a maturity level only for its marketing value, process improvement goals are not set realistically, only some of the projects participate in the improvement effort & some of the projects get appraised, insufficient resources (e.g., training, QA, metrics, consultants), management doesn't enforce the process hence benefits are not realized.

The main problem of the waterfall model is the inflexible nature of the 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 radically in the course of the project. The problem with waterfall model is the dogmatic requirement of committing to one phase before proceeding to the next. Consequently, there was a strong shift to Iterative incremental development which later evolved into the more elaborate Rational Unified Process (RUP). This shift away from - big upfront design - relied on object-oriented (OO) analysis and design - has shifted the way in which software was modularized, changed.

Adaptive methods

Adaptive software development It encourages incremental and iterative development, with constant prototyping. It provides a framework with enough guidance to prevent projects from falling into chaos, but not too much, which could suppress emergence and creativity.

Agile Modeling [5] encourages developers to produce sufficiently advanced models to support acute design needs and documentation purposes. The aim is to keep the amount of models and documentation as low as possible. Cultural issues are addressed by depicting ways to encourage communication, and to organize team structures and ways of working.

The Crystal family [6] of methodologies includes selection of the most suitable method for given individual project. It includes the principles for tailoring these methods to fit the varying circumstances of different projects. Each member of the Crystal family is marked with a color indicating the 'heaviness' of the method. Crystal suggests choosing the appropriate-colored method for a project based on its size and criticality. Larger projects are likely to ask for more coordination and heavier methods than smaller ones.

DSDM -Dynamic systems development method [7]: The fundamental idea behind DSDM is that instead of fixing the amount of functionality in a product, and then adjusting time and resources to reach that fimctionality, it is preferred to fix time and resources, and then adjust the amount of functionality accordingly.

Extreme programming (XP) [8] is a collection of well-known software engineering practices. XP aims at enabling successful software development despite vague or constantly changing software requirements. The novelty of XP is based on the way the individual practices are collected and lined up to function with each other. Some of the main characteristics of XP are short iterations with small releases and rapid feedback, close customer participation, constant communication and coordination, continuous refactoring, continuous integration and testing, collective code ownership, and pair programming.

Feature-driven development [9] is a process-oriented software development method for developing business critical systems. The FDD approach focuses on the design and building phases. The FDD approach embodies iterative development with the practices believed to be effective in industry. It emphasizes quality aspects throughout the process and includes frequent and tangible deliveries, along with accurate monitoring of the progress of the project.

Pragmatic programming [] introduces a set of programming "best practices". The "method" itself is a collection of short tips that focus on day-to-day problems. These practices take a pragmatic perspective and place focus on incremental, iterative development, rigorous testing, and user-centered design.

Scrum [10] approach has been developed for managing the software development process in a volatile environment. It is an empirical approach based on flexibility, adaptability and productivity. Scrum leaves open for the developers to choose the specific software development techniques,methods, and practices for the implementation process. It involves frequent management activities aiming at consistently identifying any deficiencies or impediments in the development process as well as the in the practices that are used.

Criteria for evaluating these methods can be summarized as:

• Which stages of the software development life-cycle does the method cover
• Does the method support project management activities
• Does the method mainly rely on abstract principles or does it provide concrete guidance
• Is the method argued to fit per se in all agile development situations
• Does the method have empirical support for its claims

Benefits

Two of the most significant characteristics of the agile approaches are:

• They can handle unstable requirements throughout the development life cycle
• They deliver products in shorter time frames and under budget constraints when compared with traditional development methods.

Limitations

Agile criticisms include - lack of structure and necessary documentation, only works with senior-level developers, incorporates insufficient software design, requires too much cultural change to adopt, can lead to more difficult contractual negotiations. Agile methods did not provide true support for project management, and abstract principles appeared to dominate the current method literature and developers' minds. While universal solutions have a strong support in the respective literature, empirical evidence is currently very limited. The emerging new agile methods need to clarify their range of applicability and explain the interfaces to the software development life-cycle phases. The emphasis should be placed on method specialization than generalization.

Conclusion

Agile development methodologies (such as XP, Scrum, and ASD) promise higher customer satisfaction, lower defect rates, faster development times and a solution to rapidly changing requirements. Plan-driven approaches (such as Clean room, PSP, or CMM-based methods) promise predictability, stability, and high assurance. However, both approaches have situation dependent shortcomings that, if left unaddressed, can lead to project failure.

Agile methods are compatible with formal process improvement frameworks. Rather than casting discipline and documentation to the wind, agile methods, when seriously applied, are actually very focused and comprehensive. Likewise, a framework such as the SEI Capability Maturity Model Integration (CMMI) need not be an overwhelming excess of paperwork and bureaucracy; when appropriately implemented, the CMMI encourages and enables significant and sustainable improvements.

If one has strong discipline without agility, the result is inflexible hierarchy and stagnation. Agility without discipline leads to the heady, unencumbered enthusiasm of a start-up company before it has to turn a profit. Great companies, and great software projects, have both in measures appropriate to their goals and environment.

References

Integrating agile software development and software process improvement: a longitudinal case study
Salo, O.; Abrahamsson, P.;
Empirical Software Engineering, 2005. 2005 International Symposium on
17-18 Nov. 2005 Page(s):10 pp. 
Digital Object Identifier 10.1109/ISESE.2005.1541828

Balancing agility and discipline: evaluating and integrating agile and plan-driven methods
Boehm, B.; Turner, R.;
Software Engineering, 2004. ICSE 2004. Proceedings. 26th International Conference on
23-28 May 2004 Page(s):718 - 719 

Formalizing agility: an agile organization's journey toward CMMI accreditation
Baker, S.W.;
Agile Conference, 2005. Proceedings
24-29 July 2005 Page(s):185 - 192 
Digital Object Identifier 10.1109/ADC.2005.27

Formalizing agility, part 2: how an agile organization embraced the CMMI
Baker, S.W.;
Agile Conference, 2006
23-28 July 2006 Page(s):8 pp. 
Digital Object Identifier 10.1109/AGILE.2006.30

Toward maturity model for extreme programming
Nawrocki, J.; Walter, B.; Wojciechowski, A.;
Euromicro Conference, 2001. Proceedings. 27th
4-6 Sept. 2001 Page(s):233 - 239 
Digital Object Identifier 10.1109/EURMIC.2001.952459

Software quality and agile methods
Ming Huo; Verner, J.; Liming Zhu; Babar, M.A.;
Computer Software and Applications Conference, 2004. COMPSAC 2004. Proceedings of the 28th Annual International
2004 Page(s):520 - 525 vol.1 
Digital Object Identifier 10.1109/CMPSAC.2004.1342889

External links

1. http://agilemanifesto.org/
2. http://en.wikipedia.org/wiki/Waterfall_model
3. http://www.sei.cmu.edu/cmmi/
4. http://www.ibm.com/developerworks/rational/library/content/03July/1000/1251/1251_bestpractices_TP026B.pdf
5. http://www.agilemodeling.com/
6. http://martinfowler.com/articles/newMethodology.html#Crystal
7. http://www.dsdm.org/
8. http://en.wikipedia.org/wiki/Feature_Driven_Development
9. http://en.wikipedia.org/wiki/Scrum_(development)
10. http://www.sei.cmu.edu/pub/documents/06.reports/pdf/06tr008.pdf
11. http://www.sei.cmu.edu/cmmi/adoption/concepts.html
12. http://stsc.hill.af.mil/crosstalk/2004/06/0406Heinz.html