What Testing is all about ?

Software Testers should be passionate enough to test the application.There should be no compromise on 'Quality' when it comes to Software Testing.'Quality' should be the prime consideration for any Software Tester no matter they are doing Manual or Automation Testing. 

I try to portrait a picture by reflecting my thoughts about What Software Testing is all about ? 

1. Testing is about quality

Testing is about providing quality product to the user.

• Quality in the form of Usage.
• Quality in the form of Data integrity.
• Quality in the form of Look and Feel.
• Quality in the form of Security.
• Quality in the form of Performance.

2. Testing is about thinking like a customer

Being a tester, we should have mind set to think that:

• Does the software under test works well as per the desired requirement of the client(who will going to use this software) 
• Is it easy to understand ?
• Is the software that we are testing have the good GUI(Graphical User Interface) features that helps in making the application more user friendly? 
• Test should think from the point of view of a very intellect user,  lay man person and from those users as well who have the tendency to do experiments on application by putting invalid data.

3. Testing is about coverage

It's very vital to test the application from all aspects.List of features to be tested with all the boundary conditions should be well defined before initiating the project. It helps in making sure that no feature is left untested and testing should be done from all prospective of implementing positive and negative test cases.

4. Testing is about finding defects

Software testing is done with the intention to find defects and to raise the quality of software by making sure that it meets all the requirements of client with no show stopper issues. Defects should be raised as soon as they are found with the relevant data.At times it happens that we ignore some issues considering it as minor User Interface issue but every valid issue raised and then rectified by development team add on the quality of software.

5. Testing is about simplicity

Complex system is always a tough deal to develop and to understand.Being a tester we should always think from customer or client prospective.We should always come forward with the suggestions as enhancements.I suppose those who have the skill to put forward their thoughts and can have ability to justify them always rise best in software Testing domain.

6. Testing is about collaboration

Testing is an activity , it cannot be performed alone. As an software tester it's very important to have good skill set of communication and should have good convincing power as well.Let's say if we do not collaborate with other teams like design, development etc then probably we have no one to whom we can raise defects.

7. Testing is about time management

Testing is about management , as the more critical issues we detect in the early phase the more time we get to test the application in better way.Defects found later in the life cycle impacts on the cost and time as well.

8. Testing is about attitude

Surely last but not the least , Software testing is about attitude that how you take the responsibility to put best of your efforts to generate quality by showing and emphasis on issues that you detect in the project you test.

How to do Planning in Agile environment ?

Agile planning is nothing more than measuring the speed a team can turn user stories into working, production-ready software and then using that to figure out when they’ll be done.

• Our to-do list on an agile project is called the master story list. It contains a list of all the features our customers would like to see in their software.
  
• The speed at which we turn user stories into working software is called the team velocity.
• It’s what we use for measuring our team’s productivity and for setting expectations about delivery dates in the future.

The engine for getting things done is the 'Agile Iteration' - one to two week sprints of work where we turn user stories into working, production-ready software.

To give us a rough idea about delivery dates, we take the total effort for the project, divide it by our estimated team velocity, and calculate how many iterations we think we’ll require to deliver our project. This becomes our project plan.

# iterations = total effort / estimated team velocity

For example:

# iterations = 100 pts / 10 pts per iteration = 10 iterations

Now, as we start delivering, one of two things is going to happen. We are going to discover that a) we are going faster than expected or b) we are going slower than we originally thought.

• Faster than expected means you and your team are ahead of schedule. Slower than expected (more the norm) means you have too much to do and not enough time.
• When faced with too much to do, agile teams will do less (kind of like what you and I do when faced with a really busy weekend). They will keep the most important stories, and drop the least important. This is called adaptive planning and it’s how Agile teams work within their budgets and keep their projects real.

How does Agile Works?

1. You make a list

Sitting down with your customer you make a list of features they would like to see in their software. We call these things user stories and they become the To Do list for your project.

2. You size things up

Then, using Agile estimation techniques, you size your stories relatively to each other, coming up with a guess as to how long you think each user story will take.

3. You set some priorities

Like most lists, there always seems to be more to do than time allows. So you ask your customer to prioritize their list so you get the most important stuff done first, and save the least important for last.

4. You start executing

Then you start delivering some value. You start at the top. Work your way to the bottom. Building, iterating, and getting feedback from your customer as you go.