Do you know what software programmers dread the most? Testing.
Have you ever encountered a situation where the software you’re using - regardless of whether it’s on the computer, your smartphone or your tablet - didn’t quite give you the result it expected?
Sometimes it’s plain wrong, sometimes just bizarre and sometimes just in a state where stubbornly refuses to give you a response. We’d be surprised if you haven’t, as almost every software ever created has had bugs, errors and defects built into it. Not on purpose, but simply because of the monumental task it is to create 100% perfect quality software.
You could even go so far as to say that quality software isn’t that which is without bugs and errors, it’s that which has the least bugs and errors.
Technically speaking, software quality is the degree to which a software’s performance and features meets the expectations. In other words, is it doing what it’s supposed to do, and does it ever act funny?
In practice, it covers multiple elements, such as design and interface, reliability, reusability, consistency of output and of course, functionality. The better these qualities show themselves in the execution of the software’s operations, the better the software quality.
A software may pass off as satisfactory by providing the right results, regardless of the testing or development model, even if it lacks in the design and durability department. But if defects prevent correct computation, then the software is worth nothing at all. However pretty it might be, you wouldn’t use a calculator that calculated 1 + 1 to be 3, would you?
It then becomes necessary to take software through a stringent quality testing process to ensure that it’s doing it’s job. That’s what we’ll be taking you through today.
Good software is a lot of things. What it definitely isn’t is simply the correct execution of its tasks.
According to Virginia Tech, there are 6 qualities that are a sign of good software.
Specific testing methods can help a developer make sure that each of the requirements are met under various circumstances of use. It has to also be capable of being easily maintained (“maintainability”). What if your client requires a moderate change to the program? An amateur software developer would rewrite the whole program; a good one would have accounted for such a possibility and allowed for modular changes that enable new requirements to fit in snugly with the old program.
“Reliability” and “Reusability” come next. No software is technically 100% reliable, but the aim for a high degree of reliability should always be present. If, under regular operating circumstances, a software fails, and fails often, it is said to be unreliable. In some cases, such as in air traffic control, a minor drop in reliability can have severe consequences. It work hand in hand with correctness and maintainability. Reusability is self-explanatory: can your software be used again, for some other purpose? Has it been designed in such a way that some of its functions may be transmitted to other programs with common requirements, thereby saving you time?
“Portability” is another feature that simply measures how well your software can be used on a wide variety of systems. There are a large variety of computer systems which clients often deal with and you’ll want to be certain that it can run on as many of them as possible. “Efficiency” measures how optimized your program is, in terms of computer resource. Efficient software uses as little as possible, giving your client a better experience overall.
Believe or not, money is one of the biggest consequences of poor software. The enormous time spent in debugging poorly written code results in hundreds of billions of dollars of lost revenue, as discovered by Cambridge University.
Lost time is another result. Clients are stubborn about their requirements, and when you deliver code that is imperfect or downright wrong, they expect it to be corrected - as they should. You’ll only end up wasting more time correcting something that could have been written properly the first time around.
There are far darker consequences as well, depending on the purpose of the software. Stock market crashes and airline delays have been known to have been affected by software bugs. Thousands of people can be stranded halfway across the world, many companies and vested stakeholders lose enormous sums of money because of overlooked errors in the original program. Heaven forbid there being errors in a hospital’s software program.
Broadly speaking, there are three different kinds of faults with software: errors, defects called bugs or faults and failure, according to SoftwareTestingBooks. The first is when the programmer makes a mistake that results in incorrect output. The second when there is some internal mismatch or conflict in a component or series of components of the software that prevents the function from being carried out. The last is when the program simply does not provide the correct result.
It is the defects that are hardest to deal with as they require a close examination of the code.
Test. Test. Test.
And there all kinds of tests. They can be divided into two categories, let’s call them strategic and tactical. Tests that are strategic are automated, manual, exploratory tests, while the tactics used to perform the tests are unit, integration and functional, according to Atlassian.
You can check individual components of the software with unit tests, a subsystem of the program with integration tests and the whole end-to-end process of use with functional tests. These let you narrow down the problem areas.
Computers can be programmed to check the repetitive aspects of the software for correctness, while manual tests are used to check aspects of the software output that usually involve the customer experience. Exploratory testing is like field testing: you get a group of people who broadly represent your software target audience, and give them guidelines to check if it’s working. Essentially, you’re testing the software as if it’s “out there”, though with some supervision, according to Atlassian.
Watch the open lecture on software testing by Professor James Bach (video below). It’s a fantastically entertaining and informative watch that takes you through the whole of software testing.
Software is a quite complex endeavour, though also extremely interesting. At any rate, it is vital if you want to deliver good software and develop a good reputation. You can’t skimp on it!
Software testing is one of the vital phases of software development since some mistakes might be too costly. Projects developing totally new software are commonly challenged with doubts concerning software requirements as well as realization tools.
As a professional software developer, you spend most of your time working with clients that have very limited knowledge about programming, and most of the time, they cannot fully explain what they actually want you to develop.
This little misunderstanding can cause big troubles. In such cases, it is of utmost importance to constantly communicate and gather information from the customer.
If that happens to you, we recommend you to apply the iterative and incremental software development approach (IID) as it allows swift response to alterations, unlike historical methodologies, such as the waterfall model.
Therefore, I decided to provide you with some valuable information about the Iterative-Incremental Development model throughout this article.
Defining Interactive-Incremental Development According to Mockus and Herbsleb (2011) Iterative-Incremental Development is one of the methods of Agile software development, extreme programming and rational integrated procedure.
Iterative-incremental model is an approach of software development, which is formed around a steady enhancement in component additions along with a cyclic releases and pattern upgrading.
It starts with planning and carried out through iterative progression cycles that consist of constant customer response and the incremental computation of extra features, finished with the utilization of completed software before moving onto the next cycle (Larman, 2003).
In short, Incremental is a process of adding new components in small pieces whereas the iterative is a process of acting upon the project repetitively, for example, adding new components in cyclic way.
You first have to identify the software requirements, analyze them, and based on your analysis, you design the software and start coding to develop the designed model. Once you are finished, you conduct with the customer, gather feedback and move onto the next software product increment phase or cycle, where you repeat the steps you took at first cycle, but this time you take those steps based on the freshly gathered feedback and information.
The cycle continuous until the end product is perfectly delivered (Larman, 2003).
The perfect examples of iterative-incremental software development approach can be:
The Pros and Cons of Applying Iterative-Incremental Development Let’s be real. There is no perfect approach to software development and as all the other application development models, the iterative-incremental software development model also has its pros and cons.
Let’s take a look at the advantages that IID offers:
Even though the advantages sound good, a professional programmer should be aware of the following disadvantages of IID:
The Iterative-Incremental Approach is a great software development method, however, a good programmer should know when to actually apply this approach in practice.
If you are completely new to this approach, here are the suggested occasions when you can actually apply this method in your project:
Thus, the product can only be perfectly delivered until going on different cycles of development. Throughout this article, we tried to characterize one of the popular software development methods that widely used in practice nowadays.
Moreover, we decided to include this video tutorial that can help you learn more about Iterative-Incremental Software Development Method:
In this video, the author explains IID approach cycles in great detail.
a constant communication is a fundamental necessity for successful realization of Iterative-Incremental Development method. Particularly uncertainties in the form of shifting requirements may require more communication between the software engineer and client for better understanding and problem solving (Larman, 2003).
Within indecisive working conditions, short iteration phases are required to disclose issues as early as possible. If the iteration cycle is longer, the importance of the communication can be vital for integration part. Without a proper communication and understanding between the parties, it is impossible to successfully implement IID.
What is web testing? This is the practice of looking thoroughly over a web application for errors before it is made public for use. The main reason is to find defects that can negatively impact the website in future. This process can also be used as a platform for finding areas to improve to produce better results from the application.
Generally, there are many ways to perform web testing. Testing ensures that the scope, security, and functionality of the web are correctly working. The following are the basic tests performed for a website before it is launched: functionality testing, usability testing, interface testing, compatibility testing, performance testing and finally security testing.
Let’s have a look at each of them:
Software engineers call it “functional testing” also known as “functionality testing”. Basically ensuring all components work right.
This testing involves verifying that the web application works according to its documentation and specifications. This is generally ensuring that the forms work properly, links among homepages, connection with the database, and the user interface etc. works well according to its intended purpose.
These tests are documented in the test scripts, which test the functionality and specs. This test includes activities such as identifying the expected web functions, data sets, e.g. a drop down list of pre-defined values, data input and the output.
This is one of the most often asked questions in software testing classes and testing-related google searches as newcomers in the testing business are surrounded by confusion regarding the terminology.
Testing is a crucial part of any software development project as it ensures the project has no serious flaws or bugs that will later take a lot of resources and time to fix. But before any testing begins there are two documents that need to be drafted and approved: the test strategy and the test plan.
To be able to understand the difference between them one must first know what these documents mean and what they are useful for.
This is a document developed by the Test Manager and is a high-level document. It defines the approach the team will have in achieving the testing objectives. It derives from the Business Requirements document and it sets the standards for the testing processes and activities. As appose to an actual testing model, such as The Waterfall, this is the high level strategy.
The Test strategy includes the following:
Scope and objectives–the test strategy defines the business objectives and the test scope;
Business issues – the budget of the project, the amount of time allocated for testing, the resources needed and other parameters such as these are defined and set before the testing begins.
Testing approach–the document establishes what type of testing will be carried out (performance, functional, stress, load) and if the testing will be done automatically or only manually.
Test deliverables – will list the documents needed from the testing team and also the method they’ll use for testing record keeping.
Defect tracking approach–the test strategy defines the tools the team will use to keep track of the defects and the data flow between the testing and the development teams.
Training –this is especially important if new tools are introduced in the project. The test strategy also defines the type of training that’s needed and the person or entity in charge of delivering them.
Other relevant information – testing measurements and metrics, change and configuration management, risk management, automation information, if it’s being used.
In smaller projects, the test strategy is just a section of the test plan as it’s not practical to separate the two. According to differencebetween, in large companies with many projects, there is usually one test strategy and a lot of test plans, typically one plan for every major component.
According to getzephyr.com, The test plan focuses on describing what, how and when to test. The document is necessary as the test strategy only covers a whole range of modules and it covers general principles on how to approach the testing process. The test plan, on the other hand, focuses more on the specifics, the details of who and how is responsible for testing.
The test plan has the following components:
Test plan ID–it’s a unique code that it’s assigned to every plan.
Test environment – defines the environment that’s needed in order to carry out the testing. It’s the setup of both hardware and software that’s required by the test teams in order to execute test cases. It allows the team to carry out the tests by being configured with the necessary hardware, software and network.
Features to be tested or not – this section defines in details the software features that will be tested as well as the ones that will not be tested for any reason. They might not be available in that version of the software, for example.
Types of testing - the testing plan defines and describes in details the testing method used for every feature (stress, performance, usability, acceptance, integration, system etc).
Entry/ Exit criteria – basically specify when the testing has to start and when to stop.
Other relevant information such as status, testing tasks, pass or fail criteria, schedule, responsibilities, test items and a brief introduction.
The test plan is very specific as it tells the team or even the team members what to test and when as well as criteria used for testing.
A single development project can have multiple Test Plans and a waterfall project can have a test plan for every type of testing, as it is in an Agile project, for example, according to Focus Professional Services.
When we put together the characteristics of the test strategy and the test plan, we observe some crucial differences.
1. The Test Plan is formulated from SRS (Software Requirement Specification) and it describes the scope of testing as well as the activities performed, in detail. The test strategy describes the way testing is carried out, according to Art of Testing.
2. The test plan is very detailed and specific when the test strategy talks about the general approach to testing.
3. The test plan is subject to change while the test strategy remains untouched.
4. The test plan is always a standalone document, the test strategy can be, in smaller projects, included in the test plan.
5. While the test strategy is set at the organization level, the test plan is defined only at the project level.
6. The test strategy outlines the necessary resources to complete the testing while the test plan assigns the testing tasks to specific roles.
7. The testing strategy talks about the company vision and the expected results, the testing plan explains what needs to be done in order to achieve those results.
And the differences continue. The development of the testing plan, as well as the testing strategy, is viewed by many people as the most important part of testing and it really pays to have a very good plan that specifies clearly what steps are needed to ensure an error-free product.
Both these documents, however, are just pieces of paper unless they are checked regularly against the reality of the testing process and if the test plan is not updated to the current testing needs.
So, what is the difference between a test case and a test script? If this is something you've been asking yourself lately then you happen to be in just the right place. We'll first start by explaining what a Test Case is.
A test case is basically the specification of execution orders, inputs, expected results and testing procedures that define a series of single tests to be done with the main goal of achieving certain software testing objectives. These testing objectives could include compliance verification of specific requirements or exercising particular program paths.
Test cases rely on methodical testing procedures rather than the haphazard way of doing things. The desired coverage for software testing can be produced by building a series of test cases using this technique.
Test cases that have been formally defined give those same tests the ability to run repeatedly against the software's successive version. What this does is it allows for consistent as well as effective regression testing.
In order for an application's requirements to be fully tested, each requirement will require you to run a minimum of two test cases each. A negative test as well as a positive test.
Expected outputs and known inputs are the characteristics of a formal test case. Test cases based on normally accepted program operations are informally written test cases.
Now for the Test Script description. This is basically a script module consisting of system instructions for testing purposes. The fact that you need to write actual coding language to produce this tool is why people in the IT realm gave this procedure the term "test script".
The development of test scripts can be done in very many ways. A clear example is, when working with programming codebase that's object oriented, developers and programmers can access testing objects using several different strategies.
In other cases, developers and programmers, once again, can take huge advantage of APIs or Application Programming Interfaces for the creation of high quality test scripts, which will in turn lead to development projects with high functionality levels.
In general, test scripts are basically mediums that give IT professionals the ability to determine predetermined input results and test case isolations. This is comprehensive testing's strategy for the elimination of glitches and bugs as well as the promotion of better software service and product functionality. Test harnesses are the test script repositories and the text execution engines.
Any functionality that allows for testing is what a Test Scenario basically is. Most IT professionals also commonly refer to this as Test Condition or Test Possibility as well. In this approach, you as a software tester, will need to figure out real world scenarios by using the end user's point of view, as well as using the cases of the application that is currently being tested.
Two words make up Test Scenario. These are Test and Scenario. Here, "Test" represents verification or validation while "Scenario" is meant to represent the user journey's verification process.
Normally you'll find that large amounts of possible paths as well as large amounts of data combinations in the software will usually restrict you from using exhaustive testing, however, Scenario Testing ensures that the application's end to end functionality that is currently being tested is working as it should and it also makes sure that the business flows involved are also working as expected.
As Scenarios are just basically the User Journeys, in this approach the software tester, when checking the applications performance, just has to walk in the end user's shoes.
The Test Scenario's preparation stage is most often times the most vital part of the whole process. You as the software tester using this approach will need to get help or consult the business user, client, developer or business analyst. After the determination of these test scenarios is when you can begin to write test cases for each scenario.
The high level concepts of what need to be tested are what make up Test Scenarios.
If you're an IT professional in this day and age, then you might want to consider fully understanding the fundamentals of Test Plan. It has the ability of making some of your work so much easier as well as way more effective.
Always try to make the test plan as concise as possible if you want the plan to be as effective as possible and avoid superfluousness and redundancy, and with that you'll be good to go. Hopefully, you now know a lot more about Test Plan.
Regression testing is defined as the process of testing a changed software to ensure that the older established features still work as they should. It is a crucial step in software development as it eliminates many of the risks associated with software updates.
Although some organizations verify critical functionality only once and they presume it will continue to work fine unless it’s been purposely modified, the practice has shown that even routine changes in code can have unthought-of side effects that break previously established functionality.
It is essential as it provides the only reliable tool that verifies that the code changes don’t break the existing functionality of an application and it has a huge impact on release delays, budget overruns and the possibility of bugged errored software being released.
Regression testing determines when code alterations cause previously working functionality to fail, giving you the opportunity to identify errors in real time.
For a software that was previously working flawlessly, this can change if the updates included incorrect or incomplete changes. This occurs extremely often in the software industry. Generally, one of six attempts to correct a defect is faulty and generates additional errors.
This high rate of the defects has several reasons. First, it’s the tendency developers have to fix the symptoms instead of the root cause. Other factors can be the lack of experience of the developers or poor system documentation, often seen in the agile methodology, as appose to the waterfall model.
These techniques exist to focus our testing on the aspects that could have been affected by the code changes instead of covering all possible aspects that could go wrong.
Full testing (Retest All) aims to cover as many issues as possible and it’s basically running all tests after every change to the code is made. It’s the complete technique and sometimes the only option when you can’t predict which part of the software was affected by the update.
Regression test selection aims only at the modules that were more likely to be affected by the changes. As it is not complete, I can let errors slip through so it’s extremely important to receive a very high ROI.
Test Case Prioritization is approached in two different ways: general prioritization when cases are chosen based on their importance and version-specific prioritization when cases are chosen based on their importance for that specific version.
Hybrid combines any or all of the above techniques for various releases.
When you create your regression testing plan and you’re opting for one technique or the other, there are a few things you should keep in mind:
1. Use automation – nothing can make your process more efficient than automation. Repeated testing under the same conditions and with the same variables will not discover any new defects. Also, repeated tasks will make your testers lose concentration and they might miss some of the defects.
The biggest advantage of automated regression testing is that you can add extra test cases to the regression pack without increasing the testing time too much. And more, the automated test can be run during the night or at the same time with the manual tests.
2. Update your regression pack regularly – It is always a good idea to keep your regression pack up to date. As your project increases, some of the newest functionality won’t have enough test coverage while some other tests might not be necessary anymore.
3. Use an element 'id’ to locate items on screen. Original automation tests recorded actions they later replayed. They could simulate the clicking on a certain pixel’s location. However, if that button was moved, the clicking will take place in the wrong location. Calling it by name instead of location allow the test to continue no matter where the button was moved.
4. Analyze every defect that escaped the previous testing - this will allow you to figure out what went wrong and to include tests that can possibly cover that path and detect that particular type of defect.
5. Focus on busy paths – they should include the basic functionality of your software as well as the most used features. This implies you know your users and those features they rely on the most. Your regression pack should focus on the core functionality of your application.
6. Identify those areas that have shown the most failures and include in your regression pack more tests that focus on those areas.
7. Don’t forget to include tests that cover non-functional attributes such as performance, usability, security.
The latter are simple substitutes to Enterprise IDEs but they offer advanced functionality, like DOM comparison, collaboration functionality, etc.
When developers change or update their applications, the smallest modification can have unforeseen ramifications. Regression testing is the only way to ensure the modification hasn’t broken existing functionality. By re-running testing scenarios that were designed when original problems were fixed you can make sure your update didn’t cause previously solved bugs to re-appear.
Regression testing needs to be seen as a piece of a testing methodology that’s cost-effective but still complete and that incorporates enough variety, like for example frontend UI automated tests combined with targeted unit testing using risk prioritization. This will prevent any aspect of your application from being unchecked.
Software development companies with effective regression packs improve their performance of their developers significantly thus leading to a successful project.
The discovery of errors on time can save a lot of time wasted on chasing errors further in the development cycle. It also allows the team to update the code when necessary without being afraid it will compromise previously established functionality.
The Waterfall model, also known as linear sequential design, is a software development model. Just like the name suggests, the development flows only in one direction, which is downwards.
According to Oxagile, this sequential development ends up releasing a new software product. The key to this Waterfall Model’s framework is that it proceeds with each requirement step by step and never goes backwards..
The linear sequential design follows a program full of activities that need to be accomplished correctly before moving on to the next one.
This won’t allow you to leave any open stages because you won’t be able to proceed to the next task. All of the phases are planned and designed beforehand.
I highly recommend you to watch this YouTube video, that goes through the basics of this development model. This will help you understand all the aspects explained in the article. It’s named “What is Waterfall Methodology?” and it is created by Project Management Software – Easy Projects.
If you are still trying to understand how this software development model works, it is essential for you to get acquainted with all the steps that you will be required to pass before reaching the final result.
The most important thing you should keep in mind while going though this software development model is to have a clear vision of the project and to understand properly what you are aiming for.
The Waterfall Model is very useful and easy to follow, only if the idea and its stages are perfectly identified. According to a Tech Republic article, the following are the phases to a successful development.
One of the first steps is brainstorming and defining a concept. Investigate the target briefly to get an idea of their needs and find out the perfect product.
Once you resolve all of those questions, you need to do an exhaustive research of the clients and customers that you will be directing to. Define your target and investigate what they need and where they are from.
Once you have your customer’s area controlled, it is time to start designing. You will need to plan a strategy that solves each of the problems that are presented. Apart from that, you will need to program other aspects like the language.
The next step is to start constructing it. Once all the ideas are clear, you will be able to start with the next step, which is implementing the solutions to every stated problem and constructing the final product.
Once the construction part of the development is done, you should start testing it. Verify that it accomplishes all the requirements you named before. Also, check out if they are totally error-free.
There are three different types of testing that are usually put into practice. The first one is called unit testing of code modules, which makes sure that all the coding is properly set up.
Then you should proceed with the system testing and finally, the acceptance testing.
The next step is deployment. When you check and verify that everything is working properly, you will be able to install the final product. The last step is the maintenance of the software result you just created.
The Waterfall Model is well known for its multiple advantages when it comes to creating and developing a new software product from scratch.
In agreement with an article of Tech Target, the first thing to note is how organized the process is. This means that every step or activity has a deadline that needs to be respected and followed strictly.
Every task has a starting and ending point that needs to be accomplished in a limited time.
Dividing the development of the software in other departments makes it easier to manage and control. The rigid model usually turns into a successful final project.
Another advantage to keep in mind is that usually this model requires a lot of beforehand strategic thinking and planning. This is why so many problems are found in the early stages and can be avoided.
The model is also popular for its simplicity. As mentioned before, the planning is so well organized that everyone is able to understand the process. Moreover, the tasks never overlap each other, so there are no confusions.
All of the processes are completed one at a time, that is why the model is strict to follow but the durability of the activities is much shorter and effective than if you use any other development model.
After going through all of the advantages that this software development model has, it is fair to display some of the disadvantages.
One of the aspects that most people tend to dislike according to Armarjeet Chavan is the fact that once you complete one task, you are not able to step back and modify it.
Sometimes, there is a possibility that you might be able to change something but it will surely end up being extremely expensive and will add extra cost to your project.
That is why the Waterfall Model is only supposed to be used when the idea of the product is very clear and all of the requirements are understood beforehand.
However, it is true that due to its fast development, it makes it a little bit difficult and complicated to revise all the work, as well as to verify if it is going on the right path.
Another disadvantage is the difficulty to solve all the problems even before starting with the process. You may estimate the basic things that will get on your way but maybe not each and every one of them.
For example, you could have designed something that later turns out to cost a lot more money or it is just too difficult to produce. This is why some people state that this development model is unrealistic.
Finally, this model should only be used in short and simple projects because if you try to apply this to a complex development, the risk of needing to change any requirement is higher.
And as suggested above, this will only result in extra expenses or even a failure of the project.