In Part I, we answered the question What is software testing doing?

In this Part II, I will share with you two of the most important subjects in software testing: Testing and Debugging, also known as Testing and Debugging.

In other words, testing is trying to find software errors (BUG) and debugging is finding ways to fix and fix them.

In this Part II, we will learn more about BUG – software errors and the cost if software occurs BUG.

I. What is a bug?

BUG is an error or error when a software program is created but the result is not as expected or incorrect. It prevents the software from being implemented in accordance with the software specifications and requirements. In software testing, there are many concepts related to this error or other error, depending on the case that people call it by the following names:

• Bug
• Defect (defect)
• Failure (failure)
• Error
• Problem
• Issue
• …

However, most of us only care about the three basic concepts that are Bug, Defect and Failure. Their relationship can be roughly understood based on the following simple diagrams: BUG -> DEFECT -> FAILURE Tools can:

• In the process of designing and building software, programmers make certain errors at certain screens or functions. That means there is an error in the software.
• If the monitors / functions appear to have an error, they themselves have defects
• If in certain environment and fault situations in the application or product is executed, the system will produce wrong results. This is a software failure

So, we ask the question? Where did that BUG come from?

II. The cause of the bug in the software

There are many causes of bugs at each stage of software development, as shown below:

From the images we illustrate, it is easy to see that bugs arise at each stage of software development and the rate of bug generation decreases from the specification stage to coding. At each stage, there are specific causes of the bug.

1. Software requirements specification phase:

• The request is not in the specification document
• The request is in a specification document but is too sketchy and inadequate, leading to readers not understanding or misunderstanding the request
• The request has been changed but has not been updated to the specification document
• In developing the specification document, the customer and the development team do not perform well in communication, leading to the development team’s misunderstanding or misunderstanding.

• This is the stage where bugs are most likely to occur because it is the first stage of the development process, the stage of concept formation and analysis, when things are still vague for both the customer and the team. Software products will be created so the error rate of occurrence is very very high

2. Design phase

• The person in charge of the design work carried out too hastily and without thoroughly following the specification requirements
• During the design process, the specification requirements were changed and although it was updated in the document, it was not modified in the design.
• Poor communication at this stage is again the cause of the bug

3. The coding phase

• The complexity of the software makes it difficult for the programmer to understand each function request or the relationship between the functions that make the bug arise.
• This is the beginning period of time pressures, work must be on schedule, deadline release each function … makes programmers can not perform carefully and spend time checking.
• Some unworthy mistakes come from programmers who come from subjectivity
• Poor specification documents and design documents lead to programming errors (false from the original)

4. Other causes

There are also many other causes leading to bugs in software such as:

• Software requires difficult technology to apply, the level of programmer cannot meet all
• Limitations of programming languages
• Programming languages ​​change and develop quickly so software doesn’t keep up with technology
• Third party error
• And many other causes

III. Costs for software errors

In the process of software development, we must always keep in mind that being careful at one stage is a big cost savings. That means that if you find a bug late in the development cycle, it will hurt the project more than an error found earlier.

1. Is there a cost of software bug?

• Software failures discovered at different stages of the Software Development Life Cycle (SDLC) have different negative impacts and costs to the project.
• If you follow the correct software development life cycle (SDLC), it is easier to have a reliable and easier fault-free software.
• However, it does not guarantee that the software will be error free. One of the main concerns of all software companies is reducing software release time.
• Testing is sometimes seen as an activity that increases software release time and results in negative perception.
• Unfortunately, a small number of organizations pay little attention to this important activity and provide low quality software services.
• The costs associated with detecting and fixing defects increase significantly throughout the life cycle, if they are not rectified on time.
• In short, the cost of an error increases exponentially as the software evolves along SDLC.

Example 1: If an error is detected during the request period, the cost may be $ 1. If it is detected during the design phase, the cost will increase to $ 10, $ 100 during encryption and $ 1000 during testing. If you discover a problem right away, it could save additional work later, as depicted in the image below:

Example 2:

We’ve all heard about the infamous Samsung Galaxy Note 7 smartphone case and all the phone explosions. Samsung had to pay $ 17 billion for this error. Not only did it cost a lot of money, but Samsung’s reputation also suffered. If they have discovered the bug earlier, it will save them a lot of money.

2. Some serious damage can be caused if you bypass the software testing listed below:

• Software quality is lower
• Increasing indirect costs incurred for quality assurance due to software defects are detected later in the development cycle.
• Losing customers, trust and brand image of software vendors. One of the biggest loss of bad quality is reputation. In addition to losing money, software vendors lose support from customers
• Therefore, it is advisable to start testing early in the development cycle. AS SOON AS POSSIBLE

IV. Manage software quality to avoid arising BUG and limit COST

In the software development process, we have a formula for close connection between software testing and software quality assurance as follows:

** Quality control = Quality Assurance (QA) + Quality control (Quality Control – QC) **

• Quality assurance focuses on the process
• Quality control focuses on products and projects
• Software testing is part of software quality assurance

1. What is quality assurance?

• Quality Assurance abbreviated as QA.
• Is focusing on the quality of the product development process to avoid mistakes in the project’s products or services and thus prevent problems for your stakeholders.
• It includes the following tasks: planning, implementation, testing and action Specific:
• Planning – The organization should plan and set process-related goals and identify the processes required to provide a high quality product.
• Implement – Develop and test Processes and also “change” processes
• Check – Monitor processes, modify processes and check if it meets pre-defined goals.
• Action – Take actions needed to achieve process improvements

Principles of quality assurance

There are two principles for quality assurance.

• One is purpose-fit, meaning the product or service meets its purpose.
• Second, right the first time, immediately, in which any mistakes they have to be handled promptly.

With these two principles in mind, the goal is to make the product or service work correctly all the time through managing variables in the project. To do so, quality assurance involves the quality control of raw materials, assemblies, products and components; services related to production; and process management, production and testing.

2. What is quality control?

• Common quality control is abbreviated as QC.
• This is a software engineering process used to ensure quality in a product or service.
• It does not deal with the processes used to create a product; Instead, it checks the quality of the “end product” and the final result.

The main purpose of quality control

• Is to check whether the products meet the specifications and customer requirements.
• If a problem is identified, it should be repaired before delivery to the customer.
• QC is also assessed for the quality of their skills and training for certificates.
• This assessment is necessary for a service-based organization to contribute to providing “perfect” service to customers.

3. The difference between Quality Assurance and Quality Control

Sometimes, QC is confused with QA. Quality control is testing of products or services and testing results. Quality assurance is testing of processes and making changes to the processes leading to the end product.

4. Differences between Quality Assurance and Testing

Source: Software Testing Book: An ISTQB-BCS Certified Tester Foundation guide, 4th edition

Authors: Brian Hambling, Peter Morgan, Angelina Samaroo, Geoff Thompson, Peter Williams