|
Home
Overview
Publications
QA Cluster
People
| |
Content
Emerging trends and challenges
Solution approach: Distributed Continuous QA
Emerging Trends and Challenges
Software quality assurance (QA) tasks are typically performed in-house by
developers, on developer platforms, using developer-generated input workloads.
One benefit of in-house QA is that programs can be analyzed at a fine level of
detail since QA teams have extensive knowledge of, and unrestricted access to,
the software. The shortcomings of in-house QA efforts, however, are well-known
and severe, including (1) increased QA cost and schedule and (2) misleading
results when the test-cases, input workload, software version and platform at
the developer's site differ from those in the field. These problems are
magnified in performance-intensive software, such as that found in
high-performance computing systems, distributed real-time and embedded systems
and the accompanying systems software (e.g., operating systems, middleware, and
language processing tools). This is because this software is increasingly
subject to the following trends:
 | Demand for user-specific customization.
Since performance-intensive software pushes the limits of technology, it must
be optimized for particular run-time contexts and application requirements.
One-size-fits-all software solutions often have unacceptable performance.
|
 | Severe cost and time-to-market pressures.
Global competition and market deregulation are shrinking budgets for the
development and QA of software in-house. In particular, customers are often
unwilling to pay for customized software. The result is that limited resources
are available for the development and QA of highly customizable
performance-intensive software. |
 | Distributed and evolution-oriented development
processes. Today's development processes are distributed across
geographical locations, time zones, and business organizations. This is done
to reduce cycle time by having developers work simultaneously, with minimal
direct inter-developer coordination. But it can also increase software churn
rates, which in turn increases the need to detect, diagnose, and fix faulty
changes quickly. The same is true for evolution-oriented processes, where many
small increments are routinely added to the base system. |
These three trends present new challenges to developers. One major new
challenge is the explosion of the software configuration space. To
support customizations demanded by users, performance-intensive software must
run on many hardware and OS platforms and typically have
many options to configure the system at compile- and/or run-time. For example,
web servers (e.g., Apache), object request brokers (e.g., TAO),
and databases (e.g., Oracle) have dozen or hundreds of options. While
this flexibility promotes customization, it creates many potential system
configurations, each of which deserves extensive QA.
When increasing configuration space is coupled with shrinking software
development resources, it becomes infeasible to handle all QA in-house. For
instance, developers may not have access to all the hardware, OS, and compiler
platforms on which their software will run. In this environment developers are
forced to release software with configurations that have not been subjected to
extensive QA.
Moreover, the combination of an enormous configuration space and tight
development constraints mean that developers must make design and optimization
decisions without precise knowledge of the consequences in fielded systems.
Solution Approach: Distributed Continuous QA
To address these challenges, we are conducting a collaborative research
project called Skoll. Skoll is a general, continuous, feedback-driven process,
supported by automated tools to carry out around-the- orld, around-the-clock QA.
Our approach divides QA processes into multiple subtasks that are intelligently
distributed to client machines around the world, executed by them, and their
results returned to central collection sites where they are fused together to
complete the overall QA process.
Creating Skoll presented challenges for which we have created the following
novel solutions:
 | Modeling the QA subtask configuration space:
We formally model aspects of the QA subtasks and underlying software
that will be varied under control of the distributed process. This includes
not only process and software configuration parameters, but also constraints
among them. To do this, we developed a general representation with
configuration options, option settings, and inter-option
constraints. We also developed the notion of temporary inter-option
constraints to help us reduce configuration space size artificially in
certain situations. |
 | Exploring the configuration space: The
configuration space of a QA process for a performance-intensive infrastructure
system can be quite large. Even with a large pool of user-supplied resources,
brute-force approaches may be infeasible or simply undesirable. Consequently,
we developed techniques to explore/search the configuration space. We
developed a general search strategy based on uniform sampling of the
configuration space and supplemented it with customized adaptation
strategies to allow goal-driven process adaptation.
|
 | Feedback: As subtasks are scheduled
and executed in parallel at several sites, feedback (subtask results) is
collected. QA processes can analyze this feedback and modify their behavior
based on it. We have developed techniques for automatically characterizing
such feedback, visualizing it, and adapting the QA process.
|
 | Resource availability: Since QA
subtasks are assigned to remote machines, volunteered by end users, we cannot
know when resources will be available. Moreover, some volunteers may wish to
maintain some control of how their resources will be used; for example
limiting which version of a system can undergo QA on their resources. In such
cases, it is impossible to pre-compute QA subtask schedules. Therefore, we
have developed scheduling techniques that adapt based on a variety of factors
including resource availability. |
 | Process execution framework: We
developed a new process, called the Skoll process, that provides a flexible
framework to integrate the above mentioned QA techniques and tools. |
|