13.ai/CVR.chandra
.m From cchandra@genesis-a.CS.Berkeley.EDU Mon Aug 30 11:29:53 1993
.ls 2
.na
.LP
An ATMS-Based Maintenance Environment for Managing the Consistency of Software Objects

Claudia Chandra

(Professor C. V. Ramamoorthy)
        
(AIRMICS) DAKF11-92-C-0042 and Rome Labs

The inability of software developers to deal with the complexity of
typical software systems is what has led to the software crisis.
Complexity is a problem each time a software developer needs to
understand the various software entities and the interactions among
them. The various tasks during the software life cycle, such as
reverse engineering, testing, debugging, integration, and reengineering
requires detailed knowledge of the relationships between software
components. Our ATMS-based software maintenance environment assists a
software developer to analyze, record, maintain, view, and investigate
dependency relationships between software entities during the process
of understanding and modifying a complex software system. The
capabilities of our system include support tools to analyze and
maintain dependency relationships between software objects at different
levels of abstraction, and to determine the ripple effects of a
modification to a software system. Our research is distinguished from
previous works in the application of the truth maintenance system (TMS),
to the maintenance of software objects (previous works did not
use this technique). The
mechanisms provided by the TMS, such as the maintenance of a
dependency network of beliefs, the propagation of changes in
assumptions to the status of those beliefs that depend on those
assumptions, and the facilities for dependency-directed reasoning makes
the ATMS a suitable technique for maintaining the dependency structure
of software objects and their consistency. Our research also goes
beyond previous software analysis tools, such as the CIA and
Interlisp-D, in the analysis of control and data flow dependencies, and
the abstraction of software entities at different abstraction levels.
By abstracting entities and their relationships at different levels of
detail, our maintenance environment is capable of providing multiple
views of the structure of a software system.

We have developed a loose hierarchical ATMS (LHATMS) to maintain
the dependencies between software objects and a network generator,
which, when given a specification of software objects, automatically
generates an LHATMS dependency network corresponding to the
specification.

We are currently implementing a front-end query system to assist
users in querying the LHATMS-based maintenance environment, and
a program analysis tool that takes a C program and produces
a specification of the input system that can be processed by
the network generator.

By the end of this project, our aim is to provide an environment
that 
supports tools for analyzing a source program, abstracting various
program entities at different levels of abstraction (i.e., control
blocks, functions, subcomponents, components, and modules), and
analyzing the dependencies between these entities. The attributes of
software entities and their dependency relationships are maintained by
the LHATMS component of our system. Using a command line or graphical
interface, which our environment supports, a software developer can
query our system about the effects of various modifications that might
be made to the system. The response can be in the form of an itemized
description or a graphical schematic of all the program entities that
are affected by the proposed change. Using the ATMS, our system can
also provide an explanation of how and why those entities are affected
by the proposed change. The user should be able to control at what
abstraction level the answer to the query is provided. A user can also
request our system to provide information about the structure of a
software system\(emthe relationships among its components from the
highest to the lowest levels of detail. When a modification has been
made to the program, all that needs to be done to update the ATMS
dependency network is to reprocess the program through the analysis
system and update the dependency network accordingly. The effort to
analyze the dependencies and to abstract program entities is comparable
to the effort to compile a program.