Welcome to EVOLVE Project HOME PAGE
EVOLVE
Overview
The framework of the EVOLVE development consists of two layers:
- The Design and Prototyping Layer.
- The C++ Code Generation Layer.
The Design and Prototyping Layer first translate the given
requirement specifications
(including both structural and behavioral requirements),
that are produced through requirement capturing and specification process,
into the EVOLVE notation, i.e., modeling the structural specifications in
terms of the class dictionary graph notation (see Section~2), and
representing the operational sepcifications
in terms of the propagation patterns (see Section~4).
Since the EVOLVE development takes the Demeter system/C++ as
the experiment base, most of the EVOLVE notation are compatible with
the Demeter notation \cite{karl:demeter}.
After the syntax and semantic checking of the class
dictionary specification and
the propagation pattern schema, The EVOLVE will analyze and
measure the quality of a given schema design by means of the set of adaptive
schema style rules (see Section~3).
Such an analysis is based on enhancing the adaptiveness
and robustness of the schema
in anticipation of future requirement changes.
Based on the analysis results
produced through the schema analysis and evaluation
stage, the EVOLVE will use its schema transformation algorithms to generate
a better style schema for the initial requirement design and specifications.
The modified schema presents relatively higher adaptiveness towards
future requirement changes.
A list of benefits may also be provided, if requested, for demonstrating
why and in what aspects the modified schema is better in terms of adaptiveness
and robustness of the schema design.
In the current implementation scenario, the Code Generation layer
partially uses the Demeter system/C++ to assist in generation of
the corresponding C++ class library and C++ method definitions
for a given class dictionary graph and the set of propagation patterns
ranging over this class dictionary graph.
We are also interested in experiment of mapping the generated C++ code
to a C++ based object schema for a commercial object-oriented DBMS
(e.g., OpenDB, ObjectStroe, O2, etc.).
Outline of the Methodology
We describe the methodology of the EVOLVE development in
Figure 1. It consists of four components: the schema
editor, the adaptive schema style analyzer, the schema optimizer and the code
generator.
-
The EVOLVE object-oriented schema editor is
composed of two components: class dictionary builder and behavioral
specification editor. The former is designed to transform, for example,
an ER-like modeling sepcification into an object-oriented class
dictionary graph. It is also possible to model the
structural/organizational requirements of a universe of discourse
directly through the EVOLVE graphic modeling tool.
The latter intends to translate the given operational
sepcifications into the EVOLVE method definitions in terms of propagation
patterns and the refinement mechanism of propagation patterns.
-
The adaptive schema style checker is also called schema analyzer.
It applies a set of the EVOLVE adaptive schema style rules to the given class dictionary
graph and results in a list of advice for schema modification, a
proposal for transforming the initial schema
design into a better style schema in terms of adaptiveness, and
possibly a benefit report if requested.
-
Upon the agreement with the schema designers,
the adaptive schema optimizer will transform the original schema design
into an ``optimal" schema (class dictionary graph) which presents better
adaptiveness in anticipation of future requirement changes.
A key feature of the schema optimization methods is to preserve the information
capacity of the original design. For example, the EVOLVE supports two kinds of
schema transformation: object-preserving and object-augmenting. The object-preserving
transformation guarantees that both the original and the optimized schema
define the same set of instantiable classes with the same set of (direct or
inherited) properties. While the object-augmenting transformation causes no
information loss although it may change the structure of some objects by
addition of extra parts or additional classes. More importantly,
the distinction of object-preserving
and object-augmenting transformations allows us to enhance the reusability of
the schema transformation primitives and to facilitate the correctness proof
of a given transformation.
-
The code generator is developed based on the Demeter System/C++.
It consists of two main components.
One is to map the optimized class dictionary graph into C++ class dictionary and
to generate header files to be associated with each class.
The other is to translate the methods written
in propagation patterns into C++ application specific
method definitions. The Demeter`s automatic (or semi-automatic) generation of
C++ application specific method definitions is, to our knowledge,
rather unique as opposed to several existing CASE tools that only
generate C++ "static" code (class library and a set of standard member
functions).
We are currently also interested in mapping the C++ result to a
commercial (preferably C++ based) object-oriented database schema.
Project Members and Collaborations
Research Collaboration with
![[Link to UofA]](http://web.cs.ualberta.ca/UAlberta/gif/tiny/UA.gif)
June 1, 1996
Dr. Ling Liu, Assistant
Professor.
Dr. Karl Lieberherr,
Professor.