Testing the user friendliness of an application is called
Usability testing
Let us start with
an example such that we have two applications A & B which are different but
doing the same job. In this, we see which one is user friendly
Given below are
some of the parameters we look into for testing. In this most of them are not
measurable,
ü Speed
ü Help
ü Navigation should
be simple
ü Compatibility
ü Look & feel
ü Features
ü Location of
components
One important
parameter other than the above said parameters is “Effort needed to learn the application”. Some of them define
usability testing like above written in green
Suppose in the
example, we understand the software A in 2 hrs. But we take 4hrs to understand
B. Let us see different cases here,
® since we
understand A in 2 hrs, it becomes user friendly compared to B
® Suppose look & feel is not good for A. In
this case though, we understand A in 2hrs, we cannot say that A is user
friendly.
® Therefore, we
look into many parameters before we say user friendliness of a software
LOOK & FEEL:
The application
should be such that it should be pleasant looking [ suppose if we have red
color text in yellow background, definitely we don’t feel like using it ] and
make a feel to the end-user to use it.
Let us now see some of the examples of Usability testing
1) Consider some of the examples below,
In this example,
we see the Inbox – the most frequently used feature is not kept in the right
place.
End – users
therefore search for the Inbox & after sometime, they find the Inbox lying
somewhere down.
This type of
application may lose the customers because they are fewer users – friendly.
How to overcome this,
See to it that
the important features are placed in the left
navigation bar and top navigation
bar (This is normally followed)
Then we should
see whether frequently used features are easily accessible (like Inbox, Compose
Mail etc.)
While testing, we
therefore have to list all the important features before we start testing an
application
Consider the sketch shown below,
The
end – user to draw the above sketch every time, he clicks Tools -> Draw -> Line for each line and finally he clicks Tools -> Draw -> Line to complete
the sketch.
In this,
we see the end-user wants to draw a simple sketch, but he wastes his time in
clicking each time the Tools -> Draw
-> Line for the sketch. This becomes a waste of time for the end-user.
Therefore,
while testing, we must make user friendly of the application by creating Tool bar which makes the job simple by
clicking on the necessary tools instead of going & clicking each time Tool -> Draw -> Line
3) suppose we have a
shopping website which has 10 pages of product like shown below,
The
question here is – after going to the 10th page – how do we come
back to the 5th page? – Do we click back – after – back – back -> NO -> then how do we do –
Observe,
To
make user friendly application, we always have Bread Crumbs
Bread Crumbs
In
each page, we will have a link to go to its respective page. Suppose we have
seen all the 7 pages & we are in 8th page – that 8th
page will have the link of all the 7 pages – so whatever page (Suppose 5th
page) you like to visit, you click on the link in the 8th page &
go to the 5th page.
If a developer
develops a pop – up window, always
he should keep the Yes button in the
beginning. If he swaps this, then there should be some valid reason behind it.
Generally,
professional Test Engineer(s) should not do usability testing – the reason is
they know where exactly the feature lies & how it works – therefore, for a
TE, everything becomes user friendly in that application.
Therefore, only
end user should do usability testing.
For ex,
The employee /
CEO go & collect the s/w (let us take a game software) & distributes to various end users like kids,
friends etc. Now these end-user(s) use the games software & gives the
feedback to the CEO / employee.
Now this employee
/ CEO look into the feedback & see the major feedback & consolidate all
the feedback report collected from the people.
Ex – if a feature
for all 50 people has been reported, then that it is considered. If a feature
has been reported only by 1 or 2 people, then it becomes minor.
After
consolidating, he goes for fixing the bugs.
One thing we have
to keep in mind is that all the applications cannot be given to end-users &
thus it depends on the application.
For ex,
In case of a banking application – if we develop an
application for manager (call manager as end-user). For others call this
respective person as end-users.
In the example
above – end-users (MANAGER) starts using the application – 2 TE(s) sits at the
back of him & takes report of the defect whether the end-user goes in a
right way as the ydevelop as in a wrong way into the application.Now the manager
checks each link before he clicks on it because he knows the TE is watching
him.
So the drawback
here is – TE came to know they are not getting correct feedback.
Then how to
overcome this? – do we fix camera & take feedback? -> in this , the
end-user becomes more serious & thus it becomes a drawback.
80% of time, we
end up doing usability testing for the reasons above mentioned.
Sometimes TE has
to do usability testing for the following reasons,
Ø Do not want to
outsource to other company
Ø No money to spend
on Usability testing
But there are
scenarios we do Usability testing where we swap the features among TE and do
usability testing.
How to conduct Usability testing? (OR) What process should we
follow to do Usability testing?
Prepare OR derive
checklist (i.e., what are the points to be checked). If we don’t prepare a
checklist, we may miss some features in the application.
For Usability
testing, we should prepare a genuine checklist specific to the product we
develop.
Example of a
checklist for an application,
ü For this
application, one of the checklists includes color of already checked link
should be changed to red
ü All the images
should have alt tag(Tool tip)
ü All the pages
should have link to Homepage
ü Login feature
should have Forgot Password link
Like the above
checklist, we can derive as many checklists as possible based on the
application (or) product.
While deriving
checklist, we should derive a common checklist which can be executed for all
pages.
