Why did we need to validate and verify the product before shipping it to market?

https://www.geeksforgeeks.org/software-engineering-verification-and-validation/

Boehm (1983) questionably simplifies these, validation: are we building the right software ? and verification: are we building the right software “right”? The purpose of this article is to showcase the impact of software testing in the software development industry. As software developers, our perspective towards working software has failed us. Often than not this saying goes popular among developers that the software is working on my local development but seems not to work on production and as manager would always reply “we ain’t shipping your local system to the client”. The problem is that testing has been neglected and therefore for some developers, it does not exist in their dictionary. Douglas (2005) opined that testing aims to ascertain the validation and verification of a program The latter is to ensure no deviation from the development of the right system while the formal is to ensure the system meets the required specification. In addition, Sommerville (2016) explained software testing as when a program does what is expected to do and in doing this there were no errors.

Often than not this saying goes popular among developers that the software is working on my local development but seems not to work on production and as manager would always reply “we ain’t shipping your local system to the client”.

Software testing is an integral part of the software development life cycle (SDLC) to achieve quality delivery (Shivakumar, 2015), in other words, testing is done at every phase of SDLC (Sommerville, 2016). Software testing can be done either by manual or automation methods. Manual testing involves human testing the software with a set of inputs (test cases) and the corresponding desired outputs thereby providing the report of each test case as per falling or passing, on the other hand, automated testing mitigates the laborious processes that come with manual testing. Kumar & Mishra (2016) explain the process of using a set of tools or writing programs to debug a program. An automated way of testing has various advantages such as wide coverage of testing, speed the testing process, finding bugs easily, widely accepted, etc

Validation: Are we building the right product?

Verification: Are we building the right product “right” ?

However, Douglas (2005) explains that the testing processes target the errors (the mistakes the developers make in the program), the faults (the errors that cause the system to fail), and failures (the errors that cause the system not to perform the desired task) in a program. Software testing approaches are most functional (Sommerville, 2016), however, it is worth noting that every variable of a program cannot be tested. Kumar & Mishra (2016) explained that software testing is heuristic in nature as all and sundry cannot be tested. Generally speaking, testing is categorized into two; black box and white box testing, there is also grey box testing which is technically the duo of the two (Douglas, 2005; Kumar & Mishra, 2016)

Black box testing is the testing strategy based on user requirement and specification without the knowledge of the internal path, structure, and the implementation of Software Under Testing (SUT), example of such a strategy is an automated tool with prewritten test scripts accepting inputs and comparing the actual and expected output (Mayeda & Andrews, 2021). Additionally, Blackbox testing, also known as dynamic testing, is specifically targeted at functional requirements of a system and designed for behavioral operation of a system (Mansourov & Campara, 2011). Boehm (1983) justifies that black-box testing is used for validation (are we building the right software) and white box testing is used for verification (are we building the right software “right”). Nidhra, (2012) in his study further describes white box testing as structural testing or glass boxes that design the test cases based on the source code. White box testers are the developer of the code, furthermore, In white-box testing techniques, the selection of test cases is based on the implementation of source code (Nidhra, 2012).

As iterated above, testing is done on each phase of SDLC (Sommerville, 2016), but each has different objectives, the following are the testing spectrum we have (Nidhra, 2012);

1. Unit testing: Link (2003) argues that as useful as testing is, it cannot be done well on buggy applications. Research has shown that unit testing reduces defect rates and increases the high quality of code. In addition, unit testing is often performed by developers, which involves testing the granularity of code ranging from variables to classes (Nidhra, 2012).
2. Integration testing: Douglass (2016) simplifies integration testing as testing the integration of components and integration of subsystems. Nidhra (2012) further describes that Integration testing validates the workings of two or more units together.
3. System testing: Baresi & Pezzè (2006) explain in their study that integration testing does not give total assurance of a working system, therefore there is a need to validate and verify the working software against user specifications, hence system testing verifies the overall system against the user specifications.
4. Acceptance testing: Hughes (2013) describes user acceptance testing (UAT) as an operational readiness review of the software or program with the production support team in line with stakeholder specification. As McKnight (2014) clearly stated in his review that, one must be conscious and ready for any software that is ready for production, therefore UAT is a must.
5. Regression testing: Ba-quttayyan et al. (2018) in their study explain that regression testing is frequent maintenance to revalidate the modified software to curb breaking of software behavior due to changes made. Additionally, it was also noted by Rosero Miranda et al. (2016) research that in applying regression testing techniques, metrics like cost and fault detection efficiency are most relevant.
6. Alpha testing: Douglas (2005) describes Alpha testing as the first testing done once the product is developed with the support of developers. As stated by (Alpha Testing a Product — Explained, n.d.), the main purpose of alpha testing is to test the functionality of the product and note the necessary modification or improvement as well.
7. Beta testing: this is the final test before shipping the product to the client. Unlike Alpha testing which is carried out by developers, beta testing is mostly performed by users and considered as external user acceptance. As defined by (Alpha Testing Vs Beta Testing: What’s the Difference?, n.d.), it is a test performed by a “real user” of the software application in the “real environment”.
8. Functional testing: Generally speaking, this is a test performed on a finished product to ensure that the software behaves as it is expected.

In closing, the importance of testing cannot be overemphasized, Douglas (2005) supports the motion of early testing as it does not only increase security and performance, it also reduces cost. In addition, Sommerville (2016) describes software testing as a fail-fast approach in which error is fixed as it is caught. To further stress the importance of testing, as explained by (7 Reasons Why Software Testing Is Important, n.d.) testing software before shipping to market comes with so many advantages among which are not limited to saving money, boost security, increase product quality, increase the customer satisfaction and enhancing the development process.

References

7 Reasons Why Software Testing is Important. (n.d.). Retrieved August 15, 2021, from https://www.indiumsoftware.com/blog/why-software-testing/

Alpha Testing a Product — Explained. (n.d.). The Business Professor, LLC. Retrieved August 15, 2021, from https://thebusinessprofessor.com/business-management-amp-operations-strategy-entrepreneurship-amp-innovation/alpha-testing-the-product

Alpha Testing Vs Beta Testing: What’s the Difference? (n.d.). Retrieved August 15, 2021, from https://www.guru99.com/alpha-beta-testing-demystified.html

Ba-quttayyan, B., Haslina, H., & Baharom, F. (2018). Regression Testing Systematic Literature Review — A Preliminary Analysis. International Journal of Engineering and Technology, Vol 7, No 4.19 (2018), 418–424. https://doi.org/10.14419/ijet.v7i4.19.23176

Baresi, L., & Pezzè, M. (2006). An Introduction to Software Testing. Electronic Notes in Theoretical Computer Science, 148(1), 89–111. https://doi.org/10.1016/j.entcs.2005.12.014

Boehm, B. W. (1983). Seven basic principles of software engineering. Journal of Systems and Software, 3(1), 3–24. https://doi.org/10.1016/0164-1212(83)90003-1

Douglas, B. (2005, May). Software Engineering for Students, 4th Edition — [PDF Document]. Vdocuments.Mx. https://vdocuments.mx/software-engineering-for-students-4th-edition.html

Douglass, B. P. (Ed.). (2016). Front-matter. In Agile Systems Engineering (pp. i–iii). Morgan Kaufmann. https://doi.org/10.1016/B978-0-12-802120-0.00011-4

Hughes, R. (2013). Chapter 2 — Iterative Development in a Nutshell. In R. Hughes (Ed.), Agile Data Warehousing Project Management (pp. 33–79). Morgan Kaufmann. https://doi.org/10.1016/B978-0-12-396463-2.00002-8

Kumar, D., & Mishra, K. K. (2016). The Impacts of Test Automation on Software’s Cost, Quality and Time to Market. Procedia Computer Science, 79, 8–15. https://doi.org/10.1016/j.procs.2016.03.003

Link, J. (Ed.). (2003). Front Matter. In Unit Testing in Java (p. iii). Morgan Kaufmann. https://doi.org/10.1016/B978-1-55860-868-9.50023-7

Mansourov, N., & Campara, D. (Eds.). (2011). Front matter. In System Assurance (pp. i–ii). Morgan Kaufmann. https://doi.org/10.1016/B978-0-12-381414-2.00017-8

Mayeda, M., & Andrews, A. (2021). Evaluating software testing techniques: A systematic mapping study. In Advances in Computers (Vol. 123, pp. 41–114). Elsevier. https://doi.org/10.1016/bs.adcom.2021.01.002

McKnight, W. (2014). Chapter Seventeen — Organizational Change Management: The Soft Stuff is the Hard Stuff. In W. McKnight (Ed.), Information Management (pp. 179–188). Morgan Kaufmann. https://doi.org/10.1016/B978-0-12-408056-0.00017-5

Nidhra, S. (2012). Black Box and White Box Testing Techniques — A Literature Review. International Journal of Embedded Systems and Applications, 2(2), 29–50. https://doi.org/10.5121/ijesa.2012.2204

Rosero Miranda, R., Gómez, O. S., & Rodriguez, G. (2016). 15 Years of Software Regression Testing Techniques — A Survey. International Journal of Software Engineering and Knowledge Engineering, 26, 675–689. https://doi.org/10.1142/S0218194016300013

Shivakumar, S. K. (2015). 2 — Ensuring High Availability for Your Enterprise Web Applications. In S. K. Shivakumar (Ed.), Architecting High Performing, Scalable and Available Enterprise Web Applications (pp. 59–99). Morgan Kaufmann. https://doi.org/10.1016/B978-0-12-802258-0.00002-0

Sommerville, I. (2016). Software engineering. http://www.dawsonera.com/depp/reader/protected/external/AbstractView/S9781292096148