Why is Quality Assurance Important?
What is software testing?
Let us take a look at what the notion of software testing actually includes.
- Testing is a process of researching software with the purpose of obtaining information about the quality of the product.
- Testing is a process of verification of conformability between predefined requirements and de facto implemented functionality.
- Assessment of the system with the purpose of finding differences between the intended state of the system and in-fact status.
In a broad sense, testing is one of the techniques of Quality Control (QC), which includes planning, writing of tests, carrying out of testing per se, and analysis of results of testing.
Decrease of expenditure
Testing plays a crucial role in the project lifecycle and is an integral part of the whole development due to the following reasons:
- Testing increases reliability, quality and efficiency of software.
- Testing helps the developer to check whether the software is functioning properly and that it accomplishes the tasks it is designed for.
- Testing helps to understand whether there is a difference between the factual and intended result, which provides for quality product.
Owing to the fact that testing is becoming a part of programming, developers are able to correct errors at the very early stages of development. This allows to decrease the risk of defects occurring in the end product. The earlier the process of testing is started, the earlier possible errors are found and the less it costs to correct them.
Without proper quality control, software products can cause significant harm to both the company that orders the development and owns the software, and to the end users. Financial loss and loss of brand confidence are just some of possible consequences.
Verification and validation are the main goals of the process. Effectively, software testing helps to not only uncover defects, but also establish its usefulness to the client. Consequently, high-quality and well-managed testing helps business be successful and increases brand confidence.
Proper and effective testing helps to increase its security.
Aims of testing
Usually the process of testing pursues the following objectives:
- Provide the ordering client with accurate information on the quality of the product being developed.
- Increase overall quality of the product.
- Prevent occurrence of defects.
Who does testing?
Under most circumstances, the following specialists are involved in the process of testing:
- Software tester.
- Software developer.
- Project manager.
- Product owner.
- End user.
Software quality characteristics
To further understand the benefits of testing, let us take a look at the characteristics of quality software, which testing helps to reach.
- Functionality. Functionality is defined as the ability of software to accomplish tasks that correspond to the predefined and implied user requirements, under given conditions of software usage. This characteristic is accounts for software functioning accurately and precisely, being compliant with requirements specification, being compliant with the industry standards and being protected against unauthorized access.
- Reliability. Reliability is defined as the ability of software to carry out set tasks under given conditions for a given duration and a given number of times.
- Usability. Usability is the level of ease of understanding, learning, usage and attractiveness of software by the user.
- Efficiency. Efficiency is the ability of software to provide the required level of performance in accordance with specified resources, timing and other predefined conditions.
- Maintainability. Maintainability of software is the ease of analysis, testing, modification to correct defects, modification with the purpose of implementation of new requirements, support, and adaptability to changing environment.
- Portability. Portability characterizes software from the point of view of ease of its transfer to a new environment – software or hardware.
When is it a good time to start and to end testing?
Let us take a look at the following graph.
As we see, the later a defect is found, the more it will cost to fix it, and the more efforts and resources will be required to do the fixing. As we remember, defects that are incorporated into the project at early stages of planning and design are especially treacherous, because they are very difficult to trace and to properly interpret. The conclusion is self-evident: the earlier in the lifecycle of a product development testing is started, the more confident one can be in the overall quality of the end product.
From experience, many specialists in the industry agree that testing should start at the stage of requirements elicitation.
It is harder to establish criteria for when testing should end, as according to principles of testing we can never be completely sure that software is 100% bug-free.
Therefore, other criteria are used:
- Preset timeline that was agreed upon in advance.
- Completion of all predefined test plans and cases.
- Reaching a predefined level of test coverage.
- Reaching a moment when almost no new bugs or critical defects are found.
- Management decision.
When we are testing a product, we first ask ourselves this question: “Is this working the way it is supposed to work?” In other words, is the actual behavior of product being tested aligned with the intended behavior? Is it meeting expectations? If the answer is yes, that’s great. If the answer is no, then there’s repair work to be done.
Human error means mistakes in development are inevitable, which means that every product needs to be tested, before it can be recommended for use and relied upon by end users. As Stephen Hawking wisely put it, “One of the basic rules of the universe is that nothing is perfect. Perfection simply doesn't exist... Without imperfection, neither you nor I would exist.”
Part of prioritizing the repairs required by quality assurance is evaluating the risks associated with any errors. Risk is a factor that might lead to negative consequences in the future, and it generally expressed as a probability indicating how likely certain consequences are to come to fruition and how they will influence the system as a whole. The definition of risk also includes the probability of a potential problem — something that has not happened yet and might never happen. Not all mistakes are equally harmful, and risk levels might vary greatly for different types of software.
For example, consider how a simply typo might lead to very different types of consequences depending on the context. A typo in a social media post about your recent vacation will lead to nothing more than a little mocking from your friends, at the very worst. But what if, when a scientific journal publishes a paper on most recent cancer research, the author mistypes a key statistic? This scenario could lead to the author’s or publication’s loss of credibility — or worse, it could lead to healthcare practitioners making decisions based on false data. Similar scenarios (and similarly various outcomes) are possible in software development as well. Bugs might be harmful to a lesser or higher degree, depending on the circumstances.
As we grow more reliant on software in our daily lives, bugs in that software can be a significant obstacle to our everyday activities — from storing sensitive information and providing entertainment to making out payments from the couch. We have all been there: a text editor acting up when the deadline for school project is approaching, a credit card payment failing for no apparent reason, or a website simply not loading. It’s the disruption caused by these bugs that make quality assurance so important. It is the job of professionals to find and report errors they can be fixed. Bugs are inevitable — as Albert Einstein said, “Anyone who has never made a mistake has never tried anything new.” However, with effective quality assurance measures in place, the fixes should be inevitable, too.