Article & Observations About Diverse Teams Working Better Together
According to “The Art of Software Testing” by Glenford J. Myers, 2nd Edition, 1979, “Software testing is a technical task, but it also involves some important considerations of economics and human psychology.” This is a classic textbook for software testing techniques, and it is amazing to see how much has stayed the same since that time.
The whole goal of software testing is to find bugs before your customers find them. Software bugs reflect poorly on your website or application.
Table of Contents
- What is Software Testing
- How Does Software Testing Work?
- What Is a Software Bug?
- Different Types of Software Testing
- Common Terms: Types of Testing
- Types of Software Testing
- Agile Software Testing Strategy
- Agile Software Testing Is an Important Part of the Development Cycle
- Do I Need Software Testers?
- What Kind of Training Do Software Testers Need?
- Software Testing Best Practices
- Software Testing Resources
- Software Testing Training Resources
- Software Training Books on Amazon
- Frequently Asked Questions
The Psychology of software testing is related to the idea of wanting to find software defects. It is much better for you to find a bug rather than your customers.
Our training program for software testing specifically teaches that it is good to find a bug, because new software testers are often disappointed when a defect is found. A good day for a software tester is to find a bug.
The Economics of software testing is related to how software testing can actually reduce the cost of software development. This can be counter-intuitive, but it makes sense when you remember that software testers are generally less expensive than developers. It can also be very costly to redesign software at the end of a project if a significant bug is found that requires significant development to fix.
This is related to the “Test Left” paradigm in which the software testing should occur as early in a timeline as possible, as discussed in the Agile Software Testing Strategy section.
Example: What is Software Testing?
A software bug is simply a difference between an expected result and what actually happens when the software is tested. The Expected Result can come from a list of software requirements, or more often it comes from the expected behavior for an app that follows best practices.
For example, it is best for buttons to be labeled consistently, respond quickly, give feedback that an action was taken, etc. If your app differs from a typical app, then users will find the software confusing.
Example Bug: The Mother and Father data entries were stored in the wrong fields
There are many types of software testing. For example, Unit Testing is normally completed by developers as they add Unit Tests to their own code so that a set of expected results are verified for a set of test cases.
A simple example would be to verify that a function that adds numbers would verify that 2+2=4. Technically, this is part of Test Driven Development (TDD), which is more of a development team activity than a Quality Assurance Software Testing activity.
Therefore, many people think of software testing as User Acceptance Testing (UAT) or Software Acceptance Testing (SAT). This is considered as “final” testing at the end of a software project to do a final validation or verification (V&V). This is an important activity, but it is better and more economical to follow an Agile Software Testing Strategy as discussed in a later section.
Agile refers to a project management strategy often applied to software development projects. For our purpose, a simplified way of thinking about this is to emphasize that each part of the software should be tested at the time they are developed rather than waiting until the end of the project. Good Agile testing can be lower cost and much lower risk than the “Waterfall” strategy of waiting until the end of a project to perform the testing.
For example, assume that a project takes 6 months to complete. A development sprint could be completed every 2 weeks by several developers. Perhaps one day of software testing is done for each of these 2 weeks. This ensures that the features are actually working well and there are no regression bugs.
The alternative is to wait until the end of the project, and spend perhaps 2 weeks testing, find bugs, and then need to spend another 2 weeks or so to fix those bugs.
That can delay the release of the software product by a month, or you may need to compromise the quality of the software to meet your deadline.
Some people mistakenly think that the Test Driven Development completed by the developers are sufficient to make sure that everything is working. This needs to be balanced with manual testing to perform Integration Testing to see how the software works with all of the components completed.
Short answer is “Usually.” Let’s go through a few scenarios to consider.
If you are creating a relatively simple website, then perhaps not.
If you are creating a responsive website suitable for desktop and mobile browsers perhaps with some animation elements, then yes.
But won’t your web developer test the site? Of course, but it is often beneficial to have trained software testers also test the site. At Iterators, we have a device farm with different mobile devices, we test different browsers, window sizes to test the responsive break points, check the animations.
We always find issues, such as images that do not display correctly on certain window sizes, or animations that are not compatible with some browsers. It is more economical to hire a well-qualified software tester than to expect your developer to spend extra time testing all of these configurations.
What if you are developing a mobile app? The answer is definitely Yes!!
In fact, it is best to test with the Agile strategy of testing new features every Sprint, which could be every week or two. Iterators has had a few customers that have had their apps fail when tested at the very end. One customer had a “guarantee” by the developer to fix all problems that were found in the last 3 weeks of testing. After multiple rounds of testing, the app was still not functional, and the app was abandoned. Reduce your risk and your overall costs by performing testing during development.
It is again more cost effective to have testers test and developers develop. The other approach is for the client to test the app, because “we all use apps.”
However, there is a great benefit to using trained software testers to find those examples that your end users will end up complaining about on the launch of your app.
At Iterators, we have a custom training program that incorporates several useful components. We include the ISTQB Foundation Level training for software testers. This has several valuable techniques for software testing and some specialized terminology.
We also find the exploratory testing approach useful. A good introduction to this it is the Explore It! Book by Elisabeth Hendrickson.
Many people feel that software testing means writing extensive Test Cases. However, the real goal is to find bugs. Iterators uses an exploratory approach with enough structure to make sure that all areas are examined.
The advantage of exploratory testing is to allow an experienced tester to find the best areas to test. For example, if defects are found in a certain area, then it needs even more testing. Finally, we include a good amount of practical examples because there is no substitute for actual experience.
The most significant best practice is to make sure the software testers are included in your project. Some developers will include QA software testers on their team, and some are more individual contributors. The key thing to remember is that the Product Owner is responsible for the overall product quality and should decide on the strategy for software testing.
Iterators can provide an independent view of the testing needs. We have had some developers state “it should only take 50 hours to test at the end of a project.” These same projects have then had to scramble to get functioning software to deliver.
There are many software testing resources available on the internet. Here are some of the Top 10 links for software testing in different categories. There may not be 10 in each category, but they are all good resources.
David Willcox graduated with a Bachelor of Science from Tulsa University having double majored in Chemical Engineering and Mathematics. He earned his doctorate in Chemical Engineering from Northwestern University. He has a broad background in education, industry and software testing. David has written software for 40 years, starting with BASIC, which was originally stored on yellow punch tape. Since that time, David has expanded his skills and is proficient in Assembly Language, Pascal, C, Objective-C, Visual Basic, C#, LabVIEW.NET, Python, R, HTML and JAVA.
Internet Explorer (IE) 11 is the last major version of Internet Explorer. Starting Jun...
We Can Help YouContact Us
Iterators LLC is Certified Women-Owned Small Business (WOSB) and Women’s Business Enterprise National Council WBENC-Certified WBE