80% of the Words Used In the Quran Can Be Learnt in Two Months

If you are looking for an easy way to learn Quran the following site would be very helpful.

Start with the video embedded in this site. That gives a lot of useful information on how to use the material.

The brother who made the video, points to an external site and explains how to use it. I tried the links and found some of them are moved, but within the same site, and you can access them using the links provided.

Try it out, and Insha Allah you may benefit a lot!

KDE 4.7 is Delayed in Debian

I think I owe a blog post here because I see a lot of users visit my KDE 4.6 being delayed post. Whenever I login to debian-kde IRC channel, the topic says "No ETA for 4.7." I don't have any other information on the topic. I did look at regular places where I check for info, but could not find any.

As debian is a voluntary project, we can't expect them to commit to a deadline. People have their own lives to live. But, I tried the IRC twice to get some information on why they explicitly say "No ETA for 4.7." It seems there is no special reason for delaying 4.7 other than the usual one, need more helping hands.

I hope people join their hands with Debian.

Update: KDE 4.7 is now available for Debian. 

Defining QA Process for Teams Which Don't Write Test Cases

As I am leading a small QA team on an Open Source company, I have the task of defining the QA Process. The formal QA cycles, and process won't work here.

We have two major teams, one is working on the open source product, and the other one working on customizations of the open source product. The Open Source team is more agile, while the customization team being less agile. We have projects for which presales and estimation done in 15 minutes, development and testing finish in one day.  The largest project so far is two and a half developers working 3 months together, and two testers working both on manual testing as well as automation of basic test cases.

Writing test cases is not in the business model. We send the feature specification to customers and get it signed off before the project starts. The practice of signing the test case document is not there. I have spoken to the project managers, and none want the QA team to write test cases to their products. Since test cases are not signed off, they don't carry much business value for project managers.  For a project that runs one month, they don't want the QA team writing test cases for one week.

Following are some of the reasons why test cases don't provide a good solution to the company.
1. Specs are not written in a way so that business scenarios are easily visible. Rather it describes a small chunk of functionality. This makes it harder to write test cases before the release is made.
2. Test cases are useful if the same set of test cases are executed in multiple cycles. This, usually, is not the case. A story/functionality, is usually tested thoroughly in only one cycle. And there will be defect verifications in one or two more cycles and that's it. This reduces the value for the test cases a lot, and people prefer ad hoc.

I find it harder to define a testing process where test cases are not practiced. Since testing then goes undocumented, it is harder to monitor and control it.

I know that Agile teams don't rely on formal test cases, and they have a different view on testing. I am currently going through  "Agile Testing" by Lisa Crispin, hoping that it will shed some light to the problem.

Today, I found something interesting in the book, which I would like to share with the rest of the world.

Agile testing doesn’t just mean testing on an agile project. Some testing approaches, such as exploratory testing, are inherently agile, whether it’s done an agile project or not. Testing an application with a plan to learn about it as you go, and letting that information guide your testing, is in line with valuing working software and responding to change.

Automating Web Applications - How I Got Started - 3

I am going to explain a tool that I created which stands in between Record and Play Selenese and robust automation code.

You better read my previous post to see why I came up with such a solution.

The purpose of the solution is

1. the tool should be usable by non-technical people as well
2. a single modification of the web application should break only a single unit in the automation suite. For example, if a text box is renamed in the application, it should be possible to fix it only in one place and correct the suite.
3. should allow re-usability. i.e. We should be able to build a block of solid piece and reuse multiple times
4. should support parameterizing the data. 
5. the learning curve should be small, and after that users should be writing test cases straight away without worrying much about building large frameworks.

Bearing the above considerations in mind, I decided to go with a "hack-around of Selenium IDE."
The design had three layers
1. Action layer - containing all the actions. An action is the atomic element which performs a logical action and placed inside an action file.
2. Template layer - Template files are there just to contain action files, and other template files. They are similar to directories which contain files and other directories.
3. Data layer - Data files contain the data of a template file. Parameters of the template file, and the data file should exactly be the same. Data in the data files will be copied to templates, and then to action files.

Let me give three sample action files here. Name of the action is the name of that particular file.

Name of the action file: OpenURL 
param:URL
<tr>
   <td>open</td>
   <td>#URL#</td>
   <td></td>
</tr>

Name of the action file:TypeSearchItem
param:SearchItem
<tr>
  <td>type</td>
<td>id=lst-ib</td>
<td>#SearchItem#</td>
</tr>

Name of the action file: ClickGoogleSearch 
param:
<tr>
<td>clickAndWait</td>
<td>btnK</td>
<td></td>
</tr>


The below template file could hold the above action files.

Name of the template file: SearchGoogle

param: URL SearchItem

OpenURL URL
TypeSearchItem SearchItem
ClickGoogleSearch 

Then I create a data file to hold the data of the above template. It would look like below.

param: URL SearchItem
google.com,mailtoirs.blogspot.com
google.com,orange
google.com,apple
If I run the tool, it will map the data file to template file, correctly replace the parameters in the action files and produce one selenese script which can search google for "mailtoirs.blogspot.com", "orange", and "apple", one after the other.

• Action files are usually created by recording in the Selenium IDE, and then modifying it a bit for parameterizing, and saving as different files. Creating the above example took me less then 5 minutes. 
• The final resulting selenese script is also run using the Selenium IDE. 
• If google changed the name of the search box one day, I would have to rename it simply in one action file (TypeSearchItem), and run the tool to regenerate the selenese script. Had this been a manual recording, I would have to replace it in all three searches manually. 

What I described so far is the essence, and a simplified view of the tool I created. The tool actually contained another layer, suite, which puts templates together and generate a selenium suite.

We got a project where the tool could be used immediately. The project was fairly complex, and the duration was 2-3 months. Myself and another new person, who was a fresher to the field, had to complete the manual testing as well as the automation within the duration of the project. The concept and tool became very handy, and with some struggling, we were able to successfully automate the product to a certain level.

I was hoping to automate the entire base product using the tool. But, as usual manual testing were prioritized, and I did not have a chance to automate for a while. Then, as days passed, the initial concerns and assumptions changed, and that paved the way to another technology to be used. Details will follow in the next post.