Agile Software Engineering: Agile Methods, Scrum, and Extreme Programming
CLO1: Recognize Software Engineering principles, life cycle phases, processes, and activities.
Software Process is a structured set of activities required to develop a software system.
There are many different software processes, but all involve four fundamental activities:
Note: A software process model is an abstract representation of a process. It presents a description of a process from some particular perspective.
When we describe and discuss processes, we usually talk about the activities or actions in these processes such as specifying a data model, designing a user interface, etc. and the ordering of these activities.
Process descriptions may also include:
Processes where all of the process activities are planned in advance and progress is measured against this plan.
Planning is incremental and it is easier to change the process to reflect changing customer requirements.
Important: In practice, most practical processes include elements of both plan-driven and agile approaches. There are no right or wrong software processes.
Plan-driven model with separate and distinct phases of specification and development.
Note: Each major phase is marked by milestones and deliverables (artifacts).
Modified Waterfall: The model has been modified to allow going back to previous phases, which opened the door for other iterative models.
Incremental Model: Rather than deliver the system as a single delivery, the system is broken down into increments with each increment adding a part of the required functionality.
The Incremental model combines the elements of linear and parallel process flow. The incremental process model focuses on the delivery of an operational product with each increment.
Using the list of features in the planned product, select those features that can be implemented in the next product increment.
Add detail to the feature descriptions so that the team has a common understanding of each feature and there is sufficient detail to begin implementation.
Implement the feature and develop automated tests for that feature, tests that will validate that the system's behavior is consistent with its description.
Integrate the developed feature with the existing system and test it to check that it works in conjunction with other features.
Deliver the system increment to product manager for checking and comments. If enough features have been implemented, release a version of the system for customer use.
Key Difference: User requirements are prioritized, then the highest priority requirements are included in early increments. Once the development of an increment is started, requirements are frozen, though requirements for later increments can continue to evolve.
Difference with Evolutionary Models: The list of features is defined from the beginning in the classical incremental model.
The Evolutionary models are iterative. They are characterized in a manner that enables you to develop increasingly more complete versions of the software in increments.
It is used when core or system requirements are well understood but additional system requirements have yet to be defined.
Often a customer defines a set of general objectives for software, but doesn't identify details for the functions and features. In other cases, developers may be unsure of the efficiency of an algorithm. In these cases, Prototyping may be the best approach.
Note: The Prototype can serve as "the first system." Although some prototypes are built as "throw away," others are evolutionary in the sense that the prototype slowly evolves into the actual system.
Spiral Model couples the iterative nature of prototyping with controlled and systematic aspects of waterfall. It provides the potential for rapid development of increasingly more complete versions of the software.
The Spiral Model is a risk-driven process model generator. It has two main distinguishing features:
Key Points:
Based on software reuse where systems are integrated from existing components or application systems (sometimes called COTS - Commercial-off-the-shelf systems).
The process to apply when reuse is a development objective. You want to use components that are already made or you want to make components that may be reused.
Note: Reused elements may be configured to adapt their behavior and functionality to a user's requirements. Reuse is now the standard approach for building many types of business systems.
The Unified Process is an iterative and incremental development process. The Elaboration, Construction, and Transition phases are divided into a series of timeboxed iterations. Each iteration results in an increment, which is a release of the system that contains added or improved functionality compared with the previous release.
Key Characteristic: The Unified Process integrates planning, modeling, construction, and deployment activities throughout all phases, with varying emphasis at different stages of development.
Software products must be brought to market quickly, so rapid software development and delivery is essential. Virtually all software products are now developed using an agile approach (except safety-critical systems, which are in direct opposition with agile manifesto and development principles).
Agile software engineering focuses on:
Agile is a mindset defined by 4 values, guided by 12 principles, and manifested through many different practices. Agile practitioners select practices based on their needs.
We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:
Individuals and interactions
over
processes and tools
Working software
over
comprehensive documentation
Customer collaboration
over
contract negotiation
Responding to change
over
following a plan
That is, while there is value in the items on the right, we value the items on the left more.
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 their needs 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.
Agile is a blanket term for many approaches, including:
| Process | Distinct Phases | Incremental Delivery | Iterative | Evolving Specification | Timeboxed Iterations | Risk Management |
|---|---|---|---|---|---|---|
| Waterfall | ✓ | |||||
| Incremental | ✓ | |||||
| Evolutionary | ✓ | ✓ | ✓ | ✓ | ||
| Spiral | ✓ | ✓ | ✓ | ✓ | ✓ | |
| Unified Process | ✓ | ✓ | ✓ | ✓ | ✓ | |
| Generic Agile | ✓ | ✓ | ✓ | |||
| Scrum | ✓ | ✓ | ✓ | ✓ | ✓ |