Iterative Waterfall Model was very popular for completing a project in early days. But nowadays, developers face various problems while using it like handling customer change requests during project development and the high cost and time required to incorporate these changes. In the mid-1990s, the Agile Software Development Model was proposed to overcome these drawbacks of the Waterfall Model.
Agile Model
Primarily designed to help a project adapt change requests quickly. The main aim is to facilitate quick project completion. To accomplish this task, it is important that agility is achieved. Agility is achieved by adapting the development process to suit the specific project, eliminating unnecessary activities that do not add value, and avoiding tasks that waste time and effort. The Agile Model is not a single method but a collection of development approaches.
Steps in the Agile Model
The Agile Model is a combination of iterative and incremental process models. The phases involve in Agile (SDLC) Model are:
- Requirement Gathering
- Design the Requirements
- Construction / Iteration
- Testing / Quality Assurance
- Deployment
- Feedback
1. Requirement Gathering
In this step, the development team must gather the requirements, by interaction with the customer. Development team should plan the time and effort needed to build the project. Based on this information they can evaluate technical and economical feasibility.
- Meet with the customer to really understand their needs and what they expect from the software.
- Identify requirements and align them with business objectives so everyone shares the same understanding.
- Estimate how much time and effort it will take to develop the software.
- Assess if the project is technically possible and whether it's worth the investment from both a technical and economic standpoint.
2. Design the Requirements
In this step, the development team will use user-flow-diagram or high-level UML Diagrams to show the working of the new features and show how they will apply to the existing software. Wireframing and designing user interfaces are done in this phase.
- After gathering requirements, the next step is to design the overall structure of the system based on those needs. This ensures the software is organized in a way that meets user expectations.
- Wireframes are then created for the user interface. These act as simple layouts that show how the software will look and how users will interact with it, making sure it is easy to use.
- At this stage, high-level designs using UML (Unified Modeling Language) diagrams are prepared to visually show the system structure and how different components are connected.
- Prototypes are also developed to give stakeholders an early view of the system. This helps in collecting feedback early and making necessary changes before full development begins.
3. Construction / Iteration
In this step, the development team starts working on the project with the goal of delivering a working product. Each cycle typically consists of 1–4 weeks, and at the end of each iteration, a working version of the software is delivered.
- The team develops the features identified during the requirement and design phases.
- New functionalities are coded and integrated into the software based on the goals of that specific iteration.
- After each cycle, a usable version of the software is ready for review or use.
- With every iteration, the software is improved by adding new features and refining existing ones.
4. Testing / Quality Assurance
In this phase, the software is tested to ensure it works correctly and meets the required standards. The team identifies and fixes bugs, errors, and performance issues to improve overall quality.
- Unit Testing: Checks small pieces of code to ensure each part of the program works correctly on its own. It focuses on testing individual units or components.
- Integration Testing: Verifies that different units of the software work properly when combined and helps identify issues in their interaction.
- System Testing: Ensures that the complete software meets user requirements and works correctly in all possible scenarios.
5. Deployment
In this step, the development team deploys the working software to end users. Once an iteration is completed and fully tested, the software is ready for release.
In Agile, deployment is not a one-time activity; it is a continuous process where updates and improvements are released regularly to keep the software evolving.
- Deploy the software to a test or live environment so that it can be used by customers or end users
- Make the software accessible to users and ensure they can start using it as expected.
- Ensure the deployment runs smoothly and quickly fix any issues that arise.
6. Feedback
This is the final step of the Agile Model, where the team collects feedback on the product and works on fixing issues based on input from customers.
- Take feedback from customers, users, and stakeholders after each iteration.
- The team analyzes how well the product meets user needs and identifies areas for improvement.
- Check for bugs or issues that need fixing.
- Make adjustments to the development plan based on feedback to improve the product further.
Agile SDLC Methods
Some of the Agile Testing Methodologies are:
- Test-Driven Development (TDD): Software development process relying on creating unit test cases before developing the actual code of the software. It is an iterative approach that combines 3 operations, programming, creation of unit tests, and refactoring.
- Behavior Driven Development (BDD): Agile software testing that aims to document and develop the application around the user behavior a user expects to experience when interacting with the application. It encourages collaboration among the developer, quality experts, and customer representatives.
- Exploratory Testing: The tester has the freedom to explore the code and create effective and efficient software. It helps to discover the unknown risks and explore each aspect of the software functionality.
- Acceptance Test-Driven Development (ATDD): Collaborative process where customer representatives, developers, and testers come together to discuss the requirements, and potential pitfalls and thus reduce the chance of errors before coding begins.
- Extreme Programming (XP): Customer-oriented methodology that helps to deliver a good quality product that meets customer expectations and requirements.
- Session-Based Testing: It is a structured and time-based approach that involves the progress of exploratory testing in multiple sessions. This involves uninterrupted testing sessions that are time-boxed with a duration varying from 45 to 90 minutes. During the session, the tester creates a document called a charter document that includes various information about their testing.
- Dynamic Software Development Method (DSDM): Agile project delivery framework that provides a framework for building and maintaining systems. It can be used by users, developers, and testers.
- Crystal Methodologies: Focuses on people and their interactions when working on the project instead of processes and tools. The suitability of the crystal method depends on three dimensions, team size, criticality, and priority of the project.
Principles of the Agile Model
There are 12 Agile Principles mentioned in the Agile Manifesto. Agile principles are guidelines for flexible and efficient software development.
- Our highest priority is to satisfy the client through early and continuous delivery of valuable computer software.
- Welcome dynamic necessities, even late in development. Agile Processes harness modification for the customer’s competitive advantage.
- Deliver operating computer software often, from a pair of weeks to a couple of months, with a preference to the shorter timescale.
- Business individuals and developers should work along daily throughout the project.
- The build comes around actuated people. offer them the setting and support they have, and trust them to urge the task done.
- the foremost economical and effective methodology of conveyancing info to and among a development team is face-to-face speech.
- Working with computer software is the primary life of progress.
- Agile processes promote property development. The sponsors, developers, and users will be able to maintain a relentless pace indefinitely.
- Continuous attention to technical excellence and smart style enhances nimbleness.
- Simplicity—the art of maximizing the number of work not done—is essential.
- the most effective architectures, necessities, and styles emerge from self–organizing groups.
- At regular intervals, the team reflects on a way to become simpler, then tunes and adjusts its behavior consequently.
Characteristics of the Agile Process
The Agile process is all about being flexible, working together, and focusing on delivering real value to customers. Here is the Characteristics of the Agile Process:
- Agile processes must be adaptable to technical and environmental changes. That means if any technological changes occur, then the agile process must accommodate them.
- The development of agile processes must be incremental. That means, in each development, the increment should contain some functionality that can be tested and verified by the customer.
- The customer feedback must be used to create the next increment of the process.
- The software increment must be delivered in a short span of time.
- It must be iterative so that each increment can be evaluated regularly.
When To Use the Agile Model?
The Agile model works really well for certain types of projects. Here’s when Use the Agile Model:
- When new changes need to be implemented. The freedom that playfulness gives for change is very important.
- New changes can be implemented at a very low cost due to the frequency of new increments.
- Implementing a new feature requires developers to lose only a few days or even just hours of work to get it back and implemented.
- In the Agile model, unlike the Waterfall model, very limited planning is required to start a project.
- Agile believes that the needs of end users are always changing in the dynamic business and IT world.
- Changes can be discussed and features can be redesigned or removed based on feedback.
Advantages of the Agile Model
- Working through Pair programming produces well-written compact programs which have fewer errors as compared to programmers working alone.
- It reduces the total development time of the whole project.
- Agile development emphasizes face-to-face communication among team members, leading to better collaboration and understanding of project goals.
- Customer representatives get the idea of updated software products after each iteration. So, it is easy for him to change any requirement if needed.
- Agile development puts the customer at the center of the development process, ensuring that the end product meets their needs.
Disadvantages of the Agile Model
- Lack of formal documentation can create confusion, and important decisions may be misinterpreted by team members.
- Not suitable for projects with complex dependencies.
- Highly dependent on customer interaction; unclear requirements can lead the team in the wrong direction.
- Short development cycles make it difficult to plan, estimate timelines, and manage resources effectively.
- Requires experienced and skilled team members to handle changing requirements and iterative development.
- Limited documentation can make maintenance difficult after project completion, especially when team members move to other projects.