Stakeholders of the software industry - Research Paper Example

? WEEK 5 Technical Essay/Technical Essay-Software Testing By Michael Foweraker Technical Essay-Software-Testing Michael Foweraker Florida Institute of Technology Management of Software Systems MGT 5150 Sonnenberg, Christine September 26, 2013 Introduction Like in any other industry, stakeholders of the software industry require that they are constantly fed with information on the various products in the market. Conspicuously, information on the quality of software products is the most sought by consumers. It is imperative that developers of software products disseminate this information not only in a timely manner but also ensure that the information publicized is accurate and detailed (Myers, 1999). To obtain this information about a product’s quality, design, requirements, and implementation, it is important that developers of software products carry out different tests at the various phases of their production line. Such testing processes not only give information on the quality of a product but also enable an independent and unprejudiced view of a product not only by its developers but also by its users (Myers, 1999). In addition, the developer of software product may have the opportunity to appreciate and understand the risks of the design, development, and execution software (Myers, 1999). Contrary to common belief among laymen, software testing extends beyond tests done to ascertain whether a product can be executed or applied and testing to identify or discover bugs; it encompasses all the processes by which software is validated and verified. In addition, software testing seeks to establish whether a product has adhered to the design and development requirements and can be effectively executed with similar features. What is more, software testing seeks to establish whether the needs of all stakeholders have been achieved in a product (Willison, 2004). One fundamental facet of software testing is that it can be done at any stage of the development and implementation of software, depending on the type of testing advised or adopted. This paper explores the notion that software testing is used to show that software functions properly. More precisely, the paper discusses the use of software testing to prevent and/or eliminate faults associated with requirements, design, analysis, and implementation. Software Testing for Prevention of Faults Recent times have realized an increase in the popularity of software testing in the software development industry. Software testing in the software industry entails not only the activities in the development cycle of software but also beyond. The importance of software testing is best highlighted by the fact that quite many users have experiences of software not working as expected. Evidently, faulty software has quite huge impacts on organisations. Among the consequences of software that do not work include financial losses, time losses, damage to business reputation, injury or death for safety-critical systems (Willison, 2004). The first way by which faulty software may result in financial loss is due to non-compliance to legal requirements. Regrettably, the testing phase of software development is never accorded the seriousness it deserves from software developers and managers. This situation exists despite the fact that testing is the only way to ascertain whether an application is likely to function properly after it is deployed to the market. Due to its importance in ensuring a product is correct, there are several recommended approaches to and reasons for software testing (Willison, 2004). Although it gets a little attention, software testing remains a rather integral and important phase of any project on software development. That is, it is only via software testing that a developer may ascertain whether a software project or product is poised to succeed in the market or is doomed (Willison, 2004). It is important that software developers must have an approach that focuses on functional testing, characterized by the verification of whether software application conforms to established specifications and executes all required tasks correctly. Prior to exploring the role of software testing in preventing requirement, design, analysis, and implementation faults, it is worth noting that software testing may certainly not entirely identify all faults in software products. On the contrary, software tests mainly seek to form a foundation for criticism of a product and compare its functions and parts with the set principles of specified requirements, thus assisting in the timely identification of defects (Hambling et al., 2010). The aspects of software products targeted during tests are contracts, specifications, compatible and comparable versions, implications on intended use, compliance with user expectations, and adherence to local and international standards and laws (Hambling et al., 2010). Primarily, software testing aims at the timely detection and correction of faults related to design, quality, analysis, and implementation. Software testing entails assessment and execution of codes under different conditions. Different software testing approaches are used in modern software industry with many developers engaging specialists and entire departments for testing duties. There are several causes of software faults that are targeted in software testing. The most critical among these causes of software faults are coding errors by software design personnel. However, defects and failures are the other major causes of software faults. Under defects fall requirements gaps in meeting as the main factors (Hambling et al., 2010). For an illustration, much software suffers unrecognized requirements that result in designer-oriented omission errors. Topping the list of the requirement gap problems faced in the software industry are those associated with maintainability, usability, testability, scalability, performance, and security. Thus, programmer errors and mistakes that result in bugs and faults are the main causes of software faults. The consequences of these mistakes are failures or wrong program outputs for given inputs. That many developers test their software under combined conditions also make their products prone to failure since in cases where there are many defects, it may be difficult to detect the less frequent faults. The common types of testing used in the software industry are regression testing, destructive testing, compatibility testing, usability, availability, security, functional and non-functional, software performance, and advancement testing (Hambling et al., 2010). It is now evident that testing of software is a rather integral part of and a continuous activity in the software process, implying it should be carried out throughout the lifespan of software. That is, the entire software process should be punctuated with software testing (Schach, 2002). Thus, testing of software should be done at different phases of software development, use, and maintenance. At the workflow phases of requirements and analysis, the requirements and specifications must be checked, respectively. Similarly, it would be a dangerous practice if software checks and tests are not done at software production, management, and planning stages. The other critical phases of software process that require testing are design workflow and implementation workflow (Kaner et al., 1999). As a matter of fact, that each code artifact of software has been tested does not imply that the final and whole product can pass the testing phase. Additionally, once the acceptance testing is done and passed, software should still get tested during installation and during its maintenance, long after software products are delivered to the market and consumers. Similarly, modified versions of software should also be accompanied by thorough testing. Schach (2002) recommends that software testing should not only be done at the end of workflow; rather, testing should start at the design stage. Software design and development teams should constantly and painstakingly check, test, design, and develop software at the same time. According to Schach (2002), as is the case with other authors, the core reason software testing is done is to ensure that software products operate smoothly. Moreover, testing helps in preventing faults in requirements, analysis, design, and implementation phases of software process. The two main component of testing are verification, which is implemented at the end of each workflow to ensure everything has been done correctly and validation, done at the end of production just before a product is sent to the market (Eushiuan, 1999). In essence, validation ensures that software products have met the intended specifications (Eushiuan, 1999). Importance of Software Testing Quality is one reason for carrying out testing on software. Quality in software products is mainly compromised factors related to human mistakes that cause faults in a product (Schach, 2002). While one mistake may result in several forms of quality breaches, several mistakes may also result in one type of fault. Professional mistakes thus result in errors, the extent of a fault in software products. In software engineering, quality refers to adherence to specifications, and not excellence, as is often perceived (Schach, 2002). Thus, testing ensures that every software product that leaves the production line meets the specifications or formula expected. In addition, software testing ensures that a product is not compromised during maintenance. Software product must therefore be tested and ascertained to be well designed and methodically coded (Schach, 2002). It is for quality reasons that software quality assurance practices are developed and encouraged. That is, SQA’s key role is to ensure a developed software product is correct and that the proper workflow was used. The use of software testing to prevent quality, design, analysis, and implementation faults is highlighted by the integral and important role of the Software Quality Assurance (SQA) (Meyer, 2008). In fact, in many organizations, software testing falls under SQA operations. Thus, the SQA department hires specialists whose focus area I software development process; not merely codes and systems documentation. SQA personnel have the mandate to scrutinize and modify software engineering processes so that risks of faults occurring are reduced (Meyer, 2008). In other terms, the SQA department checks and maintains the defect rate to a minimum level. However, unlike the testing process whose goal is to detect software defects in by comparing the anticipated outcomes with the actual ones, quality assurance deals with policies implementation and the procedures of preventing defects from occurring (Meyer, 2008). From this discussion, the connection among software testing, quality assurance and quality faults is quite clear. Product use or implementation is the other area targeted by software testing. Some professionals believe that whereas testing may be useful in confirming the presence of a fault but could be inadequate in ascertaining its absence (Jiantao, 1999). For this reason, execution-based testing is highly recommended for software products. Such a test would go a long way in ensuring implementation faults are minimized or entirely eliminated. For example, if test data is used on a product, which then yields incorrect output, the implication is that there are implementation faults in the product (Jiantao, 1999). Meticulous execution-based testing is also found to be quite helpful in preventing implementation faults. A working model environment for the product, a simulator, is always used for implementation testing. Software testing also prevents faults related to utility and reliability. While utility refers to the degree to which a product meets its user’s needs, reliability measures the criticality and the regularity with which a product fails to perform its functions and give output (Schach, 2002). Robustness, correctness, and performance are the other key aspects of software products that require testing to help prevent analysis, quality, implementation, designs, and requirement culpabilities. Schach (2002) recommends that software testing should only stop when a product has lost its usefulness, has been overtaken by time and technological advances, and has been replaced by a better product. Only withdrawn and permanently discarded software should not be tested any further (Schach, 2002). Conclusion The software industry is currently expanding at a rather fast rate. However, the growth would not have been realized were it not for the efforts of the testing and quality assurance departments and personnel in the industry. The core function of software testing is to reduce the likelihood of faults being detected while software is being developed or is already in the hands of consumers. Currently, software testing has become integral to all types of workflow in software development, be it design, analysis, or requirement workflow. Consequently, SQA and testing processes such as regression testing, destructive testing, compatibility testing, functional and non-functional testing, software performance testing, usability testing, accessibility are really essential in ensuring that defects are detected and corrected at the right time. Some of the aspects of software that are tested include steadfastness, performance, efficacy, safety, and purpose. Essentially, software testing helps prevent faults related to product design, analysis, quality, and implementation. It is important to note that software testing is an integral and continuous process that should only stop when a product has been replaced by a better one, decommissioned, and discarded from the market. References Eushiuan, T. (1999). Verification, validation, and certification". In Koopman, P. Topics in dependable embedded systems. USA: Carnegie Mellon University. Hambling, B., Morgan, P., Samaroo, A., Thompson, G., and Williams, P. (2010). Software testing: An ISTQB-ISEB foundation guide. BCS Learning and Development Ltd. Jiantao, P. (1999). "Software Testing (18-849b Dependable Embedded Systems)". Topics in Dependable Embedded Systems.” Retrieved on September 24, 2013 from http://www.ece.cmu.edu/~koopman/des_s99/sw_testing/ Kaner, C., Falk, J., and Nguyen, H. (1999). Testing computer software, second edition. New York: John Wiley and Sons, Inc. Meyer, B. (2008). "Seven Principles of Software Testing." Computer, 41(8): 101. Myers, G. J. (1999). The art of software testing. John Wiley and Sons. Schach, S. R. (2002). Object oriented and classical software engineering, eighth edition. McGraw-Hill. Willison, J. S. (2004). “Agile Software Development for an Agile Force.” The Journal of Defense Software Engineering, April Issue. Retrieved on September 24, 2013 from http://www.stsc.hill.af.mil/crosstalk/2004/04/0404willison.html Read More