5 Agile Features for Quality Assurance
Goods and services quality management is one of the most important part of any business, especially in information technologies industry. This is also because a market entry barrier is rather low. And you still sometimes don’t need serious investment for that. One more evidence of it is abundance of software development for business offers on IT-market. However, software is usually inadmissible quality and it makes clients select developer very carefully.
Agile lets achieve software high quality with reasonably low costs as long as there are the same practices as in lean production.
“Software as a product” quality metrics
The term “quality” is a complex figure that most engineers define as checklist:
- Dependability – when software functions as its users are expected it to and make them sure it is working properly. The more strict variation of Dependability is Correctness. It means the appropriateness between the software and its formal functional specifications. In the reality it’s often difficult to set precisely all the functional requirement due to the fact of an IT-system complexity. This is why the practical factor of Dependability is more relevant than the formal of Correctness one.
- Robustness – means that the probability of software functioning failure and destruction is negligible. This is very important feature that exceeds the IT-system accordance to a client’s and users’ expectations along with the software dependability.
- Performance – is a software ability to solve tasks within the reasonable operations time
- Usability – is user friendliness of the interface according to user experience guidelines
- Supportability – is again a complex factor and includes: repairability, scalability and evolvability, that means its further features improvements
- Reusability – is the opportunity to develop other software, based on the current one that let’s to cut costs and improve reliability
- Interoperability – is a software feature of interaction with other software to deliver its functions and to solve the whole IT-infrastructure tasks. This is very important as long as it’s not common any more to build isolated IT-systems but essential to connect it to plenty of others.
Quality metrics of development processes
But a quality of a processes is essential for a software quality. So this is impossible to manage it without managing its creation processes:
- Productivity – means how effectively a developer can deliver the functionality and is usually measured by time in the situation of its limitations.
- Timeliness – is a factor, that indicates the possibility to deliver functionality on time. The process is not acceptable if it can’t achieve the result even with the additional resources.
- Visibility – is the development stages and operations processes being transparent to everybody involved. A client should see and understand how the IT-system is developing in order to do effective risk management.
Quality assurance standards and methodologies
Summarizing the aforementioned, the software quality assurance is based on the quality of the software development processes. This leads to the defined procedures and tasks of the processes. A range of the developers formal procedures is a traditional way to distinguish them from the lower quality ones. The main standards of calendar plans, regulated procedures of version releases and documentation of processes and product are:
- Capability Maturity Model (CMM)
- ISO 9000
- IT Infrastructure Library (ITIL)
It is important to distinguish methodologies of quality process development from processes standards, which should be provided by them:
- Rational Unified Process (RUP)
- Microsoft Solution Framework (MSF)
- Agile family methods
Agile methodology of quality assurance
The Agile Manifesto is based on twelve principles:
- Customer satisfaction by early and continuous delivery of valuable software
- Welcome changing requirements, even in late development
- Working software is delivered frequently (weeks rather than months)
- Close, daily cooperation between business people and developers
- Projects are built around motivated individuals who should be trusted
- Face-to-face conversation is the best form of communication (co-location)
- Working software is the principal measure of progress
- Sustainable development, able to maintain a constant pace
- Continuous attention to technical excellence and good design
- Simplicity—the art of maximizing the amount of work not done—is essential
- Best architectures, requirements, and designs emerge from self-organizing teams
- Regularly, the team reflects on how to become more effective, and adjusts accordingly
This means that agile doesn’t deny the importance of quality processes and its achievement instruments, all sorts of documentation, task planning and its following, but states that this is not the most important. The main focus is people, that are involved into a development process, their communications and the result as an IT-system, that is able to function in the face of changing requirements. Such point of view makes Agile a humanistic approach of development, that takes in account human and social factors, immerse teamwork, leans on collaborative experience and every employee involvement into the development process.
It worth mentioning that only a system of quality assurance practices can provide a cumulative effect and deliver a high quality software. Most common of them are:
- Frequent system demonstration to client
Scrum sprints are 2-4 weeks long and finish with a demonstration of a scope of features done and feedbacks from the client. This allows to keep developing features, that are most actual for clients and help them to focus on what they really want.
- Frequent version releases
After a feedbacks implementation in the same release, a regressive testing is done by engineers and a new version is delivered for client-side usage. In this case clients can always point and explain what they want to develop next.
- Acceptance test development
Engineers develop test examples according to the client’s requirements in order to increase clarity of the future features for developers
- Module test development
Design session lets development team define an IT-system architecture as scope of modules and their requirements. In this way software development process and its code get more flexibility and help with the effective documentation
- Sprint retrospective
This practice is very similar to classic mistakes retrospective and is also discussion session for current practices productivity and implementation of new ones.
Agile-practices make IT-system flexible and easy supportable costs. Test driven development makes application code being impregnated with its quality.