Month: January 2017

Verification and testing are two other software engineering terminologies that need to be explained for a better understanding. Both of them play a significant role in the development of a program that will satisfy the end user and maintain high quality.

What is software testing?

Software testing refers to the process of executing an application or program with the intent of detecting potential software bugs. It also has the objective of helping the developers to find out whether the software is working according to the intended purpose. During the testing process, the end user’s area of application will be considered and the software will be subjected to a series of tests to ensure it satisfies the needs of the end users.

This will include several testing for several factors that may affect the performance of the system such as the presence of a bug, programming error, and other hidden dangers to the software. When these shortcomings are detected during the testing process, they will be corrected without delay before the completion of the software system.

There are different types of system testing techniques. These are static testing, dynamic testing, unit testing, integration testing, and other testing techniques. All these testing techniques have a single function: to ensure that the software does not fail to meet the expectations of the end users, the people who the program is designed for.

The testing can either be done manually by the programmers. This will require that they will go through the program to hand pick the errors for correction.  The automated can also be used for testing but it functions by using some tools and scripts. Although the techniques are different and have their advantages,

On the other hand, we have software verification, another important tool they each constitute a great way of identifying the errors in a program. There are contributory factors to the high quality of a software program. What is it?

What is system verification?

Before a system is developed, there must be a design where the basic requirements for the system are well spelt out. During the development of the system, verification is done to consider whether the system is developed according to the requirements and specifications. This may include all the activities that are combined to make sure that high-quality software is released for use to the end users.

Some of the processes that make up system verification are:

• Inspection
• Specification analysis
• Testing
• Design analysis

The verification process is usually at the beginning of a development process and all the processes above will be done for the evaluation of some important plan, code, and specifications. The objective of verification is to answer the question “Are we developing the software according to the specification and requirements?”

For instance, banking software will be expected to be used for processing customer information, balance the account in case of withdrawal or otherwise, and other related functions. If verification is to be performed on the software, the testers will test whether these functions can be performed effectively by the software. If a banking software can update a withdrawal but cannot do the same for saving, it will generate a lot of problems. If verification is performed, such problem will be easily corrected. If any of the features of the software malfunctions, the defect will render the performance of the system useless.

While there is a stark difference between system testing and system verification, one of the system verification methods is system testing. It is testing the software that will reveal whether it is developed in conformity with the laid down design and purpose.

Software testing and software development are two distinct terms in computing. They are two different and important stages in the life of a software program because they perform different functions that support the existence and efficiency of a program. It is important to define each of these terms and identify the various roles they play.

Software testing

Software testing is the process of confirming the correctness, quality, and completeness of a computer software. It involves carrying out some specific activities that are designed to spot the errors in a software program so that it can be corrected before it is released and distributed to the end users.

The test helps the developers to check whether the result of the test will correspond with the expected result as well as check if the software is error free. How is this done?

To test a software, it is operated under some controlled conditions to see whether the output is the expected output, study the behavior of the program, look for errors, and check whether the software will meet the needs of the user or not.

For instance, if a program is designed to process the payroll of a company, during testing, the various stages of processing of payroll will be tested on the program.   Different parameters may be tested in the program to ensure that it functions in all the areas where it is expected to be used by the end user. The program may fail or show some flaws such as inaccurate calculation or omission of some data, factors that can have serious effects on the output of the program. When this occurs, the program will be taken back to the software programmer to correct all the errors. That is the essence of software testing.

Software development

While software testing involves analyzing software program to determine its efficiency and errors in addition to evaluating some features of the software, software development refers to how the software program is developed. It is simply the process of writing a computer code and maintaining it. In a broad sense, software development involves all the developmental stages of the software from the conception of the idea to the launching of the programs.

While software development may sound simple, the process may involve an extensive research, prototyping, re-engineering, developing an extensive algorithm, drawing a flowchart, several modifications, coding for hundreds of hours, debugging both serious and minor errors, and other processes that may contribute to the existence of the software program. Software development is also called application development, enterprise application development, designing software, platform development, and the likes.

This brings out the difference in the two terms. While software development refers to all the processes that culminate in the existence of a software program, software testing is checking the software to see areas of improvement, detect potential errors, test the software for accuracy, or any other activities that will ensure the successful launching of error-free software. It is a way of finding out whether a program is functioning in conformity with the objective of the software when it was under development.

Software programs are tested by software developers who are also called programmers while a software program can be tested by a software tester, test lead, test administrator, test designer, automation tester, or manager.

Although the testing is not a part of the software development, it serves as the guide to the developer to see what can go wrong and render their efforts useless.

In essence, software development precedes software testing. Without developed software, there is nothing to be tested. On the other hand, without well-tested software, a program is nothing.

These two terms are used interchangeably by some individuals due to the seeming similarity in their functions. However, they are quite different in meanings and depend on each other. A little explanation of the two terms will aid your understanding of them.  I will start with testing.

What is testing?

Testing is the process or a way of determining that a software program is devoid of any error that may affect its efficiency. It is also done to find out whether a program performs according to the objective of building it. An effective testing can be done by changing the input of a program or run it on different platforms to see its response to these inputs and platforms. Sometimes, testing may reveal a huge flaw or bug that may influence the output of a program if not promptly corrected before its distribution to the many users who will subject the program to different conditions on a variety of platforms.

During testing, different techniques way be used. This includes providing both correct and incorrect inputs, intentionally wrong inputs, and other different inputs with the objective of assessing the response of the program to different situations. While testing a program using different data, the program may flag a bug that needs to be corrected. That raises the question “What is a bug?”

A bug is a programming error that affects the execution of a program. The program may not function properly or does not execute at all. Some of the bugs may be caused by the omission of a code or the use of a wrong one. In either way, the program will not execute in line with the objective of developing the program. The result of the execution may be at variance with the expected result. This brings about the concept of debugging.

What is debugging?

When an error or bug is detected in a program, it must be corrected. Otherwise, the objective of developing the program is defeated. Nobody will feel comfortable processing the payroll of his employers with a flawed program, neither will one trusted a program filled with errors for information on construction, lest people’s lives are put at risk.

The process of removing or correcting these errors is called debugging, derived from the word “bug.” Wikipedia defines debugging thus “Debugging is the process of finding and resolving of defects that prevent correct operation of computer software or a system.”

Debugging varies in the degree of complexity. There are some simple debugging such as a small program designed for in-house use and some other related programs. Due to the relatively short length of the program, the debugging done by a programmer will be relatively simple.

Contrary to this, the code for some big conglomerate like Facebook or Google will run to millions of lines of code. In this case, debugging may be complex and difficult because the debugger may need to trace the origin of all the bugs before correcting them.  Either way, debugging still remains an important part of a robust and well-functioning program.

How do programmers detect bugs? The answer is simple: through testing. As discussed above, one of the reasons for testing a program is to identify potential bugs that may impede the smooth execution of a program. When these bugs are detected during testing, the developer immediately takes over to correct all the errors, in another word, to debug the program.

Debugging can be strenuous and time-consuming. Each of the errors will be read and understood before debugging takes place. This requires much time and effort on the part of the programmer if he wants to be credit for a good job and meet the needs of the users.

There is this confusion when people have to make a distinction between Quality Assurance and Testing. Although they share some similarities, they have some distinctions which are hidden to most people. A discussion of these terms will throw a light on their differences.

What is Quality Assurance?

Quality Assurance is the general term used for activities that make sure that some procedures, processes, and standards are implemented in relation to the development of a software program and the intended use and requirements.

According to the respected technology website, “Software quality assurance (SQA) is a process that ensures that developed software meets and complies with defined or standardized quality specifications. SQA is an ongoing process within the software development life cycle (SDLC) that routinely checks the developed software to ensure it meets desired quality measures.”

The objective is to ensure the development of a software program that meets all the basic requirements that will qualify it as a high-quality software program. Rather than wait until when the program is completed before checking its potential for quality, quality assurance is done at every stage of the development in order to give the software a good foundation.

While developing a software program, the next stage of development will not be moved to until the present stage is tested and found to meet all the quality standards that are already defined. There are many methods that can be implemented to promote quality assurance. Some are CMMI model and ISO 9000 and some other standards. A proper quality assurance may require conforming to one or more of these techniques.

The complete Quality Assurance encompasses requirements definition, coding. Software design, source code control, software configuration management, code reviews, testing, product integration, and testing. The process is organized into commitments, goals, abilities, measurements, abilities, and verifications.

With the meticulous testing of each stage of the development against some tested and proven standards, the quality of the software is guaranteed.

What is software testing?

All the activities that are targeted towards the identification of defects, bugs, or errors in software are collectively known as software testing. Software testing is the execution of the software program with the aim of evaluating its performance in relation to the objective of developing the software. During the testing, the testers will check whether the software:

• Is designed in total conformity to its design and development.
• Is efficient when tested with a variety of inputs.
• Is effective in addition to its efficiency.
• Is usable under all the expected circumstances.
• Can be distributed to be used in different environments it was built for.

The testing is done by executing the software on different environments, intentionally changing the inputs, deliberate introduction of wrong inputs to see the response of the system, and other testing techniques.

The importance of software testing has been discovered many times. Bugs can alter the output of a system, leading to misinformation and unreliable results. During testing, bugs and other errors can easily be identified for correction. This will give a clue to the quality of the software under test and its potential for failure.

There are two types of testing. These are:

• Manual testing: This is done by humans and not a machine. No scripts or any other tools are used.
• Automated testing: This requires the use of scripts and other tools to test a software program.

Regardless of the testing method used, the same objective of finding errors and correcting them in a software program is achieved. This will help the developers to develop a bug-free and efficient software program before its distribution to the end users.

Testing remains an integral part of the success of a software project. These are obviously the two software testing methods. They share the same objective of helping the developers write a flawless program that meets the users of the users without hitches. However, there are some differences between the methods of operation of these different testing techniques. Let’s discuss them.

Manual software testing

The name of this testing technique says it all. The testing is done manually without the input of any testing machine, script, or tool. The developer(s) will manually go through the code to detect the bugs before debugging them.

This process is very time-consuming, especially if there is a huge amount of code lines to be manually searched for hidden bugs. It will take the debuggers some amount of time to identify an error, and this may become strenuous and boring to them.

Manual testing is the ideal testing method if the test case is expected to be repeated just once or twice or when embarking on UI testing. In each case, using automated testing will be too expensive. If regression testing is contemplated, manual testing will be inefficient in catching hidden defects if the requirements change frequently.

Another con of manual testing is that it is not an effective way of testing a program on many machines with different Operating Systems. In this case, each task has to be executed by different testers. This will be time-consuming as well as cost a lot to be implemented.

Automated testing

In opposition to manual testing, automated testing refers to the process of testing a system by using some tools, software, and scripts.  While humans take care of the manual testing, the input of human is removed here and scripts and other tools are given the liberty to take absolute control over the testing.

Some of the reasons why many software development companies prefer automated testing to manual testing include:

• Speed: This is definitely the first advantage of automated testing on the manual counterpart. While it will take days or weeks to fully test a program manually, automated testing will be through within a couple of hours. This saves time for the company. If the business lacks complex business rules, automated testing will be ideal in getting things done better and faster.
• Reliability: Manually testing a program exposes it to some minor human errors. A bug may be accidentally overlooked, leading to more problems in the long run. An automated testing will definitely spot such bugs and report them for correction. A great advantage too.

When testing is expected to be repetitive for a good number of times and manual testing is found inefficient, automated testing will adequately fill the vacuum. This testing method is also the best for if the company wants to perform regressions in testing, acts that will involve frequent code changes.

Testing a software program across different platforms may be impossible to be done manually. However, that can easily be done with automated testing. The testing technique can leverage its versatility to test the program across man platforms concurrently.

While these testing techniques may be useful in different circumstances, it is advisable that a software development company gets it right.  Making the wrong choice will lead to tons of unseen bugs that may impact negatively on the output of the program. If the right choice is made, it will spare them a lot of stress as bugs can easily be detected and corrected. This will lead to a better and more robust program that has a better success rate among users.