A look into Agile development

By now you’ve sure heard about the Agile software development methodology, or even used this methodology in your work, so you know how intricate things can be. In order to shed some light onto this matter, I’ve gathered below the most important notions that a programmer / tester needs to know about Agile development.

So let’s begin!

…at first there was the manifesto! Agile software development is a set of software development methods that are derived from the Agile manifesto, a set of principles focused on a lightweight software development. The manifesto reads:

“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.”

The Agile manifesto was first published following a software developers’ meeting, in February 2001. Some of the authors of the manifesto formed the Agile Alliance, a non-profit organization that promotes Agile development principles.

But how does Agile development work? Agile development avoids long term planning by breaking tasks into small increments. Each iteration has its own software development cycle: planning, requirements analysis, design, coding, unit testing and acceptance testing, after which a full working piece of software is shown to the investors. This allows the teams to easily adapt to changes, this being one of the principles of Agile (Responding to change over following a plan).

On one hand, Agile development advocates practices such as: Test Driven Development (TDD) and Behavior Driven Development (BDD), where tests and scenarios are written before the actual code, and are used to create a suite of automated tests that verify if the written code meets the standards imposed for that application.

On the other hand, Agile testing involves all members of the agile team, but it’s the testers’ job to provide specific expertise and ensure that the quality and business value requested by the customer is successfully delivered at frequent intervals. Testers from an Agile team create examples of desired behavior and collaborate with  developers to turn them into automated test suites that guide coding.

As opposed to Agile, older methodologies, such as Waterfall, rely on a precise order of phases throughout the whole development process (Requirements, Design, Implementation, Verification, Maintenance) and heavily focus on initial planning. The idea behind this is that the time spent early in the development process (Planning) will result in saving time in later stages.

To advocate the Waterfall methodology, many argue that an issue found early is cheaper than one found in later stages. For example a design flaw can be easily fixed during the Design phase rather than months later, when changes to design are much harder to implement (and riskier for the stability of the application).

Agile fights back! Agile enthusiasts argue that the Waterfall model is not good in practice, as it is nearly impossible to finish a phase of development flawlessly. For sure issues will arise, such as: customers may change their initial design, developers might not be aware of future difficulties when creating a design for an new software product etc.

According to the Waterfall model, testing is another strict phase (as opposed to being distributed throughout the development process), and this comes with its own problems. For example, important issues may be found too late, due to the fact that testing is performed strictly after the implementation is complete. Or some other times, due to time pressure (since testing is the last phase before releasing the product), adequate testing cannot be performed on the entire application, and is limited only to the most important parts of the software.

In the Agile methodology, testing is a very important part of the development process – not only it finds existing issues in the code, but more importantly it leads to shaping the product in advance, and to avoiding issues instead of having to fix them later.

The advantages of Agile testing are obvious: less time is spent on fixing issues, thus fewer problems in later stages. This way, it’s easier to ensure that each part of the application meets the required quality and functional standards.

Although Agile, in theory, is highly praised, still it’s not used in its entirety, due to a few drawbacks. The most important one is that the Agile process is not based on a clear structure, and moving from a strict development model (Waterfall) to something that has no clear guidelines (Agile is mostly a set of principles, rather than a clear development model) is not so easy. However, thanks to the fact that Agile is flexible, nowadays there are many development companies that rely on Agile-based (hybrid) software development models.

Introducing SCRUM.

The most popular Agile process is SCRUM, an Agile framework that structures software development into cycles called “sprints”. Sprints usually last between two and four weeks, during which developers work with a prioritized list of customer requirements, named “user stories”. By following a prioritized list, the most valuable features are implemented first.

It’s clear that software development models are evolving and will continue to be enhanced, but Agile is here to stay! It has brought a new way of thinking, and also it makes room for improvement and adaptation, in response to market demands and the way each company runs its business.

Scroll to Top