Software bugs mean those mistakes made by a developer during the life cycle of developing software, as a result, to fix those bugs will be an effect on the developers’ time and on the cost of software. By reducing software bugs would give the developers to spend more time to add new features and enhance the software.
The primary requirement for an end-user and software developer is software quality to be error-free. It seems that it is impossible to have software free bugs. However, this essay will examine the possibility of software free bugs and will compare the techniques methods used to help software be free bugs.
2. Bug life cycles
This section will demonstrate the benefit of studying the life cycle of bugs, and methods to help in decrease the cost of bugs.
2.1 History of software bugs
According to Davies (2014), software bugs as defined by The Institute of Electrical and Electronics Engineer (IEEE) is an issue in software are not fixed can cause in the incorrect outcome or fail in an application. Furthermore, the meaning of software bugs is still vague, there are many questions about the origin of a bug, how an end-user tread if he faces bugs in a software. However, the most important question is how to prevent or deal with them. There are many tools such as Bugzilla to help the developers to track the bugs in released software have been detected by end-user (Davies, 2014).
2.2 Bug tracking systems
The most effective role in bug life cycle is Bug Tracking Systems (BTSs), they are used to provide feedback on the system by developers and end-user, the feedback may be informed as an incorrect case or as a requirement to improve the system (Pinzger, M. et al.,2009).
The feedback/bugs are recorded in a BTSs such as Bugzilla allow bug reporters (developers and end users) to report details of errors/bugs encountered while using an application (Davies, 2014). A real example of a bug shown in figure 1 from Mozilla the most common internet browser, the report includes a full explanation of a bug, specific information such as a piece of code and screenshots to guide the developer, all previous information is collected together in a bug report.
The benefit of the bug report is to guide the developer to fix the bugs using a useful information form the report. However, the information provided by bug report is not enough to fix the bug or determined the reason for the bug (Davies, 2014). As a result, the bug report is to help the developer to fix the bug and at the same time, can be stored as records to provide last update and the status of the bug to the reporter.
According to Davies (2014) the bug report life cycle has a number of steps it depends on the BTS, figure 2 demonstrates the default stages of Bugzilla. The first step is an Unconfirmed status that created by a user during reporting about a bug, the decision back to the developer to decide to be Confirmed and send it to the next phase or the bug does exist, after the bug has been confirmed will be assigned to a specific developer to investigate and fix the bug and change the status to In Progress, if the developer has finished fixing the bug the status will be Resolved, the final stages is to check and test the bug by a quality engineer and confirm that the bug has been ixed correctly then the status will be changed to Verified.
The steps of the bug report life cycle provide more information about the bug and which techniques should be used to fix the bug by the developer.
There are two popular techniques in Software Development life cycle used to test the software by tester and developer.
Sawant, el at. (2013, p.981) indicate that static testing or manual testing is a type of test which can be done by a set of tools or manually without executing the code to check the design and requirement documents to review it on the working document by the analyst and the testing team. When the system is inactive, the statics test executes security test to analyze the system without running the code. The static testing technique provides the developer the bug places in the application code on the early step of the life cycle. Static testing work with documents such as design, source code, and test plans documents. The static testing technique content many steps. First, inspection is one type of reviewing the code to find the defects using the checklist, code walkthroughs are managed by the moderator. Second, a walkthrough is meeting with the software users to describe the product, at the same time participants can ask questions as notes. Another step, technical reviews to check the code if is identical to the technical specifications and standards. The final step, informal reviews to review the documents and comments on it using informal methods.
Sawant, el at. (2013) indicate that dynamic testing or automated testing is executed while the software in active status or runtime. For example, the code executed same time of input the value, the output will be compared with the final result. The example shows the functional behavior of the application, during the runtime of the application it is possible to check the system performance and the quality of the application. There are two types of dynamic testing, functional testing, and nonfunctional testing. The dynamics techniques types are as the following. First, unit testing is the tool to test the code for individual modules. Second, integration testing is to test the join between the interfaces and the modules. Also, system testing is to test the whole application performance. The last one, acceptance testing is testing was done by the end-user.
Nevertheless, both of the testing techniques dynamics and static are important for the Software Development life cycle. Sawant, et at., (2013) claims that both techniques have strong and weak points, which should be considered while executing these techniques on the application
Sawant, et at., (2013) demonstrate that the difference between both techniques that static technique is white box testing which is the first step on the software life cycle and it is effectively more than dynamic techniques, while the dynamic technique is the last step on the software life cycle. On the other hand, the static technique performs before execute the application whereas, the dynamic technique performed at the same time of the runtime. For example, online e-learning website with the static technique should go with the following steps: Review the documents, check the interfaces of the software and check the database tables.
This article has examined the history of software bugs and the methods of tracking bugs. At the same time, discuss the static and the dynamic techniques with comparing between both of the techniques. Also, discuss the possibility of having free bugs software. Unfortunately, it seems that impossible to have free bugs software. However, the strategies and techniques of testing software is a significant requirement to enhance the development life cycle (Thakare, S. el at.,2012, p.686). Meanwhile, there are several methods to reduce software bugs, and many ways to solve it.
- Davies, S., 2014, STUDYING THE LIVES OF SOFTWARE BUGS [Online] Glasgow, University of Strathclyde Glasgow. Available from: http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.632701 [Accessed 15/11/2017].
- Sawant, A. A. et at.,2012, Software Testing Techniques and Strategies [Online] Mumbai, University of Mumbai, INDIA. Available from: http://www.ijera.com/papers/Vol2_issue3/FQ23980986.pdf [Accessed 22/11/2017].
- Pinzger, M. et al.,2009, "A Bug's Life" Visualizing a Bug Database [Online] Glasgow, University of Lugano, Switzerland and University of Zurich, Switzerland. Available from: https://serg.aau.at/pub/MartinPinzger/Publications/Dambros2007-bugslife.pdf [Accessed 15/11/2017].
- Thakare, S. el at., 2012, International Journal of Emerging Technology and Advanced Engineering [Online] Mumbai, Computer Technology Department, India. Available from: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.413.8479&rep=rep1&type=pdf [Accessed 15/11/2017].
Note: you may face some mistakes with sentence structures.