Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T21:12:19Z

Sbpatel: /* External links */

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.

__TOC__

= 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.
[http://agilemanifesto.org/]

= Comparison =

[[Image:CmmiAgile.png]]

== Predictive methods ==

The waterfall model [http://en.wikipedia.org/wiki/Waterfall_model] 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) [http://www.sei.cmu.edu/cmmi/] 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 [http://www.ibm.com/developerworks/rational/library/content/03July/1000/1251/1251_bestpractices_TP026B.pdf] - 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 [http://www.agilemodeling.com/] 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 [http://martinfowler.com/articles/newMethodology.html#Crystal] 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 [http://www.dsdm.org/]: 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) [http://www.extremeprogramming.org/] 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 [http://en.wikipedia.org/wiki/Feature_Driven_Development] 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 [http://en.wikipedia.org/wiki/Scrum_(development)] 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

= Further reading =

= External links =
# http://agilemanifesto.org/
# http://en.wikipedia.org/wiki/Waterfall_model
# http://www.sei.cmu.edu/cmmi/
# http://www.ibm.com/developerworks/rational/library/content/03July/1000/1251/1251_bestpractices_TP026B.pdf
# http://www.agilemodeling.com/
# http://martinfowler.com/articles/newMethodology.html#Crystal
# http://www.dsdm.org/
# http://en.wikipedia.org/wiki/Feature_Driven_Development
# http://en.wikipedia.org/wiki/Scrum_(development)
# http://www.sei.cmu.edu/pub/documents/06.reports/pdf/06tr008.pdf
# http://www.sei.cmu.edu/cmmi/adoption/concepts.html
# http://stsc.hill.af.mil/crosstalk/2004/06/0406Heinz.html

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T21:11:48Z

Sbpatel:

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.

__TOC__

= 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.
[http://agilemanifesto.org/]

= Comparison =

[[Image:CmmiAgile.png]]

== Predictive methods ==

The waterfall model [http://en.wikipedia.org/wiki/Waterfall_model] 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) [http://www.sei.cmu.edu/cmmi/] 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 [http://www.ibm.com/developerworks/rational/library/content/03July/1000/1251/1251_bestpractices_TP026B.pdf] - 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 [http://www.agilemodeling.com/] 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 [http://martinfowler.com/articles/newMethodology.html#Crystal] 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 [http://www.dsdm.org/]: 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) [http://www.extremeprogramming.org/] 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 [http://en.wikipedia.org/wiki/Feature_Driven_Development] 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 [http://en.wikipedia.org/wiki/Scrum_(development)] 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

= Further reading =

= External links =
# http://agilemanifesto.org/
# http://en.wikipedia.org/wiki/Waterfall_model
# http://www.sei.cmu.edu/cmmi/
# http://www.ibm.com/developerworks/rational/library/content/03July/1000/1251/1251_bestpractices_TP026B.pdf
# http://www.agilemodeling.com/
# http://martinfowler.com/articles/newMethodology.html#Crystal
# http://www.dsdm.org/
# http://en.wikipedia.org/wiki/Feature_Driven_Development
# http://en.wikipedia.org/wiki/Scrum_(development)

# http://www.sei.cmu.edu/pub/documents/06.reports/pdf/06tr008.pdf
# http://www.sei.cmu.edu/cmmi/adoption/concepts.html
# http://stsc.hill.af.mil/crosstalk/2004/06/0406Heinz.html

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T20:54:19Z

Sbpatel: /* External links */

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.

__TOC__

= 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.

= Comparison =

[[Image:CmmiAgile.png]]

== Predictive methods ==

The waterfall model 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) 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 - 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 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 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: 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) 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 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 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

= Further reading =

= External links =

# http://www.sei.cmu.edu/pub/documents/06.reports/pdf/06tr008.pdf
# http://www.sei.cmu.edu/cmmi/adoption/concepts.html
# http://stsc.hill.af.mil/crosstalk/2004/06/0406Heinz.html

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T20:53:27Z

Sbpatel: /* References */

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.

__TOC__

= 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.

= Comparison =

[[Image:CmmiAgile.png]]

== Predictive methods ==

The waterfall model 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) 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 - 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 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 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: 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) 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 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 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

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T20:52:05Z

Sbpatel: /* References */

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.

__TOC__

= 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.

= Comparison =

[[Image:CmmiAgile.png]]

== Predictive methods ==

The waterfall model 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) 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 - 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 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 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: 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) 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 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 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

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T20:51:10Z

Sbpatel: /* References */

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.

__TOC__

= 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.

= Comparison =

[[Image:CmmiAgile.png]]

== Predictive methods ==

The waterfall model 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) 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 - 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 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 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: 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) 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 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 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

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T20:46:30Z

Sbpatel: /* Comparison */

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.

__TOC__

= 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.

= Comparison =

[[Image:CmmiAgile.png]]

== Predictive methods ==

The waterfall model 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) 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 - 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 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 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: 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) 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 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 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 =

= Further reading =

= External links =

File:CmmiAgile.png

2007-11-19T20:45:39Z

Sbpatel:

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T20:41:53Z

Sbpatel: /* Benefits */

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.

__TOC__

= 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.

= Comparison =

== Predictive methods ==

The waterfall model 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) 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 - 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.

[[Image:Waterfall.png]]

=== 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 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 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: 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) 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 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 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

[[Image:Agile.png]]

=== 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 =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T20:41:29Z

Sbpatel: /* Predictive methods */

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.

__TOC__

= 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.

= Comparison =

== Predictive methods ==

The waterfall model 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) 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 - 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.

[[Image:Waterfall.png]]

=== 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 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 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: 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) 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 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 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 =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T20:40:17Z

Sbpatel: /* Predictive methods */

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.

__TOC__

= 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.

= Comparison =

== Predictive methods ==

The waterfall model 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) 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 - 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.

[[image/Waterfall.png]]

=== 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 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 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: 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) 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 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 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 =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T20:39:42Z

Sbpatel: /* Predictive methods */

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.

__TOC__

= 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.

= Comparison =

== Predictive methods ==

The waterfall model 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) 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 - 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.

[[Waterfall.png]]

=== 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 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 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: 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) 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 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 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 =

= Further reading =

= External links =

File:Waterfall.png

2007-11-19T20:38:40Z

Sbpatel:

File:Agile.png

2007-11-19T20:38:06Z

Sbpatel:

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:44:41Z

Sbpatel: /* Benefits */

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.

__TOC__

= 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.

= Comparison =

== Predictive methods ==

The waterfall model 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) 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 - 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 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 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: 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) 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 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 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 =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:36:03Z

Sbpatel: /* Conclusion */

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.

__TOC__

= 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.

= Comparison =

== Predictive methods ==

The waterfall model 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) 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 - 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 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 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: 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) 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 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 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 ===

=== 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 =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:32:43Z

Sbpatel: /* Adaptive methods */

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.

__TOC__

= 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.

= Comparison =

== Predictive methods ==

The waterfall model 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) 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 - 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 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 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: 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) 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 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 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 ===

=== 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:32:04Z

Sbpatel: /* Comparison */

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.

__TOC__

= 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.

= Comparison =

== Predictive methods ==

The waterfall model 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) 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 - 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 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 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: 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) 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 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 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. Serum 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 ===

=== 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:30:05Z

Sbpatel: /* Comparison */

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.

__TOC__

= 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.

= Comparison =

== Predictive methods ==

The waterfall model 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) 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 - 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 ===

On the other hand, 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.

== 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 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 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: 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) 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 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 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. Serum 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 ===

=== 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.

= 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:26:15Z

Sbpatel: /* Benefits */

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.

__TOC__

= 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.

= Comparison =

== 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 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 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: 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) 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 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 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. Serum 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 evaluation ===

* 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 ===

=== 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.

== Predictive methods ==

The waterfall model 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) 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 - 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 ===

On the other hand, 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:25:59Z

Sbpatel: /* Benefits */

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.

__TOC__

= 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.

= Comparison =

== 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 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 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: 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) 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 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 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. Serum 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 evaluation ===

* 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 ===

=== 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.

== Predictive methods ==

The waterfall model 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) 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 - 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 ===

=== Limitations ===

On the other hand, 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:25:32Z

Sbpatel: /* References */

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.

__TOC__

= 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.

= Comparison =

== 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 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 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: 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) 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 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 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. Serum 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 evaluation ===

* 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 ===

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.

== Predictive methods ==

The waterfall model 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) 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 - 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 ===

=== Limitations ===

On the other hand, 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:25:09Z

Sbpatel: /* Limitations */

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.

__TOC__

= 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.

= Comparison =

== 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 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 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: 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) 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 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 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. Serum 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 evaluation ===

* 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 ===

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.

== Predictive methods ==

The waterfall model 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) 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 - 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 ===

=== Limitations ===

On the other hand, 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:23:10Z

Sbpatel: /* Limitations */

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.

__TOC__

= 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.

= Comparison =

== 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 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 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: 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) 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 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 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. Serum 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 evaluation ===

* 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 ===

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.

== Predictive methods ==

The waterfall model 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) 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 - 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.

=== Limitations ===

On the other hand, 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:22:50Z

Sbpatel: /* Comparison */

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.

__TOC__

= 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.

= Comparison =

== 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 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 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: 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) 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 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 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. Serum 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 evaluation ===

* 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 ===

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.

== Predictive methods ==

The waterfall model 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) 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 - 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.

=== Limitations ===

On the other hand, 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T19:22:17Z

Sbpatel: /* Criteria for evaluation */

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.

__TOC__

= 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.

= Comparison =

== 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 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 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: 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) 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 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 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. Serum 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 evaluation ===

* 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 ===

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.

== Predictive methods ==

The waterfall model 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) 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 - 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.

== Comparison ==

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.

On the other hand, 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T16:17:27Z

Sbpatel: /* Comparison */

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.

__TOC__

= 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.

= Comparison =

== 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 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 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: 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) 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 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 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. Serum 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 evaluation ===

* 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

== Predictive methods ==

The waterfall model 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) 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 - 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.

== Comparison ==

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.

On the other hand, 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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T16:10:15Z

Sbpatel: /* Predictive methods */

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.

__TOC__

= 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.

= Comparison =

== 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 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 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: 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) 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 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 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. Serum 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 evaluation ===

* 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

=== Criticisms ===

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.

== Predictive methods ==

The waterfall model 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) 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 - 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.

=== Criticism ===
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.

= References =

= Further reading =

= External links =

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T15:51:32Z

Sbpatel: /* Predictive methods */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T15:48:29Z

Sbpatel: /* Discipline vs Agility */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T15:48:10Z

Sbpatel: /* Discipline vs Agility */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T15:47:41Z

Sbpatel: /* Introduction */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T15:43:17Z

Sbpatel: /* Introduction */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T03:48:40Z

Sbpatel: /* Predictive methods */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T03:45:56Z

Sbpatel: /* Predictive methods */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T03:42:38Z

Sbpatel: /* Predictive methods */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T03:33:04Z

Sbpatel: /* Menifesto */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T03:32:15Z

Sbpatel: /* Adaptive methods */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T03:25:57Z

Sbpatel: /* Predictive methods */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T01:24:42Z

Sbpatel: /* Adaptive methods */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T00:49:25Z

Sbpatel: /* XP */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T00:40:14Z

Sbpatel: /* References */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T00:38:31Z

Sbpatel: /* Menifesto */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-19T00:25:14Z

Sbpatel: /* Introduction */

CSC/ECE 517 Fall 2007/wiki3 10 10

2007-11-18T23:18:48Z

Sbpatel:

CSC/ECE 517 Fall 2007/wiki2 2 22

2007-10-22T03:11:49Z

Sbpatel: /* Enterprise Objects Framework (Apple) */

''Object-relational mapping. Ruby's ActiveRecord is one attempt to allow an object-oriented program to use a relational database. The Crossing Chasms pattern is another. Look up several approaches to mapping relational databases to o-o programs, include hyperlinks to all of them, and explain how they differ. Report on the strengths of various approaches (making sure to credit the authors for their insights).''

__TOC__

= Introduction =

== What is ORM? ==
Object Relational Mapping (ORM) is a technique used in software systems that use an object-oriented language in their application domain and a relational database to store persistent data from the objects they use. The mapping is required due to the differences in representation. The database uses tables and foreign keys for its representation of data and relationships where the application uses objects and references and/or pointers.
For some time proponents of Object-Oriented Database Management Systems (ODBMS) have argued that this is similar to breaking up a car to its pieces before storing it in the garage and putting it together again after taking it out. Whereas in an object database you store or retrieve the whole car at once.

A comprehensive list of ORM systems by language is available at [http://en.wikipedia.org/wiki/List_of_object-relational_mapping_software List of object-relational mapping software]

== How ORM works? ==
Typical ORM systems will map one row in a table in the database to an object in the application and vice versa. In static languages the mapping is done manually or it is automated with a preprocessor or with external mapping data (e.g. XML mapping files in Java Hibernate). In languages that support meta programming at runtime or compile time the mapping can be done automatically from information gathered from the database. ORM systems typically provide the programmer with object factories that map class method calls to SQL queries. They also provide methods to store the object data back in the database after updates in the application.

= ORM Implementations =

== Active Record ==

The Active Record pattern describes the most basic mapping of one object per table row, or as described by its author Martin Fowler: ''An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.'' [http://www.martinfowler.com/eaaCatalog/activeRecord.html]

The major features of the Rails Active Record implementation are:
* Automated mapping between classes and tables, attributes and columns.
* Associations between objects controlled by simple meta-programming macros.
* Aggregations of value objects controlled by simple meta-programming macros.
* Validation rules that can differ for new or existing objects.
* Acts that can make records work as lists or trees
* Callbacks as methods or queues on the entire life cycle (instantiation, saving, destroying, validating, etc).
* Observers for the entire life cycle
* Inheritance hierarchies
* Transaction support on both a database and object level.
* Reflections on columns, associations, and aggregations
* Direct manipulation (instead of service invocation like Java Hibernate)
* Database abstraction through simple adapters (~100 lines) with a shared connector
* Logging support for Log4r and Logger

One of the best examples of the implementation of the pattern is found in the Rails framework (http://ar.rubyonrails.com/).

== Crossing Chasms pattern ==

Crossing Chasms is a large pattern language that as a whole addresses the issues faced by teams trying to build large client-server systems using Object Technology and Relational data stores. The authors, Kyle Brown and Bruce Whitenack, originally presented the language at the Second Pattern Languages of Program Design [PLoPD] conference, the proceedings of the conference were published as the book [http://www.amazon.com/Pattern-Languages-Program-Software-Patterns/dp/0201895277 Pattern Languages of Program Design 2].

Currently there is little information available online. The best articles still available are:

* [http://www.ksc.com/article1.htm Crossing Chasms: The Architectural Patterns]
* [http://www.ksc.com/article2.htm A Pattern Language for Relational Databases and Smalltalk]
* [http://www.ksc.com/article5.htm Crossing Chasms: A Pattern Language for Object-RDBMS Integration "The Static Patterns"]
* [http://www.smallmemory.com/almanac/BrownEtc96b.html Crossing Chasms: A Pattern Language for Object-RDBMS Integration]
* [http://c2.com/cgi/wiki?CrossingChasms Crossing Chasms]

== Hibernate ==

Hibernate supports key OO features
* Hibernate supports natural OO idiom; inheritance, polymorphism, composition and the Java collections framework
* It supports fine-grained object models - a rich variety of mappings for collections and dependent objects
* There is no extra code generation or bytecode processing steps in build procedure
* Hibernate is extremely performant, has a dual-layer cache architecture, and may be used in a cluster
* Hibernate addresses both sides of the problem; not only how to get objects into the database, but also how to get them out again
* Hibernate supports both long-lived persistence contexts, detach/reattach of objects, and takes care of optimistic locking automatically
* Hibernate implements the Java Persistence management API and object/relational mapping options (EJB 3.0), two members of the Hibernate team are active in the expert group
[http://www.hibernate.org]

== Oracle TopLink ==

Oracle TopLink delivers complete Java Persistance platform by providing following main features:
* Access relational data using JPA and many advanced object-relational extensions
* Efficiently manipulate XML through a Java domain model using JAXB
* Interact with unstructured data through Service Data Objects (SDO)
* Expose relational datbases flexibly using Web Services
[http://www.oracle.com/technology/products/ias/toplink/index.html]

== JDO ==
The Java Data Objects (JDO) API is a standard interface-based Java model abstraction of persistence,
* Application programmers can focus on their domain object model and leave the details of persistence (field-by-field storage of objects) to the JDO implementation.
* Applications written with the JDO API can be run on multiple implementations without recompiling or changing source code. Metadata, which describes persistence behavior external to the Java source code including most commonly used features of O/R mapping, is highly portable.
* Applications written with the JDO API are independent of the underlying database. JDO implementations support many different kinds of transactional data stores, including relational and object databases, XML, flat files, and others.
* Application programmers delegate the details of persistence to the JDO implementation, which can optimize data access patterns for optimal performance.
* Applications can take advantage of EJB features such as remote message processing, automatic distributed transaction coordination, and security, using the same domain object models throughout the enterprise.
[http://java.sun.com/jdo]

== Java Persistence API ==

The Java Persistence API draws upon the best ideas from persistence technologies such as Hibernate, TopLink, and JDO. Customers now no longer face the choice between incompatible non-standard persistence models for object/relational mapping. The Java Persistence API contains a full object/relational mapping specification supporting the use of Java language metadata annotations and/or XML descriptors to define the mapping between Java objects and a relational database. It supports a rich, SQL-like query language (which is a significant extension upon EJB QL) for both static and dynamic queries. It also supports the use of pluggable persistence providers. The Java Persistence API is now the preferred persistence API for use with EJB 3.0 applications.
[http://java.sun.com/javaee/technologies/persistence.jsp]

== Apache ObJectRelationalBridge - OJB ==

* The PersistenceBroker kernel API and all top-level APIs (ODMG, OTM, JDO) allows Java Programmers to store and retrieve Java Objects in/from (any) JDBC-compliant RDBMS
* Transparent persistence: classes does not have to inherit from any OJB base class nor implement a special interface. OJB delivers pure transparent persistence for POJOs.
* Scalable architecture that allows to build massively distributed and clustered systems.
* Quality assurance taken seriously: More than 800 JUnit Test Cases for regression tests. JUnit tests are integrated into the build scripts and used as quality assurance for daily development.
* Support for Polymorphism and Extents. You can use Interface-types and abstract classes as attribute types in your persistent classes. Queries are also aware of extents: A query against a baseclass or interface will return matches from derived classes, even if they are mapped to different DB-tables
* Support for persistent object caching. Different caching strategies and distributed caches.
* OJB uses an XML based Object/Relational mapping. The mapping resides in a dynamic MetaData layer, which can be manipulated at runtime through a simple Meta-Object-Protocol (MOP) to change the behaviour of the persistence kernel.
* OJB provides several advanced O/R features like Object Caching, lazy materialization through virtual proxies and distributed lock-management with configurable Transaction-Isolation levels. Optimistic and pessimistic locking is supported.
* OJB provides a flexible configuration and plugin mechanism that allows to select from set of predefined components or to implement your own extensions and plugins.
[http://db.apache.org/ojb/]

== Enterprise Objects Framework (Apple) ==

Enterprise Objects Framework provides tools for defining an object model and mapping it to a data model. This allows to create objects that encapsulate both data and the methods for operating on that data, while taking advantage of the data access services provided by the Framework that make it possible for these objects to persist in a relational database.
The flexible, three-tier architecture provided by the Framework allows to build robust, scalable, client/server applications. Objects at each of the three tiers (user interface, enterprise objects, and data store) can be deployed to take advantage of network resources. For example, data might be stored in a relational database running on a fault-tolerant database server with gigabytes of disk storage, while enterprise objects run on high-end compute servers. Partitioning the application to make best use of available resources allows complex applications to achieve maximum performance.
The portions of the Framework can be used selectively to meet specific application requirements. For example, the components that provide users with the ability to interactively manipulate enterprise objects can be used by a non-database application to handle user interface refresh and undo. We can use a custom data store (such as a flat-file system) in place of a relational database to store data for enterprise objects. Or we can make use of the database adapters separate from the rest of the Framework components to provide direct access to relational databases for your applications.
[http://developer.apple.com/]

= Criteria for Selection =

There is no perfect single tool exists. Hence the most important thing when searching for the right tool is to define precisely which criteria are essential. Following is the summary of criteria which can be considered while selecting the ORM product:

== ORM specific criteria ==
=== Basic features: ===
* Be able to use inheritance, create hierarchies between entities, and use polymorphism (we are using objects!). The tools can support a variety of combinations for tables and classes to allow these mechanisms.
* Handle any type of relations (1-1, 1-n, n-n)
* Support for transactions
* Aggregates (equivalent to SQL's SUM, AVG, MIN, MAX, COUNT)
* Support for grouping (SQL's GROUP BY)
* Supported databases. A big advantage of mapping tools is that they provide an abstraction of the underlying database engine. Most of them allow switching easily between RDBMSs
=== Flexibility ===
* Customization of queries. HQL is a strong point of Hibernate/NHibernate. We could also wish a dynamic mapping to be possible from developer provided SQL queries.
* Support any type of SQL joins (inner join, outer join)
* Be able to map a single object to data coming from multiple tables (joins, views). And Be able to dispatch the data from a single table to multiple objects.
=== Performance ===
* Lazy loading - he loading of some data is deferred until it's needed. For the data through relations and for some columns.
* Cache dynamically generated queries and Cache some data to avoid too many calls to the data source.
* Handle cascade updates. Deleting a master record should delete the linked details if wished so.
=== Evolution: ===
* Maintainability - what happens if the database schema changes? If I need to add a new collection?
* Possibility to move to a new mapping tool
* Serialization. Serialization can be used to persist data outside of the database. Serialization can be done into a binary format, or more important, in XML (

== Non ORM specific criteria ==
* Price
* Performance
* Resource consumption (memory)
* Scalability
* Complexity (or simplicity...)
* Ease of use, time to be up and running
* Documentation quality, Support, forums, community
* Maturity, Frequency of the updates, bug fixes, evolutions
* Vendor's reputation and stability
* Support for multiple platforms

= References =

= Further reading =

= External links =

# http://ar.rubyonrails.com/
# http://www.ksc.com/article5.htm
# http://www.hibernate.org
# http://www.oracle.com/technology/products/ias/toplink/index.html
# http://java.sun.com/jdo
# http://java.sun.com/javaee/technologies/persistence.jsp
# http://db.apache.org/ojb/
# http://developer.apple.com/
# http://en.wikipedia.org/wiki/Object-relational_mapping
# http://c2.com/cgi-bin/wiki?ObjectRelationalToolComparison

CSC/ECE 517 Fall 2007/wiki2 2 22

2007-10-22T03:11:37Z

Sbpatel: /* References */

CSC/ECE 517 Fall 2007/wiki2 2 22

2007-10-22T03:10:26Z

Sbpatel: /* Active Record */

''Object-relational mapping. Ruby's ActiveRecord is one attempt to allow an object-oriented program to use a relational database. The Crossing Chasms pattern is another. Look up several approaches to mapping relational databases to o-o programs, include hyperlinks to all of them, and explain how they differ. Report on the strengths of various approaches (making sure to credit the authors for their insights).''

__TOC__

= Introduction =

== What is ORM? ==
Object Relational Mapping (ORM) is a technique used in software systems that use an object-oriented language in their application domain and a relational database to store persistent data from the objects they use. The mapping is required due to the differences in representation. The database uses tables and foreign keys for its representation of data and relationships where the application uses objects and references and/or pointers.
For some time proponents of Object-Oriented Database Management Systems (ODBMS) have argued that this is similar to breaking up a car to its pieces before storing it in the garage and putting it together again after taking it out. Whereas in an object database you store or retrieve the whole car at once.

A comprehensive list of ORM systems by language is available at [http://en.wikipedia.org/wiki/List_of_object-relational_mapping_software List of object-relational mapping software]

== How ORM works? ==
Typical ORM systems will map one row in a table in the database to an object in the application and vice versa. In static languages the mapping is done manually or it is automated with a preprocessor or with external mapping data (e.g. XML mapping files in Java Hibernate). In languages that support meta programming at runtime or compile time the mapping can be done automatically from information gathered from the database. ORM systems typically provide the programmer with object factories that map class method calls to SQL queries. They also provide methods to store the object data back in the database after updates in the application.

= ORM Implementations =

== Active Record ==

The Active Record pattern describes the most basic mapping of one object per table row, or as described by its author Martin Fowler: ''An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.'' [http://www.martinfowler.com/eaaCatalog/activeRecord.html]

The major features of the Rails Active Record implementation are:
* Automated mapping between classes and tables, attributes and columns.
* Associations between objects controlled by simple meta-programming macros.
* Aggregations of value objects controlled by simple meta-programming macros.
* Validation rules that can differ for new or existing objects.
* Acts that can make records work as lists or trees
* Callbacks as methods or queues on the entire life cycle (instantiation, saving, destroying, validating, etc).
* Observers for the entire life cycle
* Inheritance hierarchies
* Transaction support on both a database and object level.
* Reflections on columns, associations, and aggregations
* Direct manipulation (instead of service invocation like Java Hibernate)
* Database abstraction through simple adapters (~100 lines) with a shared connector
* Logging support for Log4r and Logger

One of the best examples of the implementation of the pattern is found in the Rails framework (http://ar.rubyonrails.com/).

== Crossing Chasms pattern ==

Crossing Chasms is a large pattern language that as a whole addresses the issues faced by teams trying to build large client-server systems using Object Technology and Relational data stores. The authors, Kyle Brown and Bruce Whitenack, originally presented the language at the Second Pattern Languages of Program Design [PLoPD] conference, the proceedings of the conference were published as the book [http://www.amazon.com/Pattern-Languages-Program-Software-Patterns/dp/0201895277 Pattern Languages of Program Design 2].

Currently there is little information available online. The best articles still available are:

* [http://www.ksc.com/article1.htm Crossing Chasms: The Architectural Patterns]
* [http://www.ksc.com/article2.htm A Pattern Language for Relational Databases and Smalltalk]
* [http://www.ksc.com/article5.htm Crossing Chasms: A Pattern Language for Object-RDBMS Integration "The Static Patterns"]
* [http://www.smallmemory.com/almanac/BrownEtc96b.html Crossing Chasms: A Pattern Language for Object-RDBMS Integration]
* [http://c2.com/cgi/wiki?CrossingChasms Crossing Chasms]

== Hibernate ==

Hibernate supports key OO features
* Hibernate supports natural OO idiom; inheritance, polymorphism, composition and the Java collections framework
* It supports fine-grained object models - a rich variety of mappings for collections and dependent objects
* There is no extra code generation or bytecode processing steps in build procedure
* Hibernate is extremely performant, has a dual-layer cache architecture, and may be used in a cluster
* Hibernate addresses both sides of the problem; not only how to get objects into the database, but also how to get them out again
* Hibernate supports both long-lived persistence contexts, detach/reattach of objects, and takes care of optimistic locking automatically
* Hibernate implements the Java Persistence management API and object/relational mapping options (EJB 3.0), two members of the Hibernate team are active in the expert group
[http://www.hibernate.org]

== Oracle TopLink ==

Oracle TopLink delivers complete Java Persistance platform by providing following main features:
* Access relational data using JPA and many advanced object-relational extensions
* Efficiently manipulate XML through a Java domain model using JAXB
* Interact with unstructured data through Service Data Objects (SDO)
* Expose relational datbases flexibly using Web Services
[http://www.oracle.com/technology/products/ias/toplink/index.html]

== JDO ==
The Java Data Objects (JDO) API is a standard interface-based Java model abstraction of persistence,
* Application programmers can focus on their domain object model and leave the details of persistence (field-by-field storage of objects) to the JDO implementation.
* Applications written with the JDO API can be run on multiple implementations without recompiling or changing source code. Metadata, which describes persistence behavior external to the Java source code including most commonly used features of O/R mapping, is highly portable.
* Applications written with the JDO API are independent of the underlying database. JDO implementations support many different kinds of transactional data stores, including relational and object databases, XML, flat files, and others.
* Application programmers delegate the details of persistence to the JDO implementation, which can optimize data access patterns for optimal performance.
* Applications can take advantage of EJB features such as remote message processing, automatic distributed transaction coordination, and security, using the same domain object models throughout the enterprise.
[http://java.sun.com/jdo]

== Java Persistence API ==

The Java Persistence API draws upon the best ideas from persistence technologies such as Hibernate, TopLink, and JDO. Customers now no longer face the choice between incompatible non-standard persistence models for object/relational mapping. The Java Persistence API contains a full object/relational mapping specification supporting the use of Java language metadata annotations and/or XML descriptors to define the mapping between Java objects and a relational database. It supports a rich, SQL-like query language (which is a significant extension upon EJB QL) for both static and dynamic queries. It also supports the use of pluggable persistence providers. The Java Persistence API is now the preferred persistence API for use with EJB 3.0 applications.
[http://java.sun.com/javaee/technologies/persistence.jsp]

== Apache ObJectRelationalBridge - OJB ==

* The PersistenceBroker kernel API and all top-level APIs (ODMG, OTM, JDO) allows Java Programmers to store and retrieve Java Objects in/from (any) JDBC-compliant RDBMS
* Transparent persistence: classes does not have to inherit from any OJB base class nor implement a special interface. OJB delivers pure transparent persistence for POJOs.
* Scalable architecture that allows to build massively distributed and clustered systems.
* Quality assurance taken seriously: More than 800 JUnit Test Cases for regression tests. JUnit tests are integrated into the build scripts and used as quality assurance for daily development.
* Support for Polymorphism and Extents. You can use Interface-types and abstract classes as attribute types in your persistent classes. Queries are also aware of extents: A query against a baseclass or interface will return matches from derived classes, even if they are mapped to different DB-tables
* Support for persistent object caching. Different caching strategies and distributed caches.
* OJB uses an XML based Object/Relational mapping. The mapping resides in a dynamic MetaData layer, which can be manipulated at runtime through a simple Meta-Object-Protocol (MOP) to change the behaviour of the persistence kernel.
* OJB provides several advanced O/R features like Object Caching, lazy materialization through virtual proxies and distributed lock-management with configurable Transaction-Isolation levels. Optimistic and pessimistic locking is supported.
* OJB provides a flexible configuration and plugin mechanism that allows to select from set of predefined components or to implement your own extensions and plugins.
[http://db.apache.org/ojb/]

== Enterprise Objects Framework (Apple) ==

Enterprise Objects Framework provides tools for defining an object model and mapping it to a data model. This allows to create objects that encapsulate both data and the methods for operating on that data, while taking advantage of the data access services provided by the Framework that make it possible for these objects to persist in a relational database.
The flexible, three-tier architecture provided by the Framework allows to build robust, scalable, client/server applications. Objects at each of the three tiers (user interface, enterprise objects, and data store) can be deployed to take advantage of network resources. For example, data might be stored in a relational database running on a fault-tolerant database server with gigabytes of disk storage, while enterprise objects run on high-end compute servers. Partitioning the application to make best use of available resources allows complex applications to achieve maximum performance.
The portions of the Framework can be used selectively to meet specific application requirements. For example, the components that provide users with the ability to interactively manipulate enterprise objects can be used by a non-database application to handle user interface refresh and undo. We can use a custom data store (such as a flat-file system) in place of a relational database to store data for enterprise objects. Or we can make use of the database adapters separate from the rest of the Framework components to provide direct access to relational databases for your applications.
[http://developer.apple.com/]

= References =

= Further reading =

= External links =

# http://ar.rubyonrails.com/
# http://www.ksc.com/article5.htm
# http://www.hibernate.org
# http://www.oracle.com/technology/products/ias/toplink/index.html
# http://java.sun.com/jdo
# http://java.sun.com/javaee/technologies/persistence.jsp
# http://db.apache.org/ojb/
# http://developer.apple.com/
# http://en.wikipedia.org/wiki/Object-relational_mapping
# http://c2.com/cgi-bin/wiki?ObjectRelationalToolComparison

CSC/ECE 517 Fall 2007/wiki2 2 22

2007-10-22T03:08:55Z

Sbpatel: /* Criteria for Selection */

''Object-relational mapping. Ruby's ActiveRecord is one attempt to allow an object-oriented program to use a relational database. The Crossing Chasms pattern is another. Look up several approaches to mapping relational databases to o-o programs, include hyperlinks to all of them, and explain how they differ. Report on the strengths of various approaches (making sure to credit the authors for their insights).''

__TOC__

= Introduction =

== What is ORM? ==
Object Relational Mapping (ORM) is a technique used in software systems that use an object-oriented language in their application domain and a relational database to store persistent data from the objects they use. The mapping is required due to the differences in representation. The database uses tables and foreign keys for its representation of data and relationships where the application uses objects and references and/or pointers.
For some time proponents of Object-Oriented Database Management Systems (ODBMS) have argued that this is similar to breaking up a car to its pieces before storing it in the garage and putting it together again after taking it out. Whereas in an object database you store or retrieve the whole car at once.

A comprehensive list of ORM systems by language is available at [http://en.wikipedia.org/wiki/List_of_object-relational_mapping_software List of object-relational mapping software]

== How ORM works? ==
Typical ORM systems will map one row in a table in the database to an object in the application and vice versa. In static languages the mapping is done manually or it is automated with a preprocessor or with external mapping data (e.g. XML mapping files in Java Hibernate). In languages that support meta programming at runtime or compile time the mapping can be done automatically from information gathered from the database. ORM systems typically provide the programmer with object factories that map class method calls to SQL queries. They also provide methods to store the object data back in the database after updates in the application.

= ORM Implementations =

== Active Record ==

The Active Record pattern describes the most basic mapping of one object per table row, or as described by its author Martin Fowler:

''An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.'' [http://www.martinfowler.com/eaaCatalog/activeRecord.html]

One of the best examples of the implementation of the pattern is found in the Rails framework (http://ar.rubyonrails.com/).

The major features of the Rails Active Record implementation are:

* Automated mapping between classes and tables, attributes and columns.
* Associations between objects controlled by simple meta-programming macros.
* Aggregations of value objects controlled by simple meta-programming macros.
* Validation rules that can differ for new or existing objects.
* Acts that can make records work as lists or trees
* Callbacks as methods or queues on the entire life cycle (instantiation, saving, destroying, validating, etc).
* Observers for the entire life cycle
* Inheritance hierarchies
* Transaction support on both a database and object level.
* Reflections on columns, associations, and aggregations
* Direct manipulation (instead of service invocation like Java Hibernate)
* Database abstraction through simple adapters (~100 lines) with a shared connector
* Logging support for Log4r and Logger

== Crossing Chasms pattern ==

Crossing Chasms is a large pattern language that as a whole addresses the issues faced by teams trying to build large client-server systems using Object Technology and Relational data stores. The authors, Kyle Brown and Bruce Whitenack, originally presented the language at the Second Pattern Languages of Program Design [PLoPD] conference, the proceedings of the conference were published as the book [http://www.amazon.com/Pattern-Languages-Program-Software-Patterns/dp/0201895277 Pattern Languages of Program Design 2].

Currently there is little information available online. The best articles still available are:

* [http://www.ksc.com/article1.htm Crossing Chasms: The Architectural Patterns]
* [http://www.ksc.com/article2.htm A Pattern Language for Relational Databases and Smalltalk]
* [http://www.ksc.com/article5.htm Crossing Chasms: A Pattern Language for Object-RDBMS Integration "The Static Patterns"]
* [http://www.smallmemory.com/almanac/BrownEtc96b.html Crossing Chasms: A Pattern Language for Object-RDBMS Integration]
* [http://c2.com/cgi/wiki?CrossingChasms Crossing Chasms]

== Hibernate ==

Hibernate supports key OO features
* Hibernate supports natural OO idiom; inheritance, polymorphism, composition and the Java collections framework
* It supports fine-grained object models - a rich variety of mappings for collections and dependent objects
* There is no extra code generation or bytecode processing steps in build procedure
* Hibernate is extremely performant, has a dual-layer cache architecture, and may be used in a cluster
* Hibernate addresses both sides of the problem; not only how to get objects into the database, but also how to get them out again
* Hibernate supports both long-lived persistence contexts, detach/reattach of objects, and takes care of optimistic locking automatically
* Hibernate implements the Java Persistence management API and object/relational mapping options (EJB 3.0), two members of the Hibernate team are active in the expert group
[http://www.hibernate.org]

== Oracle TopLink ==

Oracle TopLink delivers complete Java Persistance platform by providing following main features:
* Access relational data using JPA and many advanced object-relational extensions
* Efficiently manipulate XML through a Java domain model using JAXB
* Interact with unstructured data through Service Data Objects (SDO)
* Expose relational datbases flexibly using Web Services
[http://www.oracle.com/technology/products/ias/toplink/index.html]

== JDO ==
The Java Data Objects (JDO) API is a standard interface-based Java model abstraction of persistence,
* Application programmers can focus on their domain object model and leave the details of persistence (field-by-field storage of objects) to the JDO implementation.
* Applications written with the JDO API can be run on multiple implementations without recompiling or changing source code. Metadata, which describes persistence behavior external to the Java source code including most commonly used features of O/R mapping, is highly portable.
* Applications written with the JDO API are independent of the underlying database. JDO implementations support many different kinds of transactional data stores, including relational and object databases, XML, flat files, and others.
* Application programmers delegate the details of persistence to the JDO implementation, which can optimize data access patterns for optimal performance.
* Applications can take advantage of EJB features such as remote message processing, automatic distributed transaction coordination, and security, using the same domain object models throughout the enterprise.
[http://java.sun.com/jdo]

== Java Persistence API ==

The Java Persistence API draws upon the best ideas from persistence technologies such as Hibernate, TopLink, and JDO. Customers now no longer face the choice between incompatible non-standard persistence models for object/relational mapping. The Java Persistence API contains a full object/relational mapping specification supporting the use of Java language metadata annotations and/or XML descriptors to define the mapping between Java objects and a relational database. It supports a rich, SQL-like query language (which is a significant extension upon EJB QL) for both static and dynamic queries. It also supports the use of pluggable persistence providers. The Java Persistence API is now the preferred persistence API for use with EJB 3.0 applications.
[http://java.sun.com/javaee/technologies/persistence.jsp]

== Apache ObJectRelationalBridge - OJB ==

* The PersistenceBroker kernel API and all top-level APIs (ODMG, OTM, JDO) allows Java Programmers to store and retrieve Java Objects in/from (any) JDBC-compliant RDBMS
* Transparent persistence: classes does not have to inherit from any OJB base class nor implement a special interface. OJB delivers pure transparent persistence for POJOs.
* Scalable architecture that allows to build massively distributed and clustered systems.
* Quality assurance taken seriously: More than 800 JUnit Test Cases for regression tests. JUnit tests are integrated into the build scripts and used as quality assurance for daily development.
* Support for Polymorphism and Extents. You can use Interface-types and abstract classes as attribute types in your persistent classes. Queries are also aware of extents: A query against a baseclass or interface will return matches from derived classes, even if they are mapped to different DB-tables
* Support for persistent object caching. Different caching strategies and distributed caches.
* OJB uses an XML based Object/Relational mapping. The mapping resides in a dynamic MetaData layer, which can be manipulated at runtime through a simple Meta-Object-Protocol (MOP) to change the behaviour of the persistence kernel.
* OJB provides several advanced O/R features like Object Caching, lazy materialization through virtual proxies and distributed lock-management with configurable Transaction-Isolation levels. Optimistic and pessimistic locking is supported.
* OJB provides a flexible configuration and plugin mechanism that allows to select from set of predefined components or to implement your own extensions and plugins.
[http://db.apache.org/ojb/]

== Enterprise Objects Framework (Apple) ==

Enterprise Objects Framework provides tools for defining an object model and mapping it to a data model. This allows to create objects that encapsulate both data and the methods for operating on that data, while taking advantage of the data access services provided by the Framework that make it possible for these objects to persist in a relational database.
The flexible, three-tier architecture provided by the Framework allows to build robust, scalable, client/server applications. Objects at each of the three tiers (user interface, enterprise objects, and data store) can be deployed to take advantage of network resources. For example, data might be stored in a relational database running on a fault-tolerant database server with gigabytes of disk storage, while enterprise objects run on high-end compute servers. Partitioning the application to make best use of available resources allows complex applications to achieve maximum performance.
The portions of the Framework can be used selectively to meet specific application requirements. For example, the components that provide users with the ability to interactively manipulate enterprise objects can be used by a non-database application to handle user interface refresh and undo. We can use a custom data store (such as a flat-file system) in place of a relational database to store data for enterprise objects. Or we can make use of the database adapters separate from the rest of the Framework components to provide direct access to relational databases for your applications.
[http://developer.apple.com/]

= References =

= Further reading =

= External links =

# http://ar.rubyonrails.com/
# http://www.ksc.com/article5.htm
# http://www.hibernate.org
# http://www.oracle.com/technology/products/ias/toplink/index.html
# http://java.sun.com/jdo
# http://java.sun.com/javaee/technologies/persistence.jsp
# http://db.apache.org/ojb/
# http://developer.apple.com/
# http://en.wikipedia.org/wiki/Object-relational_mapping
# http://c2.com/cgi-bin/wiki?ObjectRelationalToolComparison

CSC/ECE 517 Fall 2007/wiki2 2 22

2007-10-22T03:03:48Z

Sbpatel:

''Object-relational mapping. Ruby's ActiveRecord is one attempt to allow an object-oriented program to use a relational database. The Crossing Chasms pattern is another. Look up several approaches to mapping relational databases to o-o programs, include hyperlinks to all of them, and explain how they differ. Report on the strengths of various approaches (making sure to credit the authors for their insights).''

__TOC__

= Introduction =

== What is ORM? ==
Object Relational Mapping (ORM) is a technique used in software systems that use an object-oriented language in their application domain and a relational database to store persistent data from the objects they use. The mapping is required due to the differences in representation. The database uses tables and foreign keys for its representation of data and relationships where the application uses objects and references and/or pointers.
For some time proponents of Object-Oriented Database Management Systems (ODBMS) have argued that this is similar to breaking up a car to its pieces before storing it in the garage and putting it together again after taking it out. Whereas in an object database you store or retrieve the whole car at once.

A comprehensive list of ORM systems by language is available at [http://en.wikipedia.org/wiki/List_of_object-relational_mapping_software List of object-relational mapping software]

== How ORM works? ==
Typical ORM systems will map one row in a table in the database to an object in the application and vice versa. In static languages the mapping is done manually or it is automated with a preprocessor or with external mapping data (e.g. XML mapping files in Java Hibernate). In languages that support meta programming at runtime or compile time the mapping can be done automatically from information gathered from the database. ORM systems typically provide the programmer with object factories that map class method calls to SQL queries. They also provide methods to store the object data back in the database after updates in the application.

= ORM Implementations =

== Active Record ==

The Active Record pattern describes the most basic mapping of one object per table row, or as described by its author Martin Fowler:

''An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.'' [http://www.martinfowler.com/eaaCatalog/activeRecord.html]

One of the best examples of the implementation of the pattern is found in the Rails framework (http://ar.rubyonrails.com/).

The major features of the Rails Active Record implementation are:

* Automated mapping between classes and tables, attributes and columns.
* Associations between objects controlled by simple meta-programming macros.
* Aggregations of value objects controlled by simple meta-programming macros.
* Validation rules that can differ for new or existing objects.
* Acts that can make records work as lists or trees
* Callbacks as methods or queues on the entire life cycle (instantiation, saving, destroying, validating, etc).
* Observers for the entire life cycle
* Inheritance hierarchies
* Transaction support on both a database and object level.
* Reflections on columns, associations, and aggregations
* Direct manipulation (instead of service invocation like Java Hibernate)
* Database abstraction through simple adapters (~100 lines) with a shared connector
* Logging support for Log4r and Logger

== Crossing Chasms pattern ==

Crossing Chasms is a large pattern language that as a whole addresses the issues faced by teams trying to build large client-server systems using Object Technology and Relational data stores. The authors, Kyle Brown and Bruce Whitenack, originally presented the language at the Second Pattern Languages of Program Design [PLoPD] conference, the proceedings of the conference were published as the book [http://www.amazon.com/Pattern-Languages-Program-Software-Patterns/dp/0201895277 Pattern Languages of Program Design 2].

Currently there is little information available online. The best articles still available are:

* [http://www.ksc.com/article1.htm Crossing Chasms: The Architectural Patterns]
* [http://www.ksc.com/article2.htm A Pattern Language for Relational Databases and Smalltalk]
* [http://www.ksc.com/article5.htm Crossing Chasms: A Pattern Language for Object-RDBMS Integration "The Static Patterns"]
* [http://www.smallmemory.com/almanac/BrownEtc96b.html Crossing Chasms: A Pattern Language for Object-RDBMS Integration]
* [http://c2.com/cgi/wiki?CrossingChasms Crossing Chasms]

== Hibernate ==

Hibernate supports key OO features
* Hibernate supports natural OO idiom; inheritance, polymorphism, composition and the Java collections framework
* It supports fine-grained object models - a rich variety of mappings for collections and dependent objects
* There is no extra code generation or bytecode processing steps in build procedure
* Hibernate is extremely performant, has a dual-layer cache architecture, and may be used in a cluster
* Hibernate addresses both sides of the problem; not only how to get objects into the database, but also how to get them out again
* Hibernate supports both long-lived persistence contexts, detach/reattach of objects, and takes care of optimistic locking automatically
* Hibernate implements the Java Persistence management API and object/relational mapping options (EJB 3.0), two members of the Hibernate team are active in the expert group
[http://www.hibernate.org]

== Oracle TopLink ==

Oracle TopLink delivers complete Java Persistance platform by providing following main features:
* Access relational data using JPA and many advanced object-relational extensions
* Efficiently manipulate XML through a Java domain model using JAXB
* Interact with unstructured data through Service Data Objects (SDO)
* Expose relational datbases flexibly using Web Services
[http://www.oracle.com/technology/products/ias/toplink/index.html]

== JDO ==
The Java Data Objects (JDO) API is a standard interface-based Java model abstraction of persistence,
* Application programmers can focus on their domain object model and leave the details of persistence (field-by-field storage of objects) to the JDO implementation.
* Applications written with the JDO API can be run on multiple implementations without recompiling or changing source code. Metadata, which describes persistence behavior external to the Java source code including most commonly used features of O/R mapping, is highly portable.
* Applications written with the JDO API are independent of the underlying database. JDO implementations support many different kinds of transactional data stores, including relational and object databases, XML, flat files, and others.
* Application programmers delegate the details of persistence to the JDO implementation, which can optimize data access patterns for optimal performance.
* Applications can take advantage of EJB features such as remote message processing, automatic distributed transaction coordination, and security, using the same domain object models throughout the enterprise.
[http://java.sun.com/jdo]

== Java Persistence API ==

The Java Persistence API draws upon the best ideas from persistence technologies such as Hibernate, TopLink, and JDO. Customers now no longer face the choice between incompatible non-standard persistence models for object/relational mapping. The Java Persistence API contains a full object/relational mapping specification supporting the use of Java language metadata annotations and/or XML descriptors to define the mapping between Java objects and a relational database. It supports a rich, SQL-like query language (which is a significant extension upon EJB QL) for both static and dynamic queries. It also supports the use of pluggable persistence providers. The Java Persistence API is now the preferred persistence API for use with EJB 3.0 applications.
[http://java.sun.com/javaee/technologies/persistence.jsp]

== Apache ObJectRelationalBridge - OJB ==

* The PersistenceBroker kernel API and all top-level APIs (ODMG, OTM, JDO) allows Java Programmers to store and retrieve Java Objects in/from (any) JDBC-compliant RDBMS
* Transparent persistence: classes does not have to inherit from any OJB base class nor implement a special interface. OJB delivers pure transparent persistence for POJOs.
* Scalable architecture that allows to build massively distributed and clustered systems.
* Quality assurance taken seriously: More than 800 JUnit Test Cases for regression tests. JUnit tests are integrated into the build scripts and used as quality assurance for daily development.
* Support for Polymorphism and Extents. You can use Interface-types and abstract classes as attribute types in your persistent classes. Queries are also aware of extents: A query against a baseclass or interface will return matches from derived classes, even if they are mapped to different DB-tables
* Support for persistent object caching. Different caching strategies and distributed caches.
* OJB uses an XML based Object/Relational mapping. The mapping resides in a dynamic MetaData layer, which can be manipulated at runtime through a simple Meta-Object-Protocol (MOP) to change the behaviour of the persistence kernel.
* OJB provides several advanced O/R features like Object Caching, lazy materialization through virtual proxies and distributed lock-management with configurable Transaction-Isolation levels. Optimistic and pessimistic locking is supported.
* OJB provides a flexible configuration and plugin mechanism that allows to select from set of predefined components or to implement your own extensions and plugins.
[http://db.apache.org/ojb/]

== Enterprise Objects Framework (Apple) ==

Enterprise Objects Framework provides tools for defining an object model and mapping it to a data model. This allows to create objects that encapsulate both data and the methods for operating on that data, while taking advantage of the data access services provided by the Framework that make it possible for these objects to persist in a relational database.
The flexible, three-tier architecture provided by the Framework allows to build robust, scalable, client/server applications. Objects at each of the three tiers (user interface, enterprise objects, and data store) can be deployed to take advantage of network resources. For example, data might be stored in a relational database running on a fault-tolerant database server with gigabytes of disk storage, while enterprise objects run on high-end compute servers. Partitioning the application to make best use of available resources allows complex applications to achieve maximum performance.
The portions of the Framework can be used selectively to meet specific application requirements. For example, the components that provide users with the ability to interactively manipulate enterprise objects can be used by a non-database application to handle user interface refresh and undo. We can use a custom data store (such as a flat-file system) in place of a relational database to store data for enterprise objects. Or we can make use of the database adapters separate from the rest of the Framework components to provide direct access to relational databases for your applications.
[http://developer.apple.com/]

= Criteria for Selection =

There is no perfect single tool exists. Hence the most important thing when searching for the right tool is to define precisely which criteria are essential. Following is the summary of criteria which can be considered while selecting the ORM product:

== ORM specific criteria ==
=== Basic features: ===
* Be able to use inheritance, create hierarchies between entities, and use polymorphism (we are using objects!). The tools can support a variety of combinations for tables and classes to allow these mechanisms.
* Handle any type of relations (1-1, 1-n, n-n)
* Support for transactions
* Aggregates (equivalent to SQL's SUM, AVG, MIN, MAX, COUNT)
* Support for grouping (SQL's GROUP BY)
* Supported databases. A big advantage of mapping tools is that they provide an abstraction of the underlying database engine. Most of them allow switching easily between RDBMSs
=== Flexibility ===
* Customization of queries. HQL is a strong point of Hibernate/NHibernate. We could also wish a dynamic mapping to be possible from developer provided SQL queries.
* Support any type of SQL joins (inner join, outer join)
* Be able to map a single object to data coming from multiple tables (joins, views). And Be able to dispatch the data from a single table to multiple objects.
=== Performance ===
* Lazy loading - he loading of some data is deferred until it's needed. For the data through relations and for some columns.
* Cache dynamically generated queries and Cache some data to avoid too many calls to the data source.
* Handle cascade updates. Deleting a master record should delete the linked details if wished so.
=== Evolution: ===
* Maintainability - what happens if the database schema changes? If I need to add a new collection?
* Possibility to move to a new mapping tool
* Serialization. Serialization can be used to persist data outside of the database. Serialization can be done into a binary format, or more important, in XML (

== Non ORM specific criteria ==
* Price
* Performance
* Resource consumption (memory)
* Scalability
* Complexity (or simplicity...)
* Ease of use, time to be up and running
* Documentation quality, Support, forums, community
* Maturity, Frequency of the updates, bug fixes, evolutions
* Vendor's reputation and stability
* Support for multiple platforms

= References =

= Further reading =

= External links =

# http://ar.rubyonrails.com/
# http://www.ksc.com/article5.htm
# http://www.hibernate.org
# http://www.oracle.com/technology/products/ias/toplink/index.html
# http://java.sun.com/jdo
# http://java.sun.com/javaee/technologies/persistence.jsp
# http://db.apache.org/ojb/
# http://developer.apple.com/
# http://en.wikipedia.org/wiki/Object-relational_mapping
# http://c2.com/cgi-bin/wiki?ObjectRelationalToolComparison