Waterfall Model
Representing a traditional software
development life cycle, the Waterfall model includes 6 consecutive phases:
planning, analysis, design, implementation, testing, and maintenance.
In the testing phase a product,
already designed and coded, is being thoroughly tested before the release.
However, the practice shows that software errors and defects detected at this
stage might be too expensive to fix, as the cost of an error tends to increase
throughout the software development process.
For example, if there is an error
in the specifications, detecting it early in the planning stage wouldn’t cause
significant losses to your business. However, the damage grows exponentially
throughout the further stages of the process. If such an error is detected at
the design stage, you will need to rework your designs to fix it. But if you
aren’t able to detect the mistake before the product is built, you might need
to make some major changes to the design as well as the source code. This will
require a significant amount of effort and investment.
The same is the case for errors
produced in the process of implementation. If a feature has a flaw in its
logic, building more functionality on top of it might cause a serious damage in
the long run. Therefore, it is better to test every feature while the product
is still being built. This is where iterative Agile methods prove beneficial.
Agile Testing
Being an integral part of the
software development process, Agile breaks the development process into smaller
parts, iterations, and sprints. This allows testers to work in parallel with
the rest of the team throughout the process and fix the flaws and errors
immediately after they occur.
The main purpose of such process is to deliver new software features fast and with the best quality. Therefore, this approach is less cost-intensive: Fixing the errors early in the development process, before more problems snowball, is significantly cheaper and requires less effort. Moreover, efficient communication within the team and active involvement of the stakeholders speeds up the process and allows for better-informed decisions. You can find out more about roles and responsibilities in a testing team in our dedicated article.
The Agile testing approach is more
about building up a QA practice as opposed to having a QA team. Amir Ghahrai, a
Senior Test Consultant at Amido, comments on this matter: “By constructing a QA
team, we fall in the danger of separating the testers from vital conversations
with the product owners, developers, etc. In Agile projects, QA should be
embedded in the scrum teams because testing and quality is not an afterthought.
Quality should be baked in right from the start.”
DevOps Testing
For those who have Agile experience, DevOps gradually becomes a common practice. This new software development methodology requires a high level of coordination between various functions of the deliverable chain, namely development, QA, and operations.
DevOps is often referred to as an extension
of Agile that bridges the gap between development along with QA and operations.
However, unlike Agile, DevOps includes the concept of continuous development
where the code, written and committed to version control, will be built,
deployed, tested and installed in the production environment that is ready to
be consumed by the end-user. DevOps places a great emphasis on automation and
continuous integration tools that allow for the high-velocity delivery of
applications and services.
The fact that testing takes place
at each stage in the DevOps model changes the role of testers and the overall
idea of testing. Therefore, to be able to effectively carry out testing
activities, testers are now expected to have technical skills and even be code
savvy.
According to the PractiTest survey,
the Agile trend is an undisputed leader, while almost 90 percent of respondents
work at least in some Agile projects within their organizations. That said, a
third of the respondents is still applying the Waterfall model in some
projects, following a steady decrease in the use of that method. DevOps keeps
growing, just slower than before.