Agile Methodology

During the 1970s, the Waterfall methodology was prevalent as being superior to all other methodologies of use (although there weren’t that many). Using Waterfall meant spending a huge amount of time and effort gathering resources upfront and panning with a lot of key decision based on assumption.

Though it was just not working out for ‘modern developers’, as the waterfall methodology just felt slow moving, regulated and constricting.

Therefore a group of individuals around 2001 created a process that was referred to as “alternative to documentation driven, heavyweight software development process”.

This was later referred to as the Agile Manifesto. 

As part of the Manifesto they had created, there were 4 key values that all Agile projects would adhere to:

1. Individuals and interactions over process and tools.
2. Working software over comprehensive documentation.
3. Customer collaboration over contract negotiation.
4. Responding to change over following a plan.

What is the Agile methodology?

Agile is the ability to create and repose to change. Agile is a way of dealing with and being successful in an uncertain environment, which can be filled with obstacles and hurdles.

In software development, the Agile approach is all about developing requirements and solutions through a collaborative effort between the development team and the client.

The methodology preaches adaptive planning, evolutionary development, early delivery, and continuous improvement to the system that was development, furthermore, Agile also encourages flexible responses to change.

The Agile software development principles include:

The Agile Manifesto for Agile Software Development is based on twelve principles:

1. Achieving customer satisfaction by early and continuous delivery of the valuable software that they require.
2. To welcome a change/changes in requirements, despite it being late in the development.
3. To deliver software frequently (usually within each iteration, i.e. weeks, rather than months).
4. A good close relationship between the development and the client.
5. Projects should be built around motivated individuals, who can be trusted.
6. Face-to-face conversation is the best form of communication.
7. Working software is the primary measure of progress.
8. To be able to develop at a constant pace, achieving sustainable development.
9. Continuous attention to technical excellence and good design.
10. Simplicity is essential.
11. Most efficient architectures, requirements, and designs will be produced from self-organising teams.
12. The team will regularly reflect on how to increase productivity and effectiveness of the software they had built.

Compared to other traditional software engineering methodologies, Agile software development will mainly target complex systems and product development with a non-deterministic, non-linear, and dynamic characteristics. Usually it will be difficult to obtain accurate estimates, stable plans, and predictions in the early stages of development, therefore the confidence in them is likely to be respectively minimal.

Teams that practice Agile will try to decrease the “leap-of-faith” (having requirements outside the scope of the project), which is required before any evidence of value can be collected. As specifications and requirements that can be outside the initial scope of the project can bring inefficiency and lack of productivity to the project, as developers will end up focusing on other aspects rather than the main goal.

The Agile methodology includes a number of software development methodologies that branch from it, including:

• Disciplined Agile Delivery (DAD)
• Adaptive Software Development
• Agile Modelling
• Kanban
• Scrum
• Srumban
• Extreme Programming (XP)
• Dynamic Systems Development (DSDM)
• Feature Driven Development
• Lean Software Development

Ultimately the overall goal for each Agile method is to adapt to change and deliver quality working software in the quickest time possible.

Although each methodology above may have slightly different variations in the way that they define the phases for software development.

Despite the overall objective being the same, each team process flow may be different depending on the specific project or situation.

Agile Iteration (sprint) Workflow

The Agile workflow environment is dominated by the notion of the iterative process also known as a sprint.

Each iteration results in the next piece of the software development process to develop.

Every iteration will usually have a fixed completion time. and takes around two to four weeks to successfully complete.

Due to the time-bound nature, the iteration process is methodical and the scope of every iteration is only as broad as the allocated time allows it to be.

During the Agile software development life cycle, there will be multiple iterations and each iteration will follow its own workflow.

During each iteration, it is important that the software development team and the client provide feedback to ensure that the features and requirements that the client had set out are met, and if there are any modifications or alterations needed in the next iteration, they are to be addressed. 

A typical iteration will have the following steps:

• Requirements:

Define the requirements for the iteration, which will be based on the product backlog, sprint backlog, customer and stakeholder feedback.

• Development:

Design and develop the software, based on the requirements that were given by the client.

• Testing:

Quality assurance testing, internal and external training, documentation development. All these are carried out during this phase.

• Delivery:

Integrate what was produced during the iteration into production.

• Feedback:

Accept feedback from the client, and implement that feedback into the next iteration.

What are the steps in the Agile methodology?

(Many industries can implement the Agile methodology, however the steps below will be relevant to computer science and technological aspects/software development)

• Requirements:

A documentation, which contains the list of initial requirements, must be created. These requirements are:

• The project objective and the result that the project will achieve at the end of development.
• Features that the software will support.
• Features that the software will not support initially, but may be added at a later stage.

A general rule of the thumb, is not to over complicate the initial requirements, but by adding only the necessary features and ignoring ones that won’t be used too often at this stage. Developers can implement these features at a later stage when the app is deployed and the core features function, as they should.

If developers choose to ignore the step regarding the non-addition of non-essential features, this can lead to what is known as “feature creep-situation”, where the non- essential features are constantly being added to the project, which will lead developers to waste time on non-important tasks rather than focusing on the core task.

(With further iterations, the client will review the requirements and can possibly add new features then)

• Design:

In software development, the design phase can be split into two:

• Software Design:

During this stage, the project team will discuss how to tackle the requirements that were created in the previous stage, and propose any relevant tool that are need to achieve the best result.

For instance, the team can discuss what potential programming languages, frameworks, and libraries they will be using and why they are the best choice for this project.

During further iterations the development team will discuss any feature implementations as well as the internal structure of the system.

• UI/UX Design:

During this phase, the development team will create a “draft” of how the User Interface/User Experience will be assembled and look like.

If the product that is being created is considered to be “consumer-grade” (which means that a person with no experience can use the system), the UI/UX of the system is the most important aspect.

Therefore this means that it’s proactive to review the possible competitors to see what they’re doing correctly, and what they can improve on.

During further iterations, time is spent on refining the initial design and/or re-working it to suite the new features.

• Development and Coding:

The development and coding phase revolves around implanting the code that is required to allow the system to function as it should, furthermore, this stage also allows the conversion of the design documentation into actual working software.

This stage is considered to be the longest, as it is regarded to be the backbone of the whole software.

• Integration and Testing:

The integration and testing phase allows the team to make sure that the software they’ve created in the step above has no errors, and no defects.

A quality assure team will conduct a series of tests in order to make sure that the code is clean and that the business goes of the solution are met as per the client requirements.

• Implantation and Deployment:

This step involves the application being deployed to the client server, so it can be provided to the customers. This can be either for demonstration or be deployed for actual use.

With further iterations, this step involves adding compiling new patches and allowing for new updates to be added to the software, which can fix potential bugs, add new features, or modify existing features.

• Review:

When the development phases are complete, a meeting between the product owner and the development team is done so that the product owner can review the progress made towards completing the requirements that were set out at the very beginning.

During this meeting, the development team will raise any problems they encountered and will propose ways to fix them in the next iteration, moreover the product owner will take these propositions for consideration and set out new requirements for the next iteration.

Once this life cycle is completed, a new iteration can be initiated.

Making the Agile methodology work for your team

Agile is generally more applicable for projects that have the development team and the client to be readily available to provide input. Therefore meaning that functioning portions of the software created in previous iterations are expected to be functioning, and flexibility is required to accommodate any changes in the requirements.

Below are four activities that teams will do to aid their Agile workflow:

Daily meetings:

Daily stand up meetings between team members to maintain open communication, and to discuss what has been completed and what obstacles there are. Ultimately to keep the iteration moving in the correct direction.

Live demonstrations:

Deliver live demonstrations of every iteration’s final product to showcase the progress made.

Share feedback:

Obtain feedback from the client and share it with the entire team before the subsequent iteration begins.

Adapting based on feedback:

Allow for changes based on feedback collated to ensure that each iteration improves from the previous one.

What are the advantages of Agile methodologies?

• Flexibility and adaptivity:

The Agile technique allows the client to define the requirements they require quite broadly at the very beginning, as it’s usually very hard to accurately define the requirements and design in detail prior to starting the project. When the initial requirements are implemented, Agile allows the developers to adapt them after consolidating with the client and seeing what amends/additions/removals should occur.

• Creativity and innovation:

Agile emphasises creativity and innovation to maximise the business value of the product for the client. Although, over-emphasis on planning and control will decrease creativity and innovation.

• Time-to-market:

Due to shorter start-up times, the Agile approach results in faster time-to-market. Furthermore, the iterative development mechanism used in the Agile approach allows portions to be complete without having the entire project completed to 100%.

• Lower costs:

Agile can potentially lower the cost in several ways:

• Reduced overhead, by reducing unnecessary documentation and control requirements.
  • Greater productivity of the project team.
  • A reduced “feature bloat” (packing too many features and functionalities into a product) from using an iterative development method and prioritising the requirements.

• Improved quality:

Quality is an integral part of the process rather than a sequential activity.

• Customer satisfaction:

Due to the client being heavily involved in the solution due to the development team and the client having gatherings/meetings at the end of each iterative cycle. This allows both parties to share problems, solutions to previous problems. Therefore this allows the team to implement any changes if necessary, hence increasing productivity, rather than dealing with all the changes at the very end. 

• Late changes in the requirements are allowed and accepted.

• Employee satisfaction:

Employees that are engaged can feel a sense of satisfaction as they can take responsibility for their own work as part of an empowered team.

• Organisational synergy:

Improves organisational synergy by breaking down organisation barriers and developing a spirit of trust and partnership around the organisational goals.

• Working software is delivered with every iteration (i.e. weeks, rather than months).

What are the disadvantages of Agile methodologies?

• Training and skill required:

Agile requires a considerable amount of training and skill to implement successfully and productively. Many development teams try to implement Agile without fully possessing the training nor the skill, furthermore, they also might not have a full understanding regarding the principles behind Agile, thus decreasing the efficiency at which they work at.

• Organisation transformation:

Agile requires the client and development team to work together in each sprint, this will mean that barriers between both parties should be broken to achieve a quality product and so that communication can flow swiftly between them.

• Scalability:

It may be difficult to implement large complicated projects with the Agile methodology.

• Integration with project/program management:

Agile may not suite projects that require a plan driven approach to achieve some level of predictability.

• Excessive pressure on developer:

Due to the focused pace and continuous workflow of Agile, individuals can become overworked.

• Difficulty is assessing the overall effort and even cost required at the beginning of the software development life cycle for large projects.

• Agile doesn’t have an increased emphasis on design and documentation like Waterfall for instance.

• As progress is done over a period of iterations/cycles, it is ore difficult to measure progress.

• Final product can be very different:

As mentioned in the article, the Agile methodology may not have a definitive plan, therefore the final product can look/function a lot differently to what was initially anticipated. This is actually due to Agile being so flexible, allowing the client to provide constant feedback, thus potentially evolving the whole project.

Summary and Facts

What is the Agile methodology?

In software development, the Agile approach is all about developing requirements and solutions through a collaborative effort between the development team and the client.

The methodology preaches adaptive planning, evolutionary development, early delivery, and continuous improvement to the system that was development, furthermore, Agile also encourages flexible responses to change.

Ultimately the overall goal for each Agile method is to adapt to change and deliver quality working software in the quickest time possible.

Though each methodology above may have slightly different variations in the way that they define the phases for software development.

Despite the overall objective is the same, each team process flow may be different depending on the specific project or situation.

What are the steps in the Agile methodology?

1. Requirements
2. Design
   • Software Design
   • UI/UX Design
3. Development and Coding
4. Integration and Testing
5. Implantation and Deployment
6. Review

What are the advantages of Agile methodologies?

• Flexibility and adaptivity
• Creativity and innovation
• Time-to-market
• Lower costs
• Improved quality
• Customer satisfaction
• Employee satisfaction
• Organisational synergy
• Late changes in the requirements are allowed and accepted
• Working software is delivered with every iteration (i.e. weeks, rather than months)

What are the disadvantages of Agile methodologies?

• Training and skill required
• Organisation transformation
• Scalability
• Integration with project/program management
• Excessive pressure on developer
• Difficulty is assessing the overall effort and even cost required at the beginning of the software development life cycle for large projects.
• Agile doesn’t have an increased emphasis on design and documentation like Waterfall for instance.
• As progress is done over a period of iterations/cycles, it is ore difficult to measure progress.
• Final product can be very different

References:

1. https://relevant.software/blog/agile-software-development-lifecycle-phases-explained/
2. https://www.smartsheet.com/understanding-agile-software-development-lifecycle-and-process-workflow
3. https://en.wikipedia.org/wiki/Agile_software_development#cite_note-Beck_Beedle_Bennekum_Cockburn_p.-3
4. https://managedagile.com/what-are-the-advantages-and-disadvantages-of-agile-scrum/
5. https://www.smartsheet.com/agile-vs-scrum-vs-waterfall-vs-kanban
6. https://study.com/academy/lesson/what-is-agile-methodology-overview-definition-steps.html
7. https://activecollab.com/blog/project-management/agile-project-management-advantages-disadvantages
8. https://www.agilealliance.org/agile101/
9. https://plan.io/blog/ultimate-guide-to-implementing-agile-project-management-and-scrum/
10. http://tryqa.com/what-is-agile-model-advantages-disadvantages-and-when-to-use-it/
11. https://managedagile.com/what-are-the-advantages-and-disadvantages-of-agile-scrum/