Future of Software Testing
His ears were ringing, his head throbbing with pain. As he came to his senses, he looked around the trashed cockpit, trying to locate a way out. He could not detect any movements behind him; probably the co-pilot was still knocked out by the crash, or even worse: dead. The ejection sequence had never initiated; after the hydraulic failure, the plane had simply not responded to any directives. A week later after he had been rescued from the crash site, the pilot learnt that the hydraulic failure had lead to the software failure, which had resulted in the crash. If the software had been tested more rigorously, the software would have switched to the backup hydraulic system, leading to a safe return of the air craft and its pilots.
It is common knowledge that most of our algorithms cannot be mathematically proven. During the development and once the software is designed, it is tested for most types of possible bugs, but not all of them. Re-creating all types of possible conditions and events is just not economically or technologically feasible. Thus software testing is one of the most important branches of computer programming, for one has to check the software of the appropriate number of tests, with which the software programmed, can be used without too much un-reliability for the end user. Software testing has evolved over the years from in-source testing to outsource testing. Currently a new testing phase is being deployed, known as crowd sourcing, which allows testers all over the world to test different softwares being developed on different platforms, multiple environments and on a wide range of hardware.
However this does not end here. Crowd sourcing may be far better than out sourcing in terms of number of testers being used and the types of environments it is tested on, but it is still not effective enough. The first problem it faces is the lack of information provided by the software about some of the errors. This becomes a big problem, as the bug in the software could lie anywhere in the code, and finding and fixing it becomes a technical and financial nightmare. To prevent such bugs, new development environments are predicted, which will interact with the developer; alerting about the possible bugs while developing and testing the software. A popular concept of such a visualization is the THUD, Testers Heads Up Display, which like in computer and console games will aid in presentation of information for the developer. Also, languages will have improved versions of exception handling functions, which will allow the bugs to be categorized more appropriately; they will tend to be specific for every method rather than being used for chunks of code.
Another problem with crowd sourcing is the amount of data sent by the tester to the developer. At times, the developer fixing the problem is just unable to reproduce the bug encountered by the tester. Such bugs may be marked as nopro and are usually neglected. To overcome this hurdle, the concept of virtualization models is being considered. Virtual environments will allow the end user to transfer the whole environment to the tester or developer, who can look straight into the problem without having to re-create it. It not only saves a lot of time and money, but also is very feasible for those bugs which are difficult to re-produce.
Then there is the problem of a collection of tests for a particular type of software or a piece of code. Every programmer or tester performs different tests on the software, but each one has his own library. Also, test cases are too dependent on specific test platforms or application and they require specific tools which other testers may not have. To correct these problems we require a common testing base, which can collect data and re-use it no matter what the application or the environment may be. To do this virtualization, again, provides a solution.
“Test cases will be written within virtual capsules that embed all the necessary environmental dependencies so that the test case can run on whatever machine you need it to run on.”
Indeed this will allow the testers to create a library for all the test cases, which can be applied on any piece of code written.
Software testing is becoming more important than ever. Software testers are gaining recognition and software testing has become a core branch in software development. Firms have started to realize that good software not only has to have functionality, but stability as well. Software testing is no longer a simple test at the end of the software development period; it has become software development.
Mashhood Ali Rastgar
University College London