Risk Based Testing

Risk Based Testing is a method for prioritizing the tests based on the risk of their failure because tester cannot test everything within available resource.

To use Risk Based Testing, we normally use following factor to prioritize tests:
- Usage frequency.
- Cost of failure.
- Impact module from change.

We should work closely with business and developer to get this information. We should do other testing techniques (e.g., black box testing technique, automation, regression testing) to optimize the cost of testing as the supplementary tool. After you prioritized the tests, you have to communicate to all of stakeholder about the risk from this testing project because of out of scope tests.

Read More

Tips to improve technical knowledge for tester in Agile Testing

It is important for tester who participates in Agile Testing to improve technical knowledge. This knowledge is essential for discussing with developer. So, I summarize the key things that I normally use for improving my technical knowledge.

Tips to improve technical knowledge

1. Learn the technology and architecture of our software
First of all, we should understand which technology is used for implementing our application and what it is. Then, we should understand the high-level architecture. For example, my project is about web application which consumes data from 3 web services in different server. From this information, you will know the dependency, risk and limitation of our system. For example, the change in web service is the risk in our project.

2. Discuss with developer. Don't be shy.
As we usually use face-to-face communication in agile, this is a good chance to talk to developer in various technical aspects. I normally use this chance to learn the high-level design of new feature. We should not just listen. We should think and analyze the developer's design as well. From this activity, we may find the wrong design and can provide the valid feedback to developers. This is good thing because we can fix the issue earlier.

Read More

What is Regression Testing? Why should we use Regression Testing?

What is Regression Testing?

Regression Testing is software testing activity that is used to ensure that existing functionality has no impact from change in a system, such as functional enhancements, patches or configuration/environment changes. Regression Testing is activity that rerun previously run tests (Existing functionality) and check whether existing behavior has change.

Why should we use Regression Testing?

There are many kinds of change that cause impact to an existing functionality. The simplest change that can have impact is the new version of Operating System. I am quite sure that you used to try to install an application but it was not allowed because of supported Operating System. The reason is that there is possibility that developer have to code in different way for a specific Operating System. So, the new version (change) of Operating System can impact the existing functionality and Regression Testing is required to check if we can support.

The Operating System is not only one thing that can impact your existing functionality. Everything that stays around existing functionality can impact (e.g., web browser, web service, database, another functionality change in the same software package).

From above issue, the Regression Testing is used widely to ensure that the quality of software is good when there is change in software environment.

Read More

Test-Driven Development (TDD) in Agile

Test-Driven Development (TDD) is a developer's process that focus on "Build the test first". First the developer creates the automated unit tests that defines a desired expectation of new function then produces code to pass that test. After that, developers refactor to optimize the code and then, retest it. Passing the tests confirms correct expected behavior as developers build and refactor the code.

Test-Driven Development (TDD) process will help developers save their manpower for unit testing if they have to retest often. So, this process will support Agile method because developers have to deliver working software frequently in Agile.

Read More

Pair Testing in Agile

Pair testing is a practice which two team members are sitting together to test the software application on the same machine. The two team members can be between one tester and developer/business analyst/another tester.

My team has applied this practice and these are benefits that I have found from Pair Testing.
1. Developers will know how testers do software testing. So, developers can apply test strategy for their own testing during coding.
2. Testers will have more idea about how the software works. This will make testers improve their test strategy and see the risk or impact in this code.
3. Tester can use it for on-the-job training to teach new tester by working together between experienced tester and new tester.
4. Face-to-face communication is used follows the Agile method.

This practice is time consuming activity so we should apply this practice if we see the benefit from this knowledge sharing.

Read More

Software Testing in Agile

Software Testing in Agile is a software testing practice which follows the rules of the Agile Manifesto. This agile testing practice involves testing from the customer perspective as early as possible, testing early and often because software will be released very often. To optimize the regression test effort and reduce the number of escaped bugs because of incremental development in agile testing, the automated testing should be used.

Automated Testing of Software Testing in Agile

The test cases are created and will be submitted to the developer before starting of actual development work. This allows the developers to get better understanding of the requirements. Software Testing in Agile requires tester to have more technical knowledge for interacting with developer and business knowledge for interacting with business analyst. The knowledge of testers will be improved continuously because the team will work together daily throughout the project.

Read More

Development Model : Agile Software Development

What is Agile Software Development?

Agile software development is a methodology based on incremental development, where requirements and solutions evolve through collaboration between self-organizing, cross-functional teams.

Agile Manifesto

The Agile Manifesto emphasizes that:
1) Individuals and interactions over processes and tools.
2) Working software over comprehensive documentation.
3) Customer collaboration over contract negotiation.
4) Responding to change over following a plan.
That means we value the items on the left more than right.

Supplementing the Manifesto, the Twelve Principles explain what it is to be Agile.
1) Our highest priority is to satisfy the customer through early and continuous delivery of valuable software. This thing has been done by incremental development. Development has to split the big feature to many small working features and they will be released continuously.

2) Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage. As we have released small working feature, we can get the feedback from customer quicker. Then, the changing can come to development easily.

3) Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.

4) Business people and developers must work together daily throughout the project. As we have short timescale, the quick answer from business and developers are required for both party.

5) Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.

6) The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.

7) Working software is the primary measure of progress. If development cannot release the working software, the small release to customer is unacceptable.

8) Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.

9) Continuous attention to technical excellence and good design enhances agility.

10) Simplicity is essential.

11) The best architectures, requirements, and designs emerge from self-organizing teams.

12) At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly. One activity is the retrospective meeting which is used for continuous improvement in how the team improve the process.

Read More