Has anyone come accross the term 'friendly user testing' in software dev?

Reading a document and t开发者_StackOverflow中文版he term is in the context "...after several weeks of friendly user testing ..."?

Friendly User Testing usually refers to 'user testing' performed by people outside the development & QA team, but known to the organisation that's conducting the testing.

We've seen it in two cases:

• Predominantly, organisations using their own staff (who should be friendly :-) to eat their own dog food (e.g. the CEO, head of sales, apprentice that joined last Monday... but usually won't include folk from inside the development team)

• And increasingly, organisations recruiting 'paid-for' or 'interested' folk to act as the test bunnies (in the nicest sense of the phrase) for soon to be launched products (e.g. O2s October 2011 VoIP trial to 1000 invited users)

It's 'friendly' - because if they find crashes, bugs, issues, the users are expecting it. And in our case, we're also probably monitoring their usage (with their permission) to fill out a 'diary', whilst performing automated field tests to drive tasks from friendly users that might not be as dedicated as we'd like (and they originally intended)...

"Friendly user testing" was used a lot on a recent conference call I was on, dealing with a project where we had started doing internal UAT. The context it was used in seems to indicate to me that the "friendly" part of "friendly user testing" is to differentiate between "our" testers, e.g. he's a "friendly" (war), and "their" testers, e.g. Charlie's in the rice patties.

Friendly user testing allows minimal client impact because "our guys" supposedly know what they're doing and what they should/shouldn't do in an environment that contains/touches client data that is currently in production that introduces a new piece of software that is at the end of its development cycle. (Existing data & software system plus the addition of a new software system.)

Edit:

I should add that when I say "our" testers I mean those not in the original QA testing phase, but testers that will be using the system in production later... hence "internal" UAT.

A friendly user test (FUT) is a user test of software carried out by people outside the development team, but known to the organization that performs the test.

A FUT is a person agreeing to test and detect bugs in an application or software in a version being deployed (not finalized) and before generalization. The voluntary user of the new service agrees to collect valuable information from developers. The inconveniences generated are transformed into active participation in the resolution of the faults encountered.

Perhaps the documentation is trying to differentiate between testing that is trying to break an application with testing that is being much friendlier - ie testing that is more superficial.

Most developers when testing their own code don't initially test to break the application, they tend to follow the same patterns of use each time - patterns which they will have cleared bugs from. Perhaps this is friendly testing? This is often why demos fail (curse of the demo) - as users new to an application follow fresh patterns which haven't been cleared.

Otherwise it could be a typo, and it should read user friendly testing - testing that is designed to be low impact on users?

Developers typically have their favorite users; users who ask good questions, suggest good features, and are good communicators.

Those users typically get software that's less than perfect before everyone else, so developers can get friendly feedback before releasing it to the ravenous hordes. Being told gently "I don't like the way your foobar works, I'd rather it do something different" is much better than hearing "Those jerks and their idiot foobar, I can't imagine why they wouldn't do it differently."

These friendly users are perhaps also not trying to break the software -- they might be willing to try new features, but they probably won't try to write exploits should they find bugs.