knowledge-based software environments, multifaceted architecture, integration of specification and construction, reuse and redesign, information retrieval, case-based reasoning
Introduction
Many software design problems are ill-structured
with
fluctuating and conflicting requirements. Traditional software
design, use and maintenance methodologies are inadequate for
dealing with ill-structured problems. Empirical studies have
shown that those problems are best understood as design
problems in which the design space and requirements unfold
incrementally .
These problems call for an integrated
approach, supporting coevolution of requirements specification
and design construction.
Complex systems are not designed from scratch, but they
evolve .
Complex systems evolve faster if they can be build
on stable subsystems .
Previously solved design problems
and design experiences should be used for informing designers
of possible solutions, failures, or justifications of current
decisions.
The above requirements have led us to conclude that software
should be developed in integrated, domain-oriented, knowledge-based
design environments that support the whole lifecycle of
software -- requirement articulation, design, maintenance, and
reuse. Our goal is to empower software designers and to augment
their capability and productivity through artificial
intelligence and human-computer interaction techniques.
The research described here addresses issues of software
reuse in such design environments. Design environments store
previously constructed design solutions as domain knowledge.
By integrating design creation tools and domain knowledge
bases, our environments based on the multifaceted architecture
support the cycle of location , comprehension ,
and modification
of prestored design objects in one coherent substrate. One
system component, CATALOGEXPLORER, which supports the location
phase in design environments, is described.
Problems of Current Approach for Software Reuse
Reuse in software development should be supported in such a way
that designers can apply previously made design efforts not
only to a final design artifact but also to a design process
and rationale behind the artifact. Truly reusable design
objects can be achieved only when those objects have been
created in the same environment because then a system could
store necessary information along with the development of
objects for later reuse .
Traditional CASE tools fail
because they do not directly support reusing created design
artifacts .
Reuse should be supported in the same context
as the development of the software takes place.
The richer the information spaces are, the more expensive it
is to access, in terms of both computational and cognitive
costs. Designers first must locate information, then
comprehend the retrieved information, and modify it according
to their current needs. Comprehension may directly lead to
further retrieval, modification may require further comprehension.
Software designers should not be distracted by the
information access, which is not their primary concern in
designing software.
Conventional query-based retrieval mechanisms break down
because they assume that humans can articulate what they
are looking for by formulating a highly specific query. Stored
software objects in most software reuse support systems are
represented in terms of a solution domain; namely, final design
solutions. When software designers need those information,
they usually have in their mind application goals, or
requirements, which are represented in a problem domain, but
not concrete solutions. Therefore, they cannot form a specific
query for retrieving such stored objects.
A purely navigational access provided by a browsing mechanism
only partially solves the above problem because it still
requires that the information space has a fairly rigid and
predetermined structure. For dealing with ill-defined domains
there is not one right structure for the information space and
the structure needs to be tailored according to the task at
hand. Moreover, humans may get lost while tracing links among
the information spaces if the search space is large and the
structure is complex .
The Approach
To this end, we have developed a conceptual framework
incorporating evolutionary design and maintenance of software.
The conceptual framework is based on cooperative problem
solving between designers and an integrated, knowledge-based,
design environment, which supports the coevolution of
specification and construction .
The design
environment framework is instantiated by innovative system
building efforts supporting information access in
high-functionality software environments, providing feedback on
partial designs, and enhancing reuse, redesign and end-user
modifiability. We have developed a multifaceted architecture
for such environments, consisting of design creation tools that
support both requirement specification and design construction,
and domain knowledge bases (see Figure 1).
Orthogonal to the elements of an environment, the
architecture supports three basic processes for information
access: location , comprehension , and modification
of stored
design objects. Reuse of design objects is supported by using
the catalog base. The catalog allows designers to reuse various
perspectives of design objects and design experiences in the
domain, either of their own, or of others that used the same
design environments.
The multifaceted architecture enables an innovative
information retrieval technique for complimenting the
conventional approaches in locating design objects stored in
the environments. The architecture takes advantage of the
synergistic integration that conventional information retrieval
systems are lacking. A partially articulated task at hand can
be used to filter out irrelevant information and reduce related
information spaces. It relieves designers of the task of
specifying queries or navigating in information spaces for
retrieval, thereby supporting designers to retain their working
context. The environments then support the designers to
comprehend the retrieved information, which may lead to
refinement of their specification and construction.
CATALOGEXPLORER
CATALOGEXPLORER is a system component of the integrated design
environments based on the multifaceted architecture.
CATALOGEXPLORER illustrates how a designer is supported in
locating prestored design object in the example domains of
plotting data in graphic programming .
The CATALOGEXPLORER augments the frame-based search technique
provided by the HELGON system with the following mechanisms
for retrieving from the catalog, design objects relevant to the
task at hand:
ordering design examples by computed appropriateness
values based on the current specification ( retrieval from
specification ).
analyzing the current construction and retrieving similar
examples from the catalog ( retrieval from construction ).
Retrieval from Specification. CATALOGEXPLORER provides a
questionnaire type specification component that allows
designers to specify requirements to their current task, at the
level of a problem domain. These requirements relate to hidden
features of a design. Hidden features are related to functions
of the design rather than low-level or surface structure
.
For retrieving design objects by hidden feature specifications,
the system must have the domain knowledge for mapping those
features onto the surface structure.
Such domain knowledge is represented by:
specification-linking rules that link each subjective
hidden feature specification item to a set of surface
condition rules (in the integrated environment, this
domain knowledge can be derived from the content of the
argumentation base; see Figure 2).
a metric that computes an appropriateness value of each
design example in the catalog in terms of a partial
specification for dealing with trade-offs among
contradictory specifications (the system then reorders
the examples according to those computed values).
For example, suppose a designer wants to create a program to
plot the results of two persons playing one-on-one basketball.
The designer first specifies some of the requirements using the
specification sheet provided by CATALOGEXPLORER, such as `` need
to illustrate the correlation of the two values '' (see
Figure 2). The system uses domain knowledge in the form of a
