What are Search Engine Positioning, Organic Search Engine Optimization?

Search Engine Positioning (SEP) includes:
- defining the business,
- set the targets,
- translating the business definitions into search phrases,
- structuring site around search phrases,
- designing pages to attract traffic,
- submitting site to directories and search engines and,
- linking site from other sites and monitoring the results.

Search engine positioning is actually the exact keywords and key phrases or search terms used that your prospective customers will typically write in the search box when looking for a particular product or service.

Organic search engine optimization is a process which improves the unpaid listings of the website in search engines. It involves the optimizing the website in natural way both on page and off page. The benefits of organic seo are:

- Organically optimized websites are often clicked by people. People tend to click on sites that are shown as part of results, not those that are shown as paid results (and search engines also differentiate between them).
- Organically optimized website search results lasts long. A paid result (or where some sort of short term strategy is applied will fail the next time the search engine logic is changed, or the money runs out). If the site makes it because of its own worth, it will only keep increasing in search engine ranking.
- Organically optimized website search results builds greater trust. Putting real and relevant content ensures that your readers will bookmark your blog, share your blog, and trust you more.
- Paid listings are more expensive than organic seo search results. For sites where you want to rank high, it is likely that paid clicks are very expensive, and trying to get more visitors through this route can be expensive.

What are different search engine optimization techniques?

Search Engine Optimization increases your website's appearance in search results. SEO techniques are tasks that would be performed by a Search Engine Optimization Company, when employed by a Client who desires high search engine positions to attract targeted traffic, with the intention of increasing their conversion rates and brand awareness.

- The search engine optimizer should have a long term outlook as SEO algorithms are changing.
- Patience is very important in SEO job and having a proper knowledge of the SEO company is also important.
- Build a good website with good and unique content.
- Site map should be included which tells the hierarchy of the site.
- The URLs should be SEO friendly.
- Select proper keywords and keyword density.
- The page title and meta tags for the page should be unique.
- Pay per click account should be opened.
- Write, keeping in mind and targeting the users.
- Keywords should be used as anchor text which helps to find out what the linked page is about.
- The links should be built intelligently.
- Participate with other blogs.
- Indulge yourself with social media sites and marketing intelligently.
- Links should be appropriate and avoid excessive linking.
- Develop relationships with other sites.

Steps to become a better software tester - can do these over a period of time - Part 12

In previous posts (Improve software testing), I have been outlining steps that can help a tester improve their testing skills. Some of these steps can happen in a short time, and some more steps that will take more time to happen. For example, in the previous post, I had talked about using metrics about the bug generation and interpreting the data to improve the quality of the bugs you log. In this post, I will take some more steps about how you can improve your testing skills:
- See whether you can get some idea about the way your customers think. Reading requirements and designs give you an idea about the customers needs, but you need to understand more about how your customers think. This can be a bit difficult, since getting access to your customers can be difficult. However, there are ways in which you learn.
So, for example, there can be user forums where users write about their experiences, write about the problems they have with their software, and so on. Such forums are a good way for testers to learn about the customer flows, since users will describe what they were doing when they ran into the problem, and other users can add more feedback from their side. Reading such threads helps to learn the workflows that customers use, and such feedback makes the testing done even more realistic, mapping to how the customer actually uses the application.
Another way of understanding customer workflows is to review the bugs that customer log. Most good softwares actually allow users to enter bugs through some sort of work flow, either from a form on a web site, or through an option on the site itself. Reading such bugs will give an idea about the workflows that the customer was using and reading a number of such bugs gives a good insight into customer workflows.

Steps to become a better software tester - can do these over a period of time - Part 11

I have been writing a series of posts (How to become a better tester) on how a tester can acquire the skills needed to become a better tester. There are a number of such steps that a person can do, with some of them being very logical, and some that many testers would not have thought about. Many of these are easy to do, and others are more difficult to do, but all of them are something that testers can do. In this series, I will write more steps that a person can do in order to improve their skills:
- Get into the business of collecting metrics about your test process and its results. These metrics could include the number of test cases written vs. the amount of time taken, the amount of test cases written vs. the complexity of the requirements / code / design (using various measures such as Function Point Analysis or other such parameters). Additional metrics that can be collected including determination of the results of the testing, such as the number of bugs generated on a daily basis, the number of bugs that were accepted as valid bugs, the number of high criticality bugs, the number of bugs that were withdrawn, the number of bugs that were marked as duplicate. Viewing these metrics can help a tester determine the efficiency of their bug logging measures. It is one thing to feel that the bugs you log are important, and that developers are happy that you are testing their feature, but to get a good validation of how you are actually doing, you need to actually do the metrics for these. Ideally, compare your data with that of the other testers, and if you find that a greater number of your bugs are withdrawn as compared to other testers, or if you have a higher number of bugs that are of a lower priority, then you need to improve things. It is only when you find yourself generating these metrics that are among the best in your comparable group that you should feel that you are improving as a tester.
The thing to note about this metrics based analysis is that this is an ongoing thing, with improvements showing up over a period of time. Do not suddenly try to generate high severity bugs, since that may actually cause a reduction in your performance. Analyse what you are doing, how you are doing your testing, and then see the benefits that will happen.

Steps to become a better software tester - can do these over a period of time - Part 10

I have been writing a series of posts (Improve your testing skills) on how to improve your testing skills, with many advice items that will take time to implement, and some items that can be done fairly swiftly. It requires that the tester have the intention of making these changes, and showing their will and determination (since some of them will ask for the tester to put in extra effort). Some more tips for this series are:
- Ensure that you put in a lot of effort to be concise and yet clear in your written communication. A tester has a number of areas where good written communication is required, such as writing test cases, test plans, bugs, and so on. A person who is able to clearly communicate is normally seen in a much better light that somebody whose documentation takes effort to read, or is not clear enough that more information is needed before somebody else can work from that documentation.
- Be sure that you make an effort to check for previous behavior, when working on products where a new version of the product is being done. No developer likes a tester who claims to have found a new bug, and then after some discussion and time spent, it gets discovered that the defect was actually filed in previous versions of the product, and for some reason, was not deemed worthy of fixing in the previous version of the product. A tester will do a check for previous versions of the product having this bug, and also provide this information to the developer. This is true because development time is limited, and sometimes if a bug is present in many versions of the product, and customers have not really raised any issues about this defect, it may be possible to de-prioritize the bug and not put time for fixing the bug.
- Keep yourself updated with latest techniques. There is a lot of research in terms of improvements in testing skills on the internet and in specialist magazines, and a tester can improve their testing skills by reading the latest research and trying out some of the measures advocated by such research.

Steps to become a better software tester - can do these over a period of time - Part 9

In the previous post (How to become a better software tester), I have been writing a series on how a tester can improve his / her abilities. Making oneself a better tester means that you get a much enhanced reputation, your career prospects improve, you get promoted faster, and the better developers seek you out to get their features tested. In this post, I will write some more tips that will help the tester improve their abilities:
- You need to be positive in your approach. The developers will not like this, but if you start with the approach that you will find bugs in your testing, it is more likely that you will find yourself in the best frame in which to find bugs. When a person is in this mode, they are likely to question things and question the feature, and start finding the weak points in the feature that are likely to lead to determining the bugs in the feature.
- Another way in which you can find bugs is by collaborating more with your other testers. One of the weakest points of features is where one feature interacts with another feature - this can be through passing of data from one feature to another, or API's that relate one feature to another, and so on. Testing assignments are normally from one feature to another, so the interaction of one feature with another does not typically get the attention it deserves. If you work closely with the testers who work on the features with which your features integrate, it is likely that you will find more bugs, and this will help in shaking out all the bugs in your feature. This does not happen without spending more effort, whether in working with the other testers, or focusing on the additional testing, but the returns will be worth it.
- Be the person who knows the feature well, even if this means that you are the person who spends the most time reading the designs, reading the specifications, and so on. This makes you the expert on the feature, including when important demos need to be given (which is good for your career), and is also important since you get the feature knowledge necessary for doing some great testing.

What are key elements of Search Engine Optimization Part 2?

Apart from keyword analysis, other important elements of search engine optimization are:

- Page uses HTML links. These HTML links needs to be optimized and is an important element of search engine optimization. The HTML code should consists of search items which tells the search engine what is the page about. The following things should be optimized like page title, page headings, image text and link anchor text.
A good page title will not only be keyword targeted but also will entice a person to click on it in the search results.

- For good search engine optimization, good page content is also important. The content should be of high quality and unique. It should not be copied from other sites. A god content enhances the search.

- The code enhancement process determines your page rank on search engines. It understands the structure or pages of the website.

- Link building becomes very important for search engine optimization. It improves the ranking of the web page or web site.

What are the important elements in search engine optimization Part I?

SEO web design is one of the most appropriate strategies to keep the competition.
A successful search engine optimization has few important elements includes a well targeted keyword focus, strong page element optimization and good quality content.

Keywords are most important element for search engines. These keywords are what search strings are matched against.The most crucial step is to find the correct keyword that can be used to optimize.

- Choosing the right keyword to optimize. It is best to focus on less competitive and highly specific keywords. The keyword should have the property of describing what is the purpose of your website. Also, check whether these keywords are relevant to your website or not.

- The website should be rich in keywords and have good keyword density. It is a measure to judge how relevant is the page.Keeping 5 to 10 keywords is termed as OK keyword density. Keyword stuffing should not be practiced.

- Quality of keywords and their position on the seb page is also very important. Keywords that appear in the heading, title are more effective than the keywords that are placed at the bottom.

- A balance has to be there between url keywords and site usability.
- The contents of page title tag are displayed during search so this is the special place where keywords can be given.

- From an SEO point of view, it is good to have as many headings with good keywords in it. The headings should not be very long as readability becomes difficult.

Steps to become a better software tester - can do these over a period of time - Part 8

In previous posts (How to improve your software testing skills), I have been talking about what are some of the properties that can make you a better tester. Some of these attributes can take some time to acquire, and some of them can happen fairly easily, as long as you are convinced that this is the right thing to do. Here are some more tips that you can implement for making yourself a better tester:
- Learn how to break your application into smaller modules / components. It is always easy to test components, write test cases for them, and so on. A good tester is able to review software applications under testing, and figure out how to break these applications into smaller discrete components for which individual test plans can be written, and even specific testing done for them.
- If you have limited time, then ensure that you write test cases that first describe the functionality that is supposed to work, and then you put the time on writing test cases that cover the functionality where the system is not supposed to work (for example, conditions where very high values are entered, or negative values, and so on). The same logic needs to be put in for the testing where there is time limitations. Typically, it is expected that a system will work for both negative and positive values that are entered, so enough time needs to be entered for the complete set of testing to happen. However, if there needs to be a priority in terms of how much time should be set aside for testing of positive and negative values, then testing needs to be focused on the positive values and then the negative values.
If you do reach a situation where you have to prioritize between testing for positive and negative values, then make sure that you have made your opinion known and your management knows about the amount of testing that is done, and the risks inherent with a reduced amount of testing.

What is Search Engine Optimization? How search engines work?

Search Engine Optimization is a web marketing technique. It's a normal tendency of a user to search the top websites. It becomes really important that your website appears in the top list. This is where search engine optimization comes into picture. It is a technique which puts your website higher than other websites when a particular search is made. SEO ensures web pages to be accessible to search engines and are more focused.
Search Engine Optimization are text driven.

The benefits of search engine optimization includes:
- SEO helps to put your website in the top rankings.
- SEO helps to build the company image and reputation.
- SEO helps in getting more business oppurtunities.
- SEO saves time and money both.
- SEO improves the competitive edge.
- SEO enhances sales.
- SEO improves the target audience.
- SEO improves the return that is got on investment.

The life cycle of search engine optimization includes:
- Generating key phrases.
- Cost per Click compaigns.
- Priortizing the phrases, traffic.
- Feed phrases into SEO.
- Competitor analysis and ranking audit.
- Audit ranked cmpetitor sites.

Some important points to remember about search engine optimization are:
- One has to keep patience. There are no shortcuts available that would make your website in the top list.
- To be able to found on net, the most important thing to remember is to write good and fresh content.
- Write content that is grammatically and factually correct.
- Page titles should be simple yet descriptive and easy to find because page titles links your site from search engine listings.
- Use the h1 - h6 elements for headings.
- The URLs that you use should be user friendly. Use search engine friendly, human readable URLs instead.
- Incoming links are very, very important for SEO.
- Use valid, semantic, lean, and accessible markup.
- Submitting a site to directories and search engines can be useful.

What are different ways to test databases?

Database testing should be kept simple. Database testing would include:

- Database Sandboxes
A sandbox is defined as a technical environment whose scope is well defined and respected. There are various types of sandboxes which can be used to work. In each sandbox, the database is copied. The new functionalities are implemented, existing functionality are refactored, validated in development sandbox and once you are satisfied with work, it gets shifted to project integration sandbox. In project integration sandbox, system is rebuild and tests are run to ensure nothing is wrong.
The advantage of sandboxes is that it helps to reduce the technical errors adversely affecting large number of people.

- Writing database tests
Writing database tests include setting up the test, running the tests using database regression testing tool and checking the results by comparing the current values against the results that you expected.

- Setting up strategies for database tests
To know the state of the database, put the database in known state before running the test suite. Common strategies for doing this is to start afresh and data reinitialization. Strategies for creating test data for writing database tests are having source test data, developing and maintaining test data creation scripts and self contained test cases.

- Database testing tools
There are two kind of database testing tools needed to test RDBMS: testing tools for interface tests and the other for internal database tests. Couple of things to remember here is that testing tools should support the language that you are developing in. Secondly, database should be put in a known state. Some database tetsing tools are:
Unit Testing Tools which enable you to regression test the database.
Load testing tools which simulate high usage loads on your database letting you know whether system's architecture can stand up to that level.
Test data generator are useful when large amounts of data is needed may be for stress and load testing.

Steps to become a better software tester - can do these over a period of time - Part 7

In previous posts (improve your testing skills), I have been mentioning tips that can help you improve your testing skills and become a much better tester. Some of these items will take time to happen, while others can be done much faster.
- Learn about techniques such as code coverage. Code Coverage is a technique that is famous when anybody talks about White box testing. If you are a white box tester, you should learn about what code coverage is, and why it is necessary and useful for white box testers to learn about. Code coverage actually is the way of defining how much of the source code of a software has been tested, using measures such as function coverage, statement coverage, decision coverage, condition coverage, and condition / decision coverage. You also need to learn how much of code coverage is possible (one measure is that 90% of code coverage is a good enough indicator of how much to cover).
- For white box coverage, a white box tester needs to ensure that they have detailed knowledge of the code structure and design of the software. As a part of this, it is required to have knowledge of programming languages, architecture, and design concepts. However, this is not a static field. Anybody who wants to be a good white box tester needs to ensure that they are upgrading their skills, attending trainings, learning new languages that come up, and be in close touch with the development team.
- For the regular white box testing, the tester needs to have gone through the actual design documents for the software, and ask questions where something is not clear. Better to ask rather than to not know something and make a mistake. Further, if there are mailing lists within the team where the developers talk about design issues, a white box tester should join such lists and get informed about all such changes.

What are Relational Database Management Systems? What is the need to test RDBMS?

Relational Database Management Systems cntains critical data which is updated by many applicatins and many end users. They provide important functionality as well. It is very important to test the functionality of relational database management systems. A regression suite should be made available and testing should be done on a regular basis.

The need to test a relational database management system is necessary because data is a very important asset and all the critical business related functionality is implemented in relational database management system. Generally, data professionals used to control changes and do formal testing but this approach did not proved to be efficient so because of the current approaches not being very efficient, there arises the need for relational database management system testing. Also, testing is a way to provide feedback that could be used to identify defects.

RDBMS testing should test the following :
- Black box testing at the interface which includes data values being persisted, data values being retrieved and stored functions and procedures.
- White box or clear box testing tests within the database. It includes scaffolding code which supports refactoring, unit tests, existence tests for database schema elements, view definitions, referential integrity rules, data invariants involving coloumns, data invariants for single column.

A test-first development(TFD) approach is used by agile software developers where a test is written before writing enough production code to fulfill that test.
- Add a test.
- Run the tests
- If it passes, again add a test otherwise make a little change and again run the tests.
- If it fails, again make a little change and run the tests.
- If it passes, the development stops.
- Once the test passes, again start over.

Test Driven Development(TDD) combines test first development and refactoring. When a new feature is implemented, the question whether this is the best design hwich enables the developer to add this feature is asked. If the answer is yes, then do the work and proceed. If the answer is no, design is refactored and then test first driven (TFD) is done.

What are different testing mechanisms used to test the sofware?

After deciding the inputs and outputs for the test cases, another issue that comes into picture is writing the code that actually tests the software. Following mechanisms can be used to write codes:

- TEST DRIVERS
The lower level modules can be tested by using a test driver program. Approach that is used is to write a program that passes input data to the unit under test and comparing the output to truth. Input is selected from uniform testing, Monte Carlo testing, selected input conditions or from manufactured data. Output is compared against trusted results using an inverse function or a file containing correct data.

- WHITE BOX TESTING
Test drivers can also be used to test several modules at once to save time if you are doing white box testing. White box testing taken advantage of the internal working of the module under test. This approach saves time but disadvantages include while testing several things together, you may get a right answer indicating that everything is right but if you do not get the right answer then you are not sure what went wrong.

- BLACK BOX TESTING
This testing does not depend on the internal working of the module unde test. It only depends on the inputs and outputs of the system.

- TEST STUBS
Test Drivers are high level routines that call lower level subprograms, test stubs can be used to test higher levels of program. Stub is a simple routine that takes the place of real routine. It may be a null procedure or it may have a simple message. There is no need for test stubs to be limited to fixed data or user supplied data. Stubs need not be just input stimulators. Stubs also display or record data sent to them.

- TEST AND DEMO PROGRAMS
A test program usually does not involve much operator intervention. A demo program is a quick confidence check.

Steps to become a better software tester - can do these over a period of time - Part 6

In the previous post, or series of posts (how to improve software testing), I am writing about how to improve the abilities of a person who does testing. In this article, I will provide some more details about what a tester can do to improve their skills in this post:
- Learning about scripting. Scripting is one technique that is beneficial to tester in many ways. There are many applications and software that have a testing interface. Being able to use these scripting interfaces can help automate some of the work of a tester; further, it is not necessary that time for this activity would be budgeted as part of the regular product activities. A tester can increase the amount of time available for regular testing and reduce the time spent on repetitive testing by using options such as Scripting. Knowledge of scripting is also useful for helping out in many of the activities of the tester on a regular basis.
- Automation. Automation is one of the techniques that ensures that continuous and repetitive tasks can be done through a software application rather than a tester doing it. Automation ensures a higher amount of coverage, and you have the option of setting up a list of automation test cases which ensure that a certain percentage of test cases can be run every day when the new build comes in. However, automation is not everyone's cup of team. Automation is typically done by those team members who have shown interest in learning about automation techniques, or those who have shown some interest in scripting (and this is normally seem to be present in people rather than all the team members being asked about whether they would prefer to do scripting or automation testing).
- Being able to adapt to new methodologies. New methodologies such as Agile, Scrum, etc have made it into the software development community and it makes sense for testers to know about these technologies (they can show the lead to their team for such methodologies) and not seem to act such that they are standing in the way of such methodologies.

Steps to become a better software tester - can do these over a period of time - Part 5

I have been writing a series of posts (How to become a better tester) about how a tester can slowly and steadily acquire a variety of skills that improve their skills and make them a much better tester, ensuring a better career and more respect. Here are some more tips that can help you in this quest:
- People working with a tester can typically figure out the tester who is laid back and the one who they can trust to make sure that their feature is of high quality. They would prefer a tester who is involved in the process from the beginning, who asks a lot of questions (relevant ones, not questions just for the purpose of questions), who contributes to improving the product and the process. A tester may irritate the developer by asking a lot of questions, but if these are relevant questions and help the developer in uncovering more defects, such help will be well appreciated. I have this transformation happening in a tester when the tester learnt that they were rated average and did some amount of comparison to see what a developer and the test manager would appreciate.
- Learning more about the intricacies of how the system / application is built. Typically when there is a black box system, the tester is just expected to know the various input and output variables for the system; however, a good tester will also try to explore to some extent white box related information for the system. The tester will try to learn about the way that different components in the system interact with each other, so that it also becomes easier to identify the areas that need more attention. This may require the tester to learn about the system design to some degree, but all of this is very much possible for a determined tester to do (it is only in some amount of applications where the tester does not have the ability to learn about the system design and the interactions between the various components in the system).

Steps to become a better software tester - can do these over a period of time - Part 4

In previous posts, I have been talking about how a tester can continually improve their expertise, gaining a good reputation as a skilled tester (something that is likely to help the tester both professionally and in terms of career climb). I will continue with more topics in this post, and if you reading these articles, I hope that this helps you a lot in your effort to become a better tester. If there are any specific experiences that you want to contribute, please put them in the comments, and I will get in touch with you for more details.
- Always do testing with an open mind. You may have had experiences with different developers and may have made some judgments about them in terms of which developer is more likely to have defects, which one has lesser defects and better quality of code. However, keep in mind that many of these properties also depend on the situation, and a developer, when faced with a tough time crunch and under a lot of pressure, can tend to make more mistakes than normal. So, do not make any assumptions while doing your testing, and make sure that other people can depend on your testing pass.
- Learn about new technologies, keep ahead of the curve. Over a period of time, there are a number of new technologies that can hit the market, and many of these can become very important in the testing community (one such example has been the use of scripting tools and automation tools to provide an automation testing strategy). If you have shown interest, and learned something about these tools and practices, there is a much higher chance that you will be selected when the group decides to get its feet wet with respect to automation and you would be the spearhead of this effort, which can be good for your career.
- One needs to be level headed, and not get irritated easily. It is seen in many cases that developers can take their own time to fix bugs, and this can irritate a tester (I have seen cases where the tester expresses feelings that their work is of no value since the developer did not even look at some of the defects for weeks altogether). A good tester should not show irritation over such matters, but instead raise the issue in proper forum so that this is seen as a problem with a solution required.

Some best practices that contribute to improved software testing Part III

There is always a search for best practices going on. Some are well known and some hidden. Testing does not stand alone. It is intimately dependant on the development practices. These practices have come from many sources. These practices can be divided in three parts:
- Basic Practices
- Foundation Practices
- Incremental Practices

The incremental practices include:
- Teaming Testers with Developers
This practice should understand the kinds of teaming that are beneficial and the environments in which they are employed. This practice should be more than just a concept.
- Code coverage
Code coverage is the numerical metric that measures the elements of code. this practice should include the information about the tools and methods of how to employ code coverage and track results.
- Automated Environment Generator
Setting up test environments to execute test cases is the most difficult task. This practice should capture the issues, tools and techniques that are associated with setting up the environment, the break down and automatic running of test cases.
- Testing to help ship on demand
Testing process should be viewed as one that enables changes that occur late and handles market pressures and still do not break the product or ship schedule. This practice should identify how to work this concept in organizations.
- State task diagram
State transition diagrams are used to capture functional operations of an application. It allows you to create test cases automatically. This practice has more than one application and one need to capture the tools, methods and uses.
- Memory Resource Failure Simulation
This practice addresses loss of memory because of poor management or lack of garbage collection. It should develop methods and tools for use on different platforms and language environments.
- Statistical Testing
the concept of statistical testing is to use software testing as a means to assess the reliability of software as opposed to a debugging process. It needs to work on the software along an operational profile and measuring interfailure times used to estimate reliability.
- Semiformal Methods
A semi formal method is one where specifications that are captured may be in state transition diagrams or tables that can be used for even test generation.
- Check-in tests for code
Check-in tests couple an automatic test program with the change control system. the chances of the code breaking the build are minimized.
- Minimizing regression test cases
To minimize regression tests, several methods are there out of which one method looks at code coverage and distill test cases to a minimal set. Sometimes, it does confuse a structural metric with a functional test.
- Instrumented versions for MTTF
Mean time between failures(MTTF) can be measured if the failures are recorded and returned to vendor. It enhances the quality of the product that is meaningful to user. It also captures first failure data that benefits the diagnosis and problem determination.
- Benchmark Trends
This practice could be initiated by benchmarking and then advance the practice to include a large pool with customers and competitors.
- Bug Bounties
These are the initiatives that charge the organization with a focus on detecting software bugs.

Some best practices that contribute to improved software testing Part II

There is always a search for best practices going on. Some are well known and some hidden. Testing does not stand alone. It is intimately dependant on the development practices. These practices have come from many sources. These practices can be divided in three parts:
- Basic Practices
- Foundation Practices
- Incremental Practices

The foundational practices include:
- User Scenarios
User scenarios are developed to test the functionality of applications when multiple software products are integrated. User scenarios test the product in a way that it reflects customer usage. It also reduces complexity of writing test cases. This practice should capture methods of recording user scenarios and developing test cases based on them.

- Usability Testing
Usability testing not only tests how usable a product is but also provide feedback on methods to improve user experience. A good user experience is very necessary. The best practice for usability testing is that it should have knowledge in area of human computer interface.

- In-process ODC feedback loops
Orthogonal defect classification or ODC uses deect stream for precise measurability into product and process. The advantage of ODC is that it has the ability to close feedback loops which has proved to be cost effective and process improvement.

- Multi release ODC/Butterfly profiles
This technology or practice allows to make strategic decisions to optimize development costs, time and quality issues by recognizing customer trends, patterns and performance of the product.

- Test Planning Requirements
Requirements management and preparing test plans out of it is an important step to check whether they are meeting the customer needs or not. This practice is understood and executed with a holistic view.

- Automated test generation
There are many automated tools to generate test cases which help in software testing.this practice needs to understand which of the methods are successful and in what environments they are viable. A good amount of learning is needed to learn these tools.

Some best practices that contribute to improved software testing

There is always a serach for best practices going on. Some are well known and some hidden. Testing does not stand alone. It is intimately dependant on the development practices. These practices have come from many sources. These practices can be divided in three parts:
- Basic Practices
- Foundation Practices
- Incremental Practices

The basic practices are like training wheels which you need to get started and when you take them off, you know ow to ride. The basic practices include:

- Functional Specifications
It is basically a development activity but it is also necessary for software functional test. It defines the external view of an object or procedure. It helps the test generation activity to move in parallel with code development. It helps in the clarity from designer's and an architect perspective.
- Reviews and Inspections
Software reviews and inspection provides a ten times gain in debugging process.
- Formal entry and exit criteria
This practice offers a careful management of software development process. Every process step has a precise entry and exit criteria defined by development process and management keeps a track of the movement from one stage to another.
- Functional test varaitions
This practice involves understanding how to write variations which refers to combination of input condition to yield a output and gain coverage to thoroughly test the function.
- Multi platform testing
Today products run on different platforms so the necessity arises of designing and testing the product for different platforms. This practice addresses aspects of multi platform development and testing.
- Internal betas
Beta means the product is released to few customers and their feedback is recorded. This practice deals with beta programs to best levarage it and reduce cost of external beta.
- Automated test execution
Using automated test execution, the amount of manual work is minimized and higher coverage is gained. This is the best practice which is well understood in some areas. This practice needs to levarage and then develop methods for areas where automation is not fully done.
- Beta programs
- Nightly builds
Nightly build captures frequent builds from changes that being promoted. Advantages include firstly, errors are captured quickly if major regression occurs. Secondly, regression tests can run in background. Thirdly, newer releases of software are available to developers and testers sooner.

Steps to become a better software tester - can do these over a period of time - Part 3

In this series of posts (Improving testing skills), I have been writing about how to improve the testing capabilities of tester, and have presented some points that could help a developer. In this context, here are some points that could help the tester to improve their skills.
- The tester needs to improve their knowledge of the product. I once had a case where the tester had a series of test cases to execute and did not really have the time to get detailed knowledge of the product. So when there was a change in design and features, and the test cases had to be re-done, the tester did not have the knowledge to quickly make the changes. It took time, and the tester had to face flak because of the time involved, and was also berated for a poor knowledge of the product (and there was really no defence of this lack of knowledge).
- Domain knowledge of the area. A skilled tester will make the time to learn about the domain in which they are testing. For example, if an application is being written for the banking domain, then it would help for the tester to get a quick understanding of the concepts of the banking domain, especially the specific areas which the application is expected to cover. In my previous experience, I have seen that this helps the tester ask informed questions, and also be able to better review the test cases for completeness.
- The tester needs to focus on the more critical parts of the application first, and check those areas first in terms of testing. It is a reality that no application is 100% bug free (or rather, the amount of effort and cost required to make an application bug free is exorbitant), and hence it is key that the tester has found more of the bugs in the application that have a high priority and severity, and the bugs that are remaining in the application are less severe, and have a lower customer impact.