Software Testing

The Software Development Life Cycle

Berto — Wed, 22 Dec 2010 10:28:09 +0000

SOFTWARE TESTING LIFE CYCLE

No matter which software development methodology you use, Pay4Bugs can be an essential part of your testing processes. Once your product, website, or application is nearing the beta phase, and it’s time to get hands-on feedback from real users at a low price, Pay4Bugs is the way to go.

Software Development Life Cycle – CODE AND FIX

This methodology is probably used more often than any other. It is unique in that the application’s feature set is designed at the same time the application logic is written.

Development starts immediately, with little (or, often, no) planning involved. Problems are dealt with, and defects are fixed, as they occur.

Although this process allows development to proceed quickly, the project will encounter serious delays if major architectural problems are found. Major architectural problems, especially those discovered late in the process, will require a rewrite of much of your code.

The Code And Fix methodology is characerized by Wikipedia as “not so much a deliberate strategy as an artifact of naiveté and schedule pressure on software developers.”

Code and Fix is popular in small companies, but its use should be discouraged. Some things that can be done to discourage its use:

Create teams with a mix of developers, marketing people and management, and empower them to make decisions about your application’s features.
Include management in the software development process; many delays are created due to management not consulting with the product development team, and, therefore, setting launch dates that are not attainable.
After the product launches, arrange a meeting of the product team to discuss what went right, and what went wrong.

Software Development Life Cycle – WATERFALL

Software Development Life Cycle - Waterfall Model

The waterfall model is a sequential design process comprised of several steps, each of which must be completed before the next starts.

System/Information Engineering and Modeling
Requirements are established for each component in the system, and the team decides which requirements will be fullfilled by the software. This is necessary when the application must interact with other resources. Once the ideal system is designed according to the requirements, work proceeds to the next step.
Software Requirement Analysis
Software Requirement Analysis is also known as a feasibility study. The development team analyzes the customers’ requirements, looking at the need for possible software automation.Then, the development team creates a document that holds specific recommendations for the customer’s system. This document includes details like personnel assignments, costs of the system, project schedule and target dates.
System Analysis and Design
Here, the process and the application’s structure are defined. If client/server technology is to be used, this step will specify elements like number of tiers required for the package architecture, and the database design. Then, the development team will create a software development model. This is a crucial step; any fault in the design phase could be very expensive to fix later.
Code Generation
In this phase, the actual application code is created. using high level programming languages like C, C++, Pascal and Java. The programming language is chosen according to the type of application, as well as the application requirements.
Testing
Several different testing methods are available to reveal errors and defects that were created during the previous phases.
Maintenance
Maintenance is performed after the application is delivered to the customer. Changes can occur due to changing customer requirements or new, unexpected input into the system. The application should be designed to accommodate changes that could be happen after development is complete.

It is very important to gather all requirements during the first phase of the Waterfall Model, in order to ensure proper system design. If the customer adds requirements later, the development process will be impacted in a very negative way.

Software Development Life Cycle – MODIFIED WATERFALL

Many engineers recommend modified versions of the waterfall model. In the traditional waterfall model, the different stages of development are not allowed to overlap. One common type of modification allows some of the stages to overlap, which results in reduced documentation requirements and a reduced cost of returning to earlier stages to make changes. Another common modification is to incorporate prototyping into the requirements phases.

Overlapping stages, such as the requirements stage and the design stage, allow the development team to integrate feedback from the design phase into the requirements; but overlapping stages can make it difficult to know when you are finished with a given stage, as the line between stages becomes blurred. This makes progress harder track. Without distinct stages, problems can cause you to defer important decisions until later in the process when they are more expensive to correct.

Software Development Life Cycle – PROTOTYPING

One of the main problems with the waterfall model is that the requirements often are not completely understood in the early development stages. When you reach the future stages, you may discover that you need to adjust the requirements.

Prototyping can be useful in determining how a design meets a set of requirements. You can build a prototype, adjust the requirements, and revise the prototype several times, gaining an understanding of the project’s overall goals. In addition to clarifying the requirements, a prototype also defines many areas of the design at the same time.

The pure waterfall model allows for prototyping in later stages, but not in the early requirements stages.

Some drawbacks of prototyping:

Because it appears that you have a working system, customers might expect a complete system sooner than is possible. In most cases, a prototype is built on compromises that allow it to come together quickly; those compromises may prevent prototypes from becoming effective building blocks for future development. You need to decide early if you want to use the prototype as a basis for future development, and everyone needs to agree with this decision before development begins.
Prototyping can easily turn into a Code and Fix development cycle. Before you begin prototyping, gather clear requirements and create a design plan. Limit the amount of time you spend prototyping before you begin. Time limits help to avoid overdoing the prototyping phase. As you incorporate changes, update the requirements and the current design. After you finish prototyping, consider returning to one of the other development models. For example, consider prototyping as part of the requirements or design phases of the waterfall model.

Types of prototyping include:

Patch Up Prototype: This type of Prototype Model has each developer working on a specific part of the program.. After everyone has done their part, the pieces program will be integrated with each other. This type of prototype encourages cooperation between members of the development team.

Non-Operational Prototype: Used when only a certain part of the program should be updated. The main application is not affected, because the code being tested is tested as part of dummy program is applied with the application. This prototype is usually used to solve problems in a specific part of the program.

First of a Series Prototype: This type of prototype is also known as a beta version. The software is fully functional; the goal of a beta is to elicit feedback and suggestions; to determine usability; and to resolve defects that may pop up as a result of real-world usage.

Selected Features Prototype: This is another form beta, but the beta testers have access only to selected features and tools. This type of prototype is used with applications that are part of a larger suite of programs. This is usually done to test the independent features of the application in question.

Software Development Life Cycle – SPIRAL

The spiral model is an iterative model that attempts to combine advantages of the top-down and bottom-up models of software design. The goal is to reduce, as much as possible, an application’s time-to-market; in the traditional waterfall model, since each step must be completed before the next one starts, the time-to-market can be much longer.

The system requirements are defined in as much detail as possible. This usually involves interviewing a number of users representing all the external or internal users and other aspects of the existing system.

A preliminary design is created for the new system. This phase is the most important part of the Spiral Model.

A first prototype of the new system is constructed from the preliminary design.

A second prototype is evolved by a fourfold procedure:

evaluating the first prototype in terms of its strengths, weaknesses, and risks;
defining the requirements of the second prototype;
planning and designing the second prototype;
constructing and testing the second prototype.

The spiral model is designed to minimize risks and allow you to find major problems earlier in the development cycle. A project is broen up the into a set of risks that you need to deal with. You then begin a series of iterations in which you analyze the most important risk, evaluate options for resolving the risk, deal with the risk, assess the results, and plan for the next iteration.

For each risk, you must consider

Probability: how likely it is that the risk will occur
Loss: the severity of the effect of the risk on the project

You can use a scale of 1 to 10 for each of these items, where 1 represents the lowest probability or loss and 10 represents the highest. Risk exposure is the product of these two rankings.

The risks that have the highest risk exposure should be resolved first.

PAY4BUGS

Pay4Bugs can be an essential part of your testing processes, no matter which methodology you use.

Software Testing: An Introduction

Berto — Wed, 22 Dec 2010 10:08:35 +0000

Intro to Software Testing

Testing is an essential part of the lifecycle of any computer program.

Why is it Important to Test?

Some people see the cost of testing as an expense that affects their product’s profitability. It is wise to instead, think of testing as an investment – one that will result in more secure software with fewer bugs; one that will result in happier end-users. Some pitfalls of not properly testing include:

Monetary penalties. Lost customers, lawsuits, fines and penalties due to non-compliance with laws and industry regulations all fall into this category.
Loss of time can be caused by transactions taking a long time to process, but can also include downtime and loss of productivity if people are not able to complete their jobs due to a failure of your software.
Damage to business reputation occurs when your software does not work properly, and an organization is unable to provide service to their customers as a result. This often results in lost business and, therefore, lost revenue.

We understand that a lot of managers see software testing as an expense and not an investment. The best way to combat this is to save money on your testing while still providing high-quality tests, performed by real humans who have incentives to try their best to “break” your application.

To do this, we use Pay4Bugs, which is an online software testing marketplace where you set your own prices and see who will work for you across the world at incredibly inexpensive rates!

The failure of safety-critical systems may result in injury or death.

What are Your Goals?

Quality Assurance
You know what your program requires as input. You can usually predict (based on that input) how the program should behave, and what its output should be.
Verification that the program matches the specification laid out by the client(s) and project managers.
Security
There are many ways a program or Web site can be attacked. Many of these attacks can be mitigated or completely avoided; for example, SQL injections in a web application, or
buffer overflows in a C or C++ desktop application. Both types of vulnerability are common and can result in disaster if not found and corrected — but both types of vulnerability are also
very easy to correct (or prevent).
Usability
Testing isn’t just about making sure your program does not crash. Testing is also about making sure the program behaves the way users expect it to behave. Your users will want
a program that is easy to use. “Easy,” in this context, means intuitive to the user (not you).
Tracebility
A reasonably complex project may have hundreds or thousands of requirements, and you need to have some way to know that you have implemented all of them. You also need
to track the progress of each requirement and prove that it has been satisﬁed.

Test Early, Test Often

Although traditionally, testing has occurred at the end of the software development cycle, it is unwise to do so on any except the smallest projects.Testing should be performed on small, manageable chunks of code, and should be started as early as possible.

White-Box vs. Black-Box Testing

These two terms describe techniques used to test software. White-box testing is performed by people who are familiar with the code and have access to the code and the developers who wrote it. Testers doing white-box testing need to either be familiar with software development, or be given ample time to interview the developers themselves.

Black box testing is used by people who never look at the code. The emphasis and purpose of black-box testing is to judge whether all of the requirements and specifications have been met. A combination of both techniques is essential for a fully-rounded testing program.

Types of Software Testing

Software testing consists of several subcategories, each of which is done for different purposes, and often using different techniques. Software testing categories include:

Functionality testing to verify the proper functionality of the software, including validation of system and business requirements, validation of formulas and calculations, as well as testing of user interface functionality.
Forced error testing, or attempting to break and fix the software during testing so that customers do not break it in production.
Compatibility testing to ensure that software is compatible with various hardware platforms, operating systems, other software packages, and even previous releases of the same software.
Performance testing to see how well software performs in terms of the speed of computations and responsiveness to the end-user.
Scalability testing to ensure that the software will function well as the number of users and size of databases increase.
Stress testing to see how the system performs under extreme conditions, such as a very large number of simultaneous users.
Usability testing.
Application security testing to make sure that valuable and sensitive data cannot be accessed inappropriately or compromised under concerted attack.

Manual Software Testing vs. Automated Software Testing

Certain types of testing can be done without human intervention. Other types can’t effectively be done in an automated manner and should use manual testing:

Usability testing – Ease-of-use is subjective; measuring it with an automated process is difficult at best.
Exploratory/ad hoc testing (where testers do not follow a ‘script’, but rather testers ‘explore’ the application and use their instincts to find bugs) – because ou are not doing the test exactly the same way each time.
Testing areas of the application which experience a lot of change.

Automated testing is best used for tests which are explicit and repetitive:

General QA and functionality tests (i.e. does each module do what the requirements say it should? How does the application respond to incorrect inputs?)
‘End to end’ scenario tests (simulating a ‘real world’ use of the software in a production environment)
Performance, load, and stress testing

Most tests are automated, like unit tests. Mathematically-oriented folks might suspect that unit tests refer to unit conversions (like centimeters to inches), and business-oriented people might think of inventory; but the term describes a technique that involves building small, individual tests for each little piece of functionality. For example, a unit test might be as simple as checking to see that, when the configuration is saved to a file, it really was saved to a file of the proper format that can be properly opened by the program. (In fact, this scenario is complex enough that some might actually break this into multiple unit tests.)

Acceptance testing is completely different. Acceptance tests may be written by the end user or customer. Even when they’re not programmed by the customer, they are actually designed by the customer, typically by having a test engineer sit down with the customer and work them through the process of how to test to ensure that the program does everything it is required to do. After working with the customer to create an incredibly detailed walk-through, the test engineers can then turn around and design automated tests around these functions, and make sure that everything the customer will try to do is possible in the software, and works.

Software Testing Milestones

A program that has hit its Alpha milestone is complete enough that the first round of end-to-end system testing can start. The program is not “ready for prime time,” since, often, the UI is not complete and many bugs may still exist.

By contrast, a program that has hit its Beta milestone has a completed UI; remaining work focuses on continuing to fix bugs, improving performance and enhancing usability.

Typically, end-users start testing the program when it hits beta, although some programmers release alpha versions of their programs, witih the caveat that since the programs are alpha, they will contain bugs and may not be usable in a production environment.

Regression Software Testing

This fancy-sounding phrase has a very simple description. Say you’ve already found Bug A, Bug B and Bug C. You’ve fixed them. Now you’re working on Bugs D and E. Regression testing simply ensures that the fixes for D and E don’t cause any of the earlier bugs to reappear.

Regression tests are performed as a group; the new tests are performed together with the older tests.

Acceptance Testing

Acceptance testing is all about giving the project to the client so the client’s users can test it.

In theory, Acceptance Testing should also be quick and relatively painless; plenty of testing should already have been done. Earlier tests should have eliminated bugs and usability issues, making
acceptance testing a simple formality.

Acceptance testing encompasses other artefacts too, not just the software. This phase of software development may include updating manuals and documentation; updating processes and operational procedures; training end-users and measuring operational performance against Service-Level Agreements.

Goal Testing

Goal testing ensures that code executes in less time than any specified Service Level Agreement. Goal testing is performed in both single-user and multiple-user environments. When committing to an SLA, the management team needs to commit to only those sections of the system they control.

A good SLA includes lots of detail: “Transaction X will complete within Y milliseconds with Z number of simultaneous users.” A bad SLA includes little detail: “Screen X will complete within Y seconds.” The user seeing screen X could be sitting next to the server, on the same LAN, in which case the SLA will probably be met; or the user could be sitting out in the middle of nowhere on a dialup connection, in which case the SLA is not likely to be met.

Software Testing Interview Questions and Answers

Berto — Wed, 22 Dec 2010 06:42:29 +0000

Here are some software testing interview questions and answers. You can add more to the comments field at the bottom to help the community out!

Note that Pay4Bugs does not require interviews – You can get paid for testing software and finding bugs without any interviews, tests, or certifications. However, the software developer customers can also block users who do not post good bugs, so it is almost like a constant interview situation!

Once your product, website, or application is nearing the beta phase, and it’s time to get hands-on feedback from real users at a low price, Pay4Bugs is the way to go.

Software Testing Interview Questions and Answers

Software Testing Interview Question 1 – What is a Traceability Matrix?

A Traceability Matrix documents the relationship between two baseline documents to determine the completeness of the relationship. A requirements traceability matrix may be used to check to see if the current project requirements are being met. This matrix is usually in the form of a table.

The identifier for each of the items of one document are usually placed in the left column, and the identifiers for the other document are placed across the top row. When an item in the left column is related to an item across the top, a mark is placed in the intersecting cell. The number of relationships are added up for each row and each column, with a higher number indicating a higher correlation between the two documents. Zero values indicate that no relationship exists; large values indicate that the relationship is too complex.

Software Testing Interview Question 2 – If there are many bugs to be fixed, which should you resolve first?

Fix the highest-priority bugs first. The severity of a software defect may not correlate directly with the priority placed on fixing it. Severity and priority should be tracked separately, although in a small organization or on a small project, there may not be a large number of defects and you will not need to track both.

It may also be helpful to track the “urgency” of a bug fix (as determined by the client).

In larger projects, you may have a Triage team.

Triage is a medical term; it is the assessment of which patients need to be dealt with first. Some patients will die regardless of what you do; some patients will heal by themselves. The third group, the patients that will only heal with your help, are the highest-priority patients. You can assign software defects to a similar type of “triage” list, based on the defects’ priority and severity.

Software Testing Interview Question 3 – What’s the difference between re-testing and regression testing?

Regression testing is the process of testing new bugfixes to ensure that they don’t cause problems to occur involving problems fixed earlier. This process involves running a suite of tests.

Re-testing is the process of testing a single defect that was just fixed. Only one test is performed, and the goal is to make sure that the defect that was just fixed was, in fact, fixed properly.

Software Testing Interview Question 4 – What are the flaws in waterfall model and how to overcome it?

The major drawback that you do not test the application logic until very late in the development cycle. Although a very detailed system specification should result in a less error-prone application, a single serious error spotted late in the development cycle may be very expensive to fix. Also, the waterfall model does not adapt well to rapidly changing technology.

Software Testing Interview Question 5 – What is the difference between Functional Testing and System Testing?

Functionality testing is based on functional requirements of the application. By contrast, system testing is end-to-end testing that covers all of an application’s functionality including usability, security and performance.

Functional testing is a subset of system testing.

Software Testing Interview Question 6 – What is the V-Model Development Method?

The V-Model

The V-model is a software development process which may be considered an extension of the waterfall model. Instead of moving down in a linear way, the process steps are bent upwards after the coding phase, to form the typical V shape. The V-Model demonstrates the relationships between each phase of the development life cycle and its associated phase of testing.

To see a graphical representation of the V-Model, see the image to the right.

Software Testing Interview Question 7 – What are the pre-requisites for white-box testing?

They are the same as for black-box testing, with one major exception: during white-box testing, the testers have access to the application logic. The tester should ask for access to detailed functional specs and requirements, design documents (both high-level and detailed), and source code. The tester analyzes the source code and prepares functional tests to ensure that the application behaves in compliance with both the requirements and the specs.

Software Testing Interview Question 8 – What is the agile manifesto?

The Agile Manifesto is a statement of the principles that underpin agile software development:

Individuals and interactions are take priority over processes and tools
Working software takes priority over comprehensive documentation
Customer collaboration takes priority over contract negotiation
Response to change takes priority over following a plan

The QA team may want to add one more principle:

Craftsmanship takes priority over execution

The idea is to prioritize the creation of good code over the creation of code that barely works.

Have more Software Testing Interview Questions and Answers? Add them to the comments field below!

Software Testing Tools and Automated Software Testing Tools

Berto — Tue, 21 Dec 2010 13:50:01 +0000

Software Testing Tools

This is a summary of our favorite software testing tools that have saved us a LOT of time and money in outsourcing and development.

Pay4Bugs – The Best Software Testing Tool

pay4bugs.com

Pay4Bugs - Software Testing Marketplace

Pay4bugs is an online marketplace that brings software developers and testers together. Pay4bugs allows developers to hire real people to perform their tests (the rest of the tools listed here deal with automated testing).

The developer sets up a project, which may consist of one or more assignments. (An assignment is a set of instructions relating to a single test or group of tests.)

The developer then sets a price (a “bounty”). Testers only get paid if they find bugs and the bugs are marked “valid” by the developer. Once a bug is reported, the developer has seven days to review it and decide whether it is valid.

Pay4Bugs works so incredibly well because it is at the heart of the free market. You only pay as much as you are willing to pay for each quality bug found, but there’s a catch – if you bid too low, nobody will want to test for you. Due to the web being international, prices end up being orders of magnitudes cheaper than anywhere else, especially for Americans looking to outsource.

Software Testing Tools – CANOO WEBTEST

Canoo WebTest provides an automated way to test web applications. Using either an XML file or a program written in Groovy, you tell WebTest which URL to visit, which form fields to “fill out” and which links or buttons to “click.” You also specify what the results should be. WebTest performs the test and outputs a report describing what each part of the test did, and whether it failed or succeeded.

WebTest has an easy syntax with steps having meaningful names that can be understood even when you don’t know WebTest. Additionally, the recorder allows you to quickly generate a first draft of your tests that you can adapt and refactor to build robust tests suites. Don’t forget: capture/replay is the least cost-effective way of automating test cases!

WebTest’s reporting capabilities are perhaps its most important feature. JUnit-style reports are not enough to understand why a test fails; WebTest reports provide all information allowing you to quickly understand the failure cause.

Software Testing Tools – SELENIUM

Selenium records your keypresses, clicks and other actions and allows them to be played back later for testing purposes. The Selenium Remote Control server can automatically start and kill web browsers and acts as an HTTP proxy for those browsers. It works with IE, Firefox, Opera and Safari, and is compatible with Windows, OS X, Linux and Solaris. To use Selenium IDE, which lets you record your browser activities for later playback, you’ll need Firefox on Windows, OS X, Linux or Solaris.

Selenium also has an API that works with C#, Java. Perl. PHP, Python and Ruby.

Here’s how you create tests with Selenium’s software testing tools:

Record and play back your test in Firefox
Use the Selenium IDE to export your test to one of several programming languages, including C#, Java, Ruby, PHP and Python. This allows you to integrate your tests with an existing testing framework
The tests are made up of a series of Selenium commands, which are sent to the Selenium Remote Control server or the Selenium Grid server

Software Testing Tools – WATIR

Watir is a set of Ruby libraries designed to automate web browsers. Although Watir was written in Ruby, it supports web apps no matter what technology they use. It also supports a wide range of web browsers, including IE on Windows, and Firefox Windows, Mac and Linux.

Watir will drive web applications that are served up as HTML pages in a web browser. Watir will not work with ActiveX plugin components, Java Applets, Macromedia Flash, or other plugin applications. To determine whether Watir can be used to automate a part of a web application, right click on the object and see if the View Source menu option is available. If you can view the HTML source, that object can be automated using Watir.

Work is proceeding on Watir drivers for WebKit (Safari and Chrome) and Opera. The website states that the OS X Safari driver and the Chrome driver are usable, but are still considered “experimental.”

Software Testing Tools – WATIN

Inspired by Watir, WatiN is a web application testing framework that runs on the .NET platform.

The WatiN home page says that the framework supports frames, AJAX, and JavaScript popups, all essential to testing today’s advanced Web applications.

WatiN supports IE 6, 7 and 8, and Firefox 2.x and 3.x.

At the moment, WatiN supports Windows 2000, Windows XP, Windows 2003 and Windows 2008.

Using WatiN on Vista, Windows 7 and Windows 2008 needs a little extra work due to the Protected Mode. You need to add the domain of the website under test to the trusted sites list. This will turn Protected mode off for your site; then your WatiN tests will run properly.

There are several other software testing tools, but this is a great place to start. We love Pay4Bugs for testing beta products and “crowdsourcing” them before going to the final masses.

Software Testing Books

Berto — Mon, 20 Dec 2010 13:53:25 +0000

Oh, software. Most of us are familiar with the routine lapses and disrepairs into which software falls, forcing us to delay our most urgent professional tasks and requiring a lump-sum payment on services to repair whatever’s wrong.

But why waste valuable time, potentially lose revenue, and needlessly chip away at your reputation when it comes to computer programs – when you could easily, effortlessly, and regularly test your software before something devastates it?

Software Testing, available by way of the address www.softwaretestingnow.com, offers to meet all your software testing needs – quickly, affordably, and with due care for your most important programs.

Software Testing aims to provide optimal user benefit by first understanding your priorities and needs with software.

And after reading that sentence, you probably think that Software Testing sends a technician to review your equipment.

To the contrary – you can do it online, with the assistance of Pay4Bugs, partners of Software Testing. A monthly or annual subscription, plus the time and attention a program like Pay4Bugs.com deserves, and voila – you’re able to comfortably and routinely check, test, and maintain your software.

Software Testing Books

When using a service like Pay4Bugs mentioned above, you really don’t need to learn as much about software testing. You can have it done for you!

But there are still a number of software testing books aim to provide quality information, or at the very least enlighten consumers about the real need for routine software testing. Here’s a sample of these books, the highest-rated and best-reviewed:

How Pay4Bugs.com Works

Pay4Bugs.com is an online software program administered by so-called “testers” the world over. These testers are real computer programmers and professionals familiar with all the needs, frustrations, and other pressing concerns about software. If anyone will know how to test, maintain, and optimally safeguard your computer programs and software, a Pay4Bugs.com tester will know.

Pay4Bugs thus serves as an online portal which, through preventive and proactive methods, holds the power of life-and-death over your software. If you choose the service, it’ll ultimately better prepare you and your software; if you don’t, you leave yourself “open to the elements,” as it were, and potentially prey to malware, adware, and viruses of all manner. With that in mind, why not read on about Pay4Bugs.com?

You Assign the Test

When you hire a tester through Pay4Bugs.com, you’re tasked with the need to assign a software problem or testing requirement to a tester – and not the other way around. This puts the power securely in your hands, enabling you to test, maintain, and ultimately better prepare your software.

Who Benefits from Pay4Bugs.com?

Well, apart from the obvious answer – namely, you – a number of IT professionals, companies, firms, and bloggers pay tribute to the quality of Pay4Bugs‘ services with their continued stay as clients. Pay4Bugs.com’s testers ensure fast, reliable service with a measure of quality that surpasses any other rivals on the market – should they even exist.

Quality Assurance

Berto — Mon, 20 Dec 2010 13:53:00 +0000

Quality Assurance, or QA, is another word the evaluation of different portions of the software development life cycle and is used to minimize downtime, bugs, and mistakes, while keeping the bottom line – profitability – ate the forefront of any process. In this article, we discuss how we keep QA costs down while productivity stays high.

With the rise of modernity and the global expansion of computer software, you no longer need to work in the IT field to understand the grave danger that viruses, malware, and other malicious software poses to your computer program.

On the other hand, who hasn’t experienced a computer crash, in which the stored data is destroyed or corrupted?

The rub of it is that most of us don’t see it coming, but we are left to deal with the consequences.

Thankfully, The Software Testing guys at softwaretestingnow.com pledge to meet all your software maintenance and testing needs, serving as a one-stop shop for preventive and proactive measures for quality assurance.

Software Testing and Quality Assurance

Software Testing understands that the well-being and ability of your computer programs are at stake – and that quality assurance is a must.

Through its affiliate, Pay4Bugs, the company relies on quality assurance engineers to supply the best in quality assurance testing and software programs. These engineers, sometimes also called “testers,” perform functions that such titles would precisely suggest, grading, probing, and bettering your software.

P4B thus models itself as a quality assurance portal for professionals with IT needs and the desire to preventively and proactively secure their software and computer programs.

How the Quality Assurance Outsourcing Works

Run by so-called “testers,” Pay4Bugs is an interactive online software marketplace that aims to holistically address the needs, frustrations, and other concerns that clients have about software. If anyone will know how to test, maintain, and optimally safeguard your computer programs and software, a Pay4Bugs.com tester will know.

This serves as a premiere quality assurance outsourcing portal for IT needs. In some ways, the testers who administer Pay4Bugs.com make the most important decisions regarding the security of your software. By paying for the service, you opt to reign in unanswered questions about your software’s security and bolster your quality assurance requirements.

The Ins and Outs of QA

Testers supply a measure of automated testing that provides “end-of-service,” usability, and exploratory and ad hoc tests. These tests serve to grade the overall quality of your software, which extends to its:

Application security
Scalability ratings
Stress and performance requirements
And more!

By probing, testing, and grading your software, testers ultimately determine whether it can stand on its own feet against the advances of spyware, malware, adware – you name it.

You Assign the QA Tests

When you hire a tester, you’re tasked with the need to assign a software problem or testing requirement to a tester – and not the other way around. This puts the power securely in your hands, enabling you to test, maintain, and ultimately better prepare your software.

Who Benefits from this Quality Assurance Program?

The short answer: anyone who regularly requires software operability or needs quality assurance guarantees for their clients. Apart from you, a number of IT professionals, firms, bloggers, and larger companies continue to stay with Pay4Bugs.com because of the reliability of its testers and the supremacy of its tests.

Contact Pay4Bugs.com

For more information, You can visit Pay4Bugs here

Regression Testing

Berto — Mon, 20 Dec 2010 13:52:12 +0000

Regression testing and analysis are tools of the trade for “testers” – software engineers who work around the clock for Software Testing’s clients. Through regression testing, testers resolve viruses in an expedient and sequential manner – without forgetting to delete the previous bugs.

These days, who hasn’t encountered a nasty virus or “bug” that infects software, delays professional services, and renders impossible any attempt to run a business smoothly?

The truth is that malicious adware, malware, and spyware lurk around every corner. Some hacker devises a new Trojan virus, or secures entry to your private server, threatening to turn over valuable information at some present or future date.

What’s Regression Testing?

The concept is easy to understand. Think about a classic television set with cords from various devices in endless knots. The job of a regression analyst is to disentangle the cords without forming a new knot.

Through its affiliate, Pay4Bugs, Software Testing relies on quality assurance engineers to supply the best in regression analysis and testing. By employing experienced software testers, the one-stop shop portal aims to resolve viruses and other IT problems without creating new ones or restoring old ones.

Here are a few other analysis and services that Software Testing provides through its capable employees:

Smoke testing – a precursor to actual testing that aims to ensure that the software in question will not crash outright if tested
Functional testing – a form of testing that feeds input and examines output, allowing testers to better identify what, exactly, might be causing problems
User acceptance testing – a simple way to gauge consumer confidence and satisfaction
Integration testing – a process whereby testers group software together to perform a critical test

Regression testing is what you need to do before every new software release. Sometimes, new code breaks the old code, and you don’t realize it until it’s too late. Many beginning programmers don’t do this type of testing because they think that everything remains static. Unfortunately, it does not. Subroutines and functions change. Input and output parameters change and get moved (they shouldn’t… but they do). And entire programs can come falling to their knees when new software breaks the old.

The solution? Constant testing on every release. But this is expensive! That’s why it’s important to have a series of unit level tests and functional tests that grow with each new release – they must all get USED during each software release! To save money, Pay4Bugs, the software testing marketplace, can do a lot of this for you.

How to Solve Common Regression Testing Problems

Pay4Bugs, as such, strives to eliminate software problems and provide the quality satisfaction you deserve as a potential client.

How Pay4Bugs Works

Pay4Bugs.com thus serves as an online portal which, through preventive and proactive methods, holds the power of life-and-death over your software. If you choose the service, it’ll ultimately better prepare you and your software; if you don’t, you leave yourself “open to the elements,” as it were, and potentially prey to malware, adware, and viruses of all manner.

You Assign the Test

When you hire a tester through P4B, you’re tasked with the need to assign a software problem or testing requirement to a tester – and not the other way around. This puts the power securely in your hands, enabling you to test, maintain, and ultimately better prepare your software.

Who Benefits from Pay4Bugs.com?

A number of IT professionals, companies, firms, and bloggers pay tribute to the quality of Pay4Bugs’ services with their continued stay as clients. The testers ensure fast, reliable service with a measure of quality that surpasses any other rivals on the market – should they even exist.

Software Testing Certification

Berto — Mon, 20 Dec 2010 13:51:17 +0000

Software Testing Certification – This page contains a list of places to get certified for software testing.

Note – You do not need any certification to begin testing software and making money on Pay4Bugs, the software bug-testing marketplace where customers can set your their own prices and bug testers can choose what projects to work with.

American Software Testing Qualifications Board

http://www.astqb.org/

This organization is the American branch of the International Software Testing Qualification Board (ISTQB).

ASTQB was founded in 2003 as the American Testing Board. In April 2005, the name was changed to the American Software Testing Qualifications Board.

Through the involvement of the world’s foremost experts in software testing, the program was developed for software professionals who want to prepare today’s professionals by anticipating tomorrow’s software testing demands.

The International Software Testing Qualifications Board (ISTQB), organized has introduced an international standard for software testers. The ISTQB’s Certified Tester programs are meant to bridge the gap between research, standard training and industry practice.

Members of the ASTQB are software testing experts who volunteer to maintain and promote the ISTQB Certified Tester program in the U.S. They also sit on the ISTQB’s U.S. national board. The ASTQB is a non-profit organization; fees cover administrative costs, the costs of exhibiting at major conventions, and other costs.

Some advantages of obtaining certification through ASTQB/ISTQB:

ISTQB software testing certification is practical: Theory is important, but you work in the real world, and ISTQB certification is meant to solve real-world issues.
ISTQB software testing certification is global: The certification programs were developed by more than 100 global software testing experts, are offered in nearly 50 countries, and have more than 145,000 certified software testers worldwide.
Take the course the way you want to; enroll in a course from an accredited provider, in-house study groups or software testing seminars, or even self-study.
ISTQB is the world’s only not-for-profit organization dedicated solely to providing practical, globally-accepted software testing certification.

INTERNATIONAL INSTITUTE FOR SOFTWARE TESTING

http://www.testinginstitute.com/certification.php

IIST stresses the need to actually learn the material on which you’re being certified, instead of just studying for an exam and receiving a piece of paper. IIST promotes professionalism through education, consulting, publications, industry conferences, and certification.

IIST focuses on Developing a Body of Knowledge (BOK), an essential first step to establishing software testing as a profession. Anyone doing software testing should have a firm grasp of all of the concepts embodied by the BOK. IIST believes that education is the only way to establish testing as a discipline.

The complexity of software systems and the demand of customers and users are constantly increasing. IIST’s training programs enable testers to perform adequate testing of software systems that control different aspects of our lives. Formal academic programs rarely cover even the basics of software testing; this is a void the Institute means to fill.

In 1999, IIST formed an Advisory Board of industry experts and practitioners, with the goal of developing education-based certifications. The IIST Advisory Board strongly believes that the value of any certification program lies in its ability to meet individuals’ diverse needs and interests for both breadth and depth of content so that it helps them improve the way they perform their job on a day to day basis.

Software Testing Methodologies and Techniques You Should Know

Berto — Sun, 19 Dec 2010 13:53:50 +0000

SOFTWARE TESTING METHODOLOGIES

This page lists and explains the most popular software testing methodologies and techniques that are important to know for all software testing.

AGILE SOFTWARE DEVELOPMENT

Agile Software Development

Agile development methods tend to promote teamwork and collaboration. The agile development process isn’t sequential (code, test, debug, release), like traditional development processes; nor is it iterative; it combines concepts of both.

Twelve principles underlie the Agile Manifesto, including:

Customer satisfaction by rapid delivery of useful software
Welcome changing requirements, even late in development.
Working software is delivered frequently (weeks rather than months)
Working software is the principal measure of progress
Sustainable development, able to maintain a constant pace
Close, daily cooperation between businesspeople and developers
Face-to-face conversation is the best form of communication (co-location)
Projects are built around motivated individuals, who should be trusted
Continuous attention to technical excellence and good design
Simplicity
Self-organizing teams
Regular adaptation to changing circumstances

CLEANROOM SOFTWARE ENGINEERING

The Cleanroom Software Engineering process is a software development process intended to produce software with a certifiable level of reliability:

Cleanroom development uses on formal methods in the design and specification of a software product. A team verifies that the design correctly implements the spec.
Development and testing is done using an iterative approach, where functionality is added to the product incrementally (as opposed to creating all of the functionality first, THEN testing it).
Software testing is performed as a statistical experiment.

ITERATIVE SOFTWARE DEVELOPMENT

Iterative Software Development

Iterative development is at the heart of a cyclic software development process; it starts with an initial planning and ends with deployment with the cyclic interactions in between.

Iterative development is NOT the same thing as incremental development, although the two methodologies do complement each other.

Two steps are involved in iterative development:

Initialization: Creates a base version of the system.
Iteration: The current version of the system is analyzed, and is redesigned and implemented based on the Project Control list.

RAPID APPLICATION DEVELOPMENT (RAD)

In place of extensive planning, RAD makes heavy use of prototyping.

In Rapid Application Development, structured techniques and prototyping are especially used to define users’ requirements and to design the final system. The development process starts with the development of preliminary data models and business process models using structured techniques. In the next stage, requirements are verified using prototyping, eventually to refine the data and process models. These stages are repeated iteratively.

RATIONAL UNIFIED PROCESS (RUP)

The Rational Unified Process is a framework intended to be customized by software development teams, for their individual needs. It was created by Rational Software (which is now part of IBM).

RUP emphasises six best practices for modern software engineering:

Develop iteratively, with risk as the primary iteration driver
Manage requirements
Employ a component-based architecture
Model software visually
Continuously verify quality
Control changes

Rational Unified Processing

SPIRAL SOFTWARE DEVELOPMENT

The Spiral Model is an iterative model that attempts to combine advantages of the top-down and bottom-up models of software design.

Spiral Software Development

A preliminary design is created for the new system. This phase is the most important part of the Spiral Model.

A first prototype of the new system is constructed from the preliminary design.

A second prototype is evolved by a fourfold procedure:

evaluating the first prototype in terms of its strengths, weaknesses, and risks;
defining the requirements of the second prototype;
planning and designing the second prototype;
constructing and testing the second prototype.

WATERFALL SOFTWARE DEVELOPMENT

Waterfall Software Development

The waterfall model is a sequential design process comprised of the following steps, each of which must be completed before the next starts:

Design
Construction/implementation
Integration
Testing/debugging/validation)
Installation
Maintenance

XP

Extreme Programming

Extreme Programming (XP) is intended to improve software quality and responsiveness to changing customer requirements. by advocating frequent “releases” in short development cycles, which is intended to improve productivity and introduce checkpoints where new customer requirements can be adopted. Features are not added until they are actually needed. Extreme Programming also encourages programming in pairs, along with frequent communication between members of the development team, and between the developers and clients.

Lean

Lean development could be summarized by seven principles, very close in concept to lean manufacturing principles.

Everything not adding value to the customer is considered to be waste, including:

unnecessary code and functionality
delay in the software development process
unclear requirements
bureaucracy
slow internal communication

In order to be able to eliminate waste, one should be able to recognize and see it. If some activity could be bypassed or the result could be achieved without it, it is waste. Partially done coding eventually abandoned during the development process is waste. Extra processes and features not often used by customers are waste. Waiting for other activities, teams, processes is waste. Defects and lower quality are waste. Managerial overhead not producing real value is waste.

Scrum

Scrum is an iterative methodology used in agile software development.

During each “sprint”, typically a two to four week period (with the length being decided by the team), the team creates a potentially shippable product increment (for example, working and tested software). The set of features that go into a sprint come from the product “backlog”, which is a prioritized set of high level requirements of work to be done. Development is timeboxed such that the sprint must end on time; if requirements are not completed for any reason they are left out and returned to the product backlog. After a sprint is completed, the team demonstrates how to use the software.

V-Model

TDD

Test-driven development (TDD) is a software development process that relies on the repetition of a very short development cycle: first the developer writes a failing automated test case that defines a desired improvement or new function, then produces code to pass that test and finally refactors the new code to acceptable standards.

PAY4BUGS

Pay4Bugs can be an essential part of your testing processes, no matter which methodology you use.

Types of Software Testing

Berto — Sat, 18 Dec 2010 13:55:27 +0000

This is a list of different types of software testing. Once you are at the point of alpha testing or beta testing your product or website, we highly recommend you use Pay4Bugs to get a crowd of software testers to find bugs in your product at the prices you choose!

BLACK BOX TESTING

Testers do not have access to, or knowledge of, the inner workings of the system being tested.Tests are based on requirements and functionality.

WHITE BOX/GLASS BOX TESTING

Testers have knowledge of the system’s internal logic, and in this type of testing, the application logic is what is being tested. When defects are discovered, the tester must examine the code to see exactly where the defect occurred.

UNIT TESTING

Testing of individual software components or modules. Since a detailed, in-depth knowledge of the internal application logic is required, unit testing is normally performed by the developers who are working on the system. Unit testing may require the development of test driver modules or test harnesses.

INCREMENTAL INTEGRATION TESTING

Continuous testing of an application as new functionality or modules are added. This requires the modules to be independent enough to test separately. Incremental integration is done by programmers or by testers.

INTEGRATION TESTING

Testing of integrated modules to verify that they work together properly. Modules can include, but are not limited to, code modules, individual applications, and client and server applications on a network. This type of testing is especially relevant to client/server and distributed systems.

FUNCTIONAL TESTING

Functional testing focuses on the output, and whether it performs as the requirements and specs say it should perform. Functional testing is a type of black-box testing.

SYSTEM TESTING

The entire system is tested to make sure it performs as the requirements and specs say it should perform. System testing is a type of black-box type testing that is based on overall requirements and specifications, and, covers all combined parts of a system.

END-TO-END TESTING

Similar to system testing. End-to-end testing involves testing of a complete application environment in a situation that mimics real-world use. This includes using production components like databases, using network communications, or interacting with other hardware, applications, or systems.

SANITY TESTING

Sanity tests determine if a new software version is performing well enough to accept it for a major testing effort. These tests test the stability of an application. If the application crashes too often for initial use, the system is deemed to be too unstable for further testing.

REGRESSION TESTING

Regression testing ensures that fixes correcting newer defects do not re-introduce problems with older defects. Often, regression testing is automated because it is difficult to cover the entire system with manual tests.

ACCEPTANCE TESTING

This type of testing is performed by the customer to ensure that the system meets their specifications and requirements. Typically one of the last procedures before the user or customer accepts the application for production use.

LOAD TESTING

Load testing checks system behavior under heavy load (e.g. heavy network traffic or database load). Example: testing of a web site under a range of loads to determine at what point the system’s response time degrades or fails.

STRESS TESTING

System is stressed beyond its specifications to check how and when it fails. Examples of components that are stress-tested are: mass-storage capacity, complex database queries, and database load.

PERFORMANCE TESTING

This term is often used interchangeably with ‘stress’ and ‘load’ testing. Performance testing checks whether system meets performance requirements, using different performance and load tools.

USABILITY TESTING

Usability testing checks for “User-friendliness” – in other words, whether or not the application behaves the way the user expects it to behave. Application flow and UI are tested to determine whether a typical user will have any problems using the system, and whether or not the system is properly documented.

INSTALL/UNINSTALL TESTING

Full, partial, and upgrade install/uninstall processes are tested on different operating systems and under different hardware/software environments.

RECOVERY TESTING

Testing how well a system recovers from crashes, hardware failures, or other catastrophic problems.

SECURITY TESTING

How secure is the system? Can the system be breached in any way? How well does the system protect against unauthorized internal or external access? Are the system and database safe from external attacks?

COMPATIBILITY TESTING

Compatibility testing measures how well software performs in different combinations of hardware/software/operating system/network environments.

COMPARISON TESTING

The system is compared against previous versions or other similar products, to determine its strengths and weaknesses.

ALPHA TESTING

Alpha testing is done in an in-house virtual user environment. Alpha testing is done at the end of development. Minor design changes may be made as a result of such testing.

BETA TESTING

Beta testing is typically done by end-users or others. This is the final stage before an application goes into commercial release. An application can be in a “closed beta”, tested only by people who have been invited to do the testing, or a “public beta” where anyone can obtain, test and provide feedback on the application.

PAY4BUGS

Pay4Bugs is a great tool that can be used in many different types of testing environments.