“Agile” means the ability to move quickly and easily, in a well-coordinated manner. As such, the Agile software development life cycle refers to developing software quickly through the collaboration of various cross-functional teams. The Agile model of the software development lifecycle involves developing the software in an iterative manner where each iteration focuses on developing a small set of features in the project that are added to the main build if they are successful. This iterative fragmented approach, together with the collaboration of various functional teams and end-users will help deliver the product much faster when the Agile methodology in the software development lifecycle is adopted.
The Agile Manifesto:
Even though the downfall of the most popular software methodology of yesteryears, the waterfall methodology, has led to many alternative software methodologies such as Rational Unified Process, Scrum, Extreme Programming, Adaptive Software Development, and Dynamic Systems Development Methods, all these software development methodologies are combined to form Agile methodology in the software development lifecycle. Around 17 technocrats drafted Agile Manifesto in the year 2001 and introduced
4 core values of an Agile software development lifecycle. They are –
1. Individuals & Interactions over processes and tools:
In an Agile environment, individuals and communications are given priority over processes and tools.
2. Working software over comprehensive documentation:
Rather than depending on the documentation, an Agile methodology believes in the demo software through which the end-user’s requirements and expectations can be understood.
3. Customer collaboration over contract negotiation:
In an Agile software development life cycle, the development team is more flexible in reaching out to the needs of the end-user or the customer, rather than strictly adhering to a rigid contract.
4. Responding to change over following a plan:
Change is always welcome and is valued in the Agile model of the software development lifecycle. In the Agile model, a plan can be changed at any point during the development stage and the focus is always on continuous development.
Based on the above 4 core values, 12 principles were designed and whoever follows these 12 principles are said to have successfully adopted the Agile model of the software development lifecycle.
Let’s see these 12 principles in detail.
1. The highest priority is to satisfy the customer:
The first principle of the Agile manifesto is giving the highest priority to the customer’s needs and satisfying them. But how to achieve this goal? Rather than promising big to the customer at the beginning of the project and later faltering with the delivery, the Agile methodology in the software development lifecycle delivers the core functionality of the software early in the project and then focuses on fine-tuning and addition of new features iteratively and continuously. This incremental approach involves all the stakeholders and end-users who provide feedback from time to time at each iteration for the betterment of the project. This way, the project team will know exactly what the customer wants and focus on those features rather than wasting time on the things that are not needed by the customer.
2. Changing requirements are welcome:
Unlike traditional software development methods where change isn’t encouraged once the specs are finalized and the project is on the go, the Agile software development life cycle methods are open to change at any stage in the software development. This is possible because the project is never viewed as a whole and is designed in small fragments which are then added to give the project its final shape. It is impossible to predict how the designed system reacts to various factors in a large complex project environment. It would be very easy to make changes when the project is developed in a fragmented approach and can continuously change the course of the project for betterment depending on the results so far achieved.
3. Deliver working software frequently:
In traditional models, customers are promised the product as a whole at the end of the project development timeframe. The problem with this approach is that the customer has to wait till the completion of the project to take a look at the project and if there are any bugs to be fixed or features to be added, it will further delay the project. With the Agile model, these problems never arise as the project is broken into smaller fragments and the customers are regularly delivered with iterative and incremental fragments. Each delivered fragment is a part of the larger solution which addresses a key component or some components of the total project. Even the customer can track the progress of the project and are happy to witness their project shaping up slowly, steadily, and more importantly, regularly!
4. Business people and developers must work together:
Continuous engagement leads to visibility! In the Agile project lifecycle, business people and developers meet regularly, as regularly as possible to share ideas, engage in debates, and discuss the project’s progress. This communication and engagement make different teams look into the aspects that are not visible otherwise and correct their course if they are not aligned with the project goals. The problem with traditional models such as the Waterfall model is that once the requirement phase is over, the development team seldom meets with all other stakeholders till the project is complete and they build the project based on their initial understanding during the requirement phase. This isn’t going to end well, particularly when the project is huge and complex.
5. Build projects around motivated individuals:
In the Agile method of building projects, project leaders should ensure that the teams working under them are motivated enough in shaping the project. They can do this by providing the team with the best tools available and all other resources that are required by the project. The Agile leaders should also ensure providing the best environment and culture for the team so that the team can give their best. The project leaders should believe in their team and trust them by giving them a free hand and addressing all their concerns regarding the project. The team’s outcomes can then be reviewed to arrive at where they stand and what is needed to improve them further. This approach is in contrast with the traditional management style of command and control.
6. An efficient & effective way of conveying information is to face to face:
The best way to exchange ideas or information is to have conversations face to face than to and fro via e. mail or chat. A lot of solutions can be found when a conversation happens in person than through any other means. Collaboration and communication are critical for all the team members in an Agile project lifecycle.
7. Working software is the yardstick:
In the Agile project lifecycle, working software takes precedence over various progress reports of the project. In the Agile methodology, success is measured by the working software that is delivered to the customer. Rather than the percentage of the total project completed or what part of the total plan has been achieved, agile focuses on the working product that is delivered which is useful to the customer. Therefore in the Agile methodology, working software is the primary measure of progress.
8. Maintain a constant pace, indefinitely:
In a traditional software development scenario, the project deadline is tackled casually at first and as the deadline is approaching, everyone in the team works continuously for long hours to meet the deadline. This puts undue pressure on every member and will ultimately affect the project. In an agile environment, since the project is approached incrementally, each fragment of working software is tested by all the stakeholders, and only upon its success, the team is moved to the next fragment. This steady constant pace between all the sponsors, developers, and users in the Agile project lifecycle promotes sustainable development.
9. Continuous attention to technical excellence:
Tech debt or Code debt is what happens when a development team takes actions to speed up the delivery of a piece of functionality rather than writing a perfect code. It is a tool used to get ahead in the project. Later, these pieces of code need to be refactored. In the Agile software development life cycle, since the product is delivered incrementally, sometimes the teams often take shortcuts in writing the code to achieve the goal faster. Agile teams should not only focus on delivering the product faster but should also pay continuous attention to the technical debt that is being accumulated over some time. This helps not only in having clarity in code but also enhances the agility of the software being written.
10. Simplicity – the art of maximizing the amount of work not done – is essential:
Instead of focusing on future requirements that may be needed in the future, the agile teams focus on the most valuable thing to do next. Simply put, to make your process more agile, do less and what is needed immediately rather than trying to attempt various things all at a time. This approach helps in gaining the trust of all the stakeholders through the delivery of working software frequently.
11. Quality thru self-organized teams:
The best architectures, requirements, and designs emerge from self-organizing teams. In other words, people associated closest to the work are the best to figure out how to do it efficiently in less time. The Agile teams don’t build the product in isolation instead, they build the product by reflecting upon how to make it more effective and better by adjusting and tuning the product continuously.
12. Feedback at regular intervals:
At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly. An Agile team frequently asks themselves what are the things that are going well, what the failures are, what are the areas that can be improved, and what are the ideas for improvement. Improving one thing at a time is always good rather than clumsily attempting to improve the system as a whole.
The above are the 12 principles on which all the existing agile methodologies are built. Now, let’s take a brief look at the
Six phases of the Agile software development lifecycle
1. Concept:
In this phase, the scope of the project is determined. The Agile team discusses the requirements, features, time frames, and the total cost of the project. The same is documented and analyzed whether the project is feasible to go ahead.
2. Inception:
Once the concept is finalized the next phase is inception in which the team members are identified and all the necessary resources are provided. In this phase of the Agile project lifecycle, the project architecture or a skeleton with all the requirements and the user interface is created.
3. Iteration:
This is the actual phase where the project is constructed. The skeleton or the architecture designed in the inception phase is converted into code. In the first iteration, the main functionality or the working software of the project is designed, and further additions, additional features, and enhancements are added later in further iterations as required by the product. This phase is the crucial phase of the Agile software development life cycle as this is the phase where the actual software is written and tweaked again and again till the desired outcome is achieved.
4. Release:
Once the product is ready with all the desired features and functionality, quality checks are done by QA team to ensure all the features and functionality are working fine with clean code and without any bugs. Documentation and user training will also take place during this phase. Once all this is thru’ the product is ready for release into production in the final iteration.
5. Maintenance:
Once the product is released and available to the end users, the Agile team members will now offer maintenance support like ensuring the system is running smoothly without any hindrance and resolving any minor issues or bugs that come along. Any upgrades to the system can be made in this phase with a new iteration.
6. Retirement:
Over a while, the software designed may become obsolete due to several factors. In such cases, the customers are first informed of the product retirement and if there is any replacement software already designed and in place, all the existing users will be migrated into the new system.
