Posts Tagged ‘test automation’

SmarteSoft Webinars

Tuesday, December 8th, 2009

Come January, SmarteSoft will begin offering a series of webinars, which we hope will help you better understand all of the benefits of test automation. These interactive lectures, each about an hour long, will be broken down into two basic categories: business issues and technical issues. We’ve come up with a few topic ideas (The Economics of Test Automation, Which Licensing Scheme is Right For You?, and How Can Test Automation Keep Pace with the Speed of Application Advancement?, for example), but we would like to hear your thoughts on what might make for good webinar material.

So: What do you think? Let us know by emailing our sales team.

Tips and Tricks — Refining the Test

Tuesday, September 15th, 2009

Often, we, as testers, are asked for the impossible.  Take, for example, the task of certifying a piece of software which has no defined — or very loosely defined — requirements.  I am not talking about the stories in Agile, but I am talking about the loose development style that typically starts in a meeting where someone says, “wouldn’t it be cool if..” and ends with a developer taking some time to write in the cool.

Requirements exist for a reason: they define the job. By the job I mean, the developer’s job, the marketer’s job, the customer’s job, and the QA department’s job.  Without the requirements being written and debugged (i.e. agreement on goals) there can never be a true SDLC.

As a tester, and a believer in the fact that software should be created to the highest quality standards, I would encourage QA to get involved in the process.  If there are representatives involved from the interested parties, Dev, Marketing, Mgmt, QA, and the customer, people’s needs are going to be met.  Not only that, but the ability to meet real — not perceived — needs will be enabled at a rapid rate.

So you need to get educated as to the goals of each interested party in the chain.   Know what development wants.  Know what management wants.  Know what your customers want.  Once you know the needs you can help to craft a requirement document that satisfies those needs and insures successful deployment.

Breaking Down the Walls

Monday, August 24th, 2009

There was a time in the semiconductor industry where the test assets created during the process were not re-used.  This meant that test engineers were forced to start from scratch each time they developed and implemented a test plan. To make matters worse, there was a giant wall between design and test teams.

There are a number of reasons why this wall was there but, for the most part, it persisted thanks to the very different ways in which design engineers and test engineers then approached their job. As a result, the way in which such accompanying technologies as simulators and programmable test equipment worked echoed the split between design and test. These differences were of course driven by the specific needs and focus of each test environment, a situation which resulted in test data being structured completely differently for designers than it was for testers.

To this day, this difference in mind-set and the way test data is represented persists, but the SemiCon industry has realized the value of design-to-test re-use and has found ways to bridge this gap. The result?  An entire support industry that specializes in technologies designed to convert test data from the formats used by design engineers to a format that can be used by test engineers. This conversion is often an extremely complex task, but tools and methodologies have evolved to the point where re-use of design test data by test engineers is the norm throughout the industry, and has resulted in dramatic savings in test engineering costs and reductions in time-to-market for products that are often characterized by an extremely small market window.  While the wall is still very much intact for now, the results seen here still represented a dramatic, positive shift in the way technology firms view the separation between design and test. As such, it should serve as an example for the high tech sector.

At SmarteSoft, we’re taking the lessons learned in the semiconductor industry and applying them to the wall that divides software development teams from the QA folks who test their applications. With such revolutionary products as SmarteStudio (look for a full release in September) and the forthcoming SmarteScript 6.0, our clients will find themselves suddenly able to integrate development and QA, cutting both costs and time to market, thus improving their ROI. In ten years this may well be the norm. For now, you can only find such revolutionary implementation here.

What we can learn from Tom Watson

Friday, July 24th, 2009

Like many middle aged men in the US, I was enthralled by Tom Watson’s drive to win the British Open last week. At almost 60, a hero and icon of the golf world in the 70’s and 80’s was once more in pole position to win.

This win would have set some records too – including oldest major winner (by far) , and most British Open wins (tied).

On the final hole Tom hit a perfect 8-iron into the green, which landed in the perfect position on the front of the green and then ran straight for the hole. The shot was flawless, but unfortunately for Tom, and millions of fans, the ball kept rolling and rolling and ran off the back of the green.

Long story short, Tom lost.

What could he have done differently to avoid this fate ? Well, nothing that I could see. If a perfect shot is not good enough I don’t know what is.

Once I got past the agony of seeing such a worthy champion be defeated by bad luck at the last instant, this got me to thinking about the software world.

How many times have we seen everything done well leading up to software release, only to see some random event throw everything horribly off course ?

Like the time my development team crunched for months to get a release ready on time, and the QA team tested it every which way, and the Operations team prepared and tested the deployment infrastructure and did practice installations.

Everything was prepared as well as we all knew how. Then, one fine Sunday evening, we pulled together our best and brightest and deployed the software. The DBMS locked up, and nothing we did could fix it, except for a roll-back.

Weeks later that deployment was done successfully. In the interim, we discovered there was an obscure bug in Oracle’s software that caused it to fail under a very specific set of circumstances which we happened to hit during live deployment. This was not Oracle’s fault – no software is perfect. It was not our fault – we tested it successfully in the same configuration many times. It was just bad luck.

Unit testing, manual system testing, ad hoc testing, load testing, regression test automation, and pre-deployment infrastructure testing all failed to spark this problem.

Candidly, I don’t know what else we could have done. Like Watson’s approach on 18 last Sunday, we performed as close to perfectly as is possible and yet still ended up with a bogey on our hands.

So what did we learn ? How did this change our operating processes and procedures ? Well, it didn’t.

I did consider being even more cautious with the rest of the executive team with expectation setting. But if you go around telling your executives that no matter what you do everything may still go to hell, that’s generally not well received. The zone between doomsayer and pollyanna is pretty broad, and you don’t want to skate too far away from center when dealing with the executive team.

At the end of the day, stuff happens. We can improve our odds immeasurably with great preparation, frequent regression testing, etc., but there are no guarantees in life or in software development. (Something I try not to think about every time I get on a fly-by-wire airplane)

The best I can say of that episode, is that there was no finger-pointing and everyone went about their business professionally until we solved the problem.

I hope Tom feels the same way. I hope he was able to accept that luck was just against him on that hole, close the chapter without beating himself up, and move on.

The Agony and the Ecstasy: Deciding When Software is Ready to Release

Monday, July 13th, 2009

One of the most angst-ridden parts of the software development cycle is deciding when your product is ready to release. Functionality, performance, security and quality must be considered relative to specifications, and more often than not a judgment call must be made in the face of strong business pressure to release. Very often, the development cycle runs long and the Quality Assurance team doesn’t get nearly as much time as was scheduled to validate product quality. Still, QA is the final gatekeeper. If QA says ‘yes,’ the product releases amidst celebration. If they say no, there is a collective groan and the developers knuckle down to fix whatever must be fixed. Unnecessary delay hurts the business, just as too hasty a release (with attendant defects and customer complaints) also hurts the business. So the pressure on the QA Director is intense.

So how do you decide when a software product is ready?

Like all things it begins with planning at the start of the project. What are your test coverage goals?  What are your defect rate goals? How many defects of each severity are acceptable? What trend line must be established before you will feel confident releasing?

If these things (and more) are established at the start of the project, while not under intense pressure, and signoff on release metrics is gained from the key stakeholders at that time, then the release decision becomes a matter of keeping good metrics and using a little common sense for judgment calls. But if those metrics have not been established up front–or at least before decision time–then the whole process is fraught with subjectivity and emotion and the chances of someone making a bad decision are greatly increased.

Trend analysis for software quality is a whole art and science in itself, and some excellent books have been written on it. Being able to chart found versus fixed defects and their ratios, total defects of each severity and their trend, and keeping track of the impact of new builds on the stats, is a good starting point. When you’re fixing more than you’re finding, and each new build is introducing proportionately fewer defects than the previous one, while steadily reducing the overall defect rate, then you’re going in the right direction. This requires keeping whatever stats you have decided will be important from day one.

To add consistency to the defect measurement, and enable a rapid test cycle and assessment of quality, test automation is invaluable. By automating regression testing, you get to rapidly measure regressions–another key indicator of the quality trend–and can often spot a bad build almost immediately and scrap it before it does too much damage. Automation of regression testing also frees up your team to use their creativity to find new and better ways to try to break the application under test, and to test new functionality immediately rather than grinding through manual regression testing first.

A good test management tool (which enables everyone to see what is happening in the project based on their role, and includes visibility into the defect database), plus pre-planned metrics/objectives, plus trend analysis, plus test automation makes the release decision relatively stress free. Everyone can see the trend, and a common expectation becomes established that removes much of the emotion, and pressure, from the discussion. The decision on when to pull the trigger and release a product is seldom an easy one, but it can be made easier with careful planning, systematic measurement, and application of the right tools.