:: QC Boss :: Testing, Independent Software Testing, Manual Testing, Website Testing, Functionality Testing, Usability Testing, QC, QA, UAT

PDCA Cycle:

Plan (P): Device a plan. Define your objective and determine the strategy and supporting methods required to archive the objective.

Do (D): Executing the plan. Create the conditions and perform the necessary training to execute the plan.

Check (C): Check the results to determine whether work is progressing according to the plan and whether the results are obtained.

Action (A): Take the necessary action. If your check up reveals that the work is not being performed according to plan or results an not what was anticipated device measures for appropriate action.

Classes of Reviews:

1. Informal Review:

Ø Generally one to one meeting

Ø No agenda

Ø Results are not formally reported

Ø Occurs as needed throughout each phase.

2. Semi Formal Review:

Ø Facilitated by the author (the person who is responsible for the activity)

Ø Presentation is made with comment throughout and at the end

Ø Reports are distributed to the participants

Ø Possible solutions for defect not discussed

Ø Occur one or more times during phase.

3. Formal Reviews:

Ø Facilitated by the modulator (the person who has link between test engineer and Management)

Ø Assisted by a recorder

Ø Meeting are planned in advance

Ø Directly dependent on the preparation of participants.

Developers do not allow a lot of time to test their programs. Because of this they often just test with ideal data that fits into the specified parameters. In other words the developer is only testing the program to see if it is doing what it should be doing, and they are not testing to see that the program is doing what it shouldn’t be doing. A program needs to be tested outside its parameters to see if it gives the proper response or error message to such data. To get the product out to the environment on time, programmers run test that they already know will work. A test engineer once said to me that “if the program only works on a day when the temperature outside is 80 degrees, the programmer will wait for an 80 degree day on which to test.” This may seems extreme, but it is something that I have observed in my internship.

When working with a project for any amount of time, those involved in getting the project to deployment have developed a biased toward the project. When those accountable for getting the project out to the customer on time and on budget are the ones to test the program, it is certain that certain things will not be checked in order to save time. I remember on one occasion the programmers failed to test the printing option, because “it had always worked before.” This program was for calculating certain data and putting it into report form, without the printing option this program became useless. So, because of their past experience with the program and their desire to get the product to deployment, the product came out on time and on budget, but not with the quality that it needed to be beneficial to the company. Testers are not biased to the product and will test the product fully, because it is their job to find the faults, before it goes to deployment.

The programmer knows his or her code inside out, however they also know how to get around flaws in the program. The best example that I can give is for installation of a new program. Programmers are a creative lot when it comes to passing their own product. There was a programmer that was confident that his product was ready for deployment, however during testing we were not able to install the program using the setup.exe file. His explanation of this was that there was a registry key that needed to be modified before the setup could be run successfully. The testing facility was not about to pass a product that required the user to edit the registry. The programmer honestly thought that this was an okay work around for the product’s failure. Outside testing is best in this situation, because the developer doesn’t realize that the mistake in the installation was something that needed to be fixed within his own program.

Many programmers test their programs locally on there own machine and they seem to forget that the program has to get to the user somehow. Some user will have the program installed from a CD, which is the most like how the developer tests his or her program, however in many cases the program is going to be pushed down from a network, offered on the web, or passed around on a networked drive. When the developer is not prepared for this, files can be lost in the distribution method. Independent testing resources are the best way to go in this case, because the have solve the problem of the “developer’s machine” and the will have the network for testing the push from the network without involving the production server. The developer forgets that there is more than one-way to receive a program and if not all methods are tested, one of them is bound to fail.

The first thing that I learned was that a developer’s computer has the latest and greatest software, fixes and upgrades, which the average target computer’s environment user does not. Having tested the product thoroughly on his or her own machine, the developer is ready to deploy the software to the entire environment. The problem with this is that the developer is usually running the software on only one operating system build (version) and is using a server that is only supporting a handful of developers. This is not a true test of the program’s ability to perform on machines of different processor speeds and operating system builds. The developer, who does not have the resources for such testing, should request testing from an outside source to ensure that the program is going to run in the environment with minimal errors. Environments are much more complex than the developer’s personal environment that he has created for himself; Networks have more than just a handful of people on them. Running things off of the network slows the response times of all programs, but if the program is not efficient enough, it should not be deployed.

Yes, Certainly. manual testing fills a gap in the testing repertoire and adds invaluably to the software development process.

Manual Testing will

• Provide confidence in the system
• Identify areas of weakness
• Establish the degree of quality
• To prove it is both usable and operable

Offshoring Software is one of the biggest growing Businesses these days. Most of the Top Shots in the industry outsource projects. While outsourcing software one should keep in mind that the successful completion of the software depends on a lot of factors and one should analyze these factors before outsourcing projects.

The biggest and the most important issue is to choose the right firm or freelancer for the project. Along with it there are other issues which need to be addressed before as well as during the project is in progress.

Let’s go through a few important of these issues in brief here:

1. A Very Strong and Project Centric Approach: As far as the Project is possible one should know what the exact requirements are. It is usually best to document the requirements and make sure that the offshore firm completely understands it. This should be as the guideline for the project.

2. Continuous and Focused Communication: It is a very healthy practice to be in constant touch with the offshore firm. Reports should be sought after a period of time so as to know what the progress of the project actually is. This helps one not only keep track of the project but also avoids unnecessary hassles later on. There can be circumstances when the project goes haywire if one does not properly track it.

3. Risk Management: The software projects are always somewhat risky. The risks can be related to the schedule, the pricing or the deliverables. It is always a good practice to make all these assessments before hand. It is always a nice practice to make sure that the project is delivered in a phased manner. The various features can be delivered one by one and testing can be carried out separately for each feature.

4. Experience: While handling the software projects it is always an advantage that there is some experience in handling such projects before. This helps one in knowing that whether the project is on the right track or not.

5. Testing: This is one of the most important issues as the projects need to be properly tested before implementation. There are various phases of testing such as Alpha Testing and Beta Testing wherein the stability of the project is judged.

With all these factors in mind one can easily make the best out of offshore outsourcing projects.

Software development is an industrious mission that is incomplete and trivial without Software Testing as this has a major significance in the Software Development Life Cycle.

Software testing evaluates the quality and checks the potency of the program for the required output. Software testing is the most important functionality in the Software Development Life Cycle as it exhibits all the mistakes and errors in the developed software. Without rectifying theses errors, which in the technical words are called the “bugs” the software development is not considered to be complete. Hence, Software testing is an important parameter for the assured quality of the product. The processes of Software testing starts from the beginning of the project, where all the software developers and programmers examine all the aspects of the data provided by you and dig out all the flaws and issues. We also provide ideas and views to enhance the quality of the software.

Companies do not understand that software development and testing are two separate and opposite sides of the software development process. Most often there is only one person to do both tasks. The person, who writes the code, tests the code. Now, you might say, “What is wrong with that?” The problem is that testers and developers have different views of the problem, different approached to testing the product, and different goals. If only the developers test their own programs, the program and end users of the program suffer from inadequate testing.

As a software testing company we take up this responsibility to provide all the errors in the software development to the customer in a predetermined frame of time and as well be cost effective.

An efficient Software Testing is not only displaying the errors, but also underlining the requirements of the customer throughout the product cycle. We also introduce information that is new to project community so as to keep them much aware of the standards and parameters.

However not all the companies may be well equipped with the in-house testing professionals, at this point of time we come in the scenario. We confirm the correctness, completeness and compatibility of the software and find all the missing links in the products.

We always advise for the software to go through all the phases of testing as the errors and mistakes can be recognized from both the ends and their rectifications can also be done simultaneously. We take all the desired measures and make use of all the latest techniques to perform this task. As it is very important to be sure that it does not only works but the functionality also meets the requirement of the customers.

The web is a powerful medium, through which any person or organization can publish its message for consumption or use by anyone who has access. Part of the value of the web is that content can be easily modified or added to as a message grows or changes. However, the downside to this non-permanence is the idea that the message or site does not need to be perfect before it is presented to the intended audience and participants. This is not a productive school of thought. We must realize that a website should be treated similar to any other marketing or informational piece and thoroughly reviewed for correct content and functionality through formal quality control procedures.

If you want a great Web site, you must test its usability. Just because no one has complained about your site doesn’t mean that all your visitors are using your site effectively, efficiently and to their full satisfaction.

Visitors won’t make the effort to complain unless you have outraged them in some way, or have provided an easy way for them to in touch with you from every page about the problems they may be having.

Who should be testing the website? The client? The development team? A third party? The answer is, “Yes, to all three.” Quality control personnel should consist of the client, the development team members and other personnel who are not involved with the creation of the site. This ensures that the site is reviewed by a variety of different people who have different relationships to – and expectations of – the site.