Research - Components

CGC

Abstraction

Component-based technology has become the preferred way of producing high quality software systems fast and with less effort. However, component development while offering modularity, introduces a number of dependencies between the different interacting classes, making class dependencies a critical factor in the achievement and performance of component evolution and further component-based system. In this paper, we look at managing class dependencies as the first step towards achieving online, dynamic component evolution. Towards that, we propose a new architecture, CGC, that provides

the isolation of class behavior and class interaction

a hierarchical class dependency graph

For component evolution, this architecture offers:

fast search capability to discover all affected classes for a given change

reduction of the result set of affected classes

minimization of the update process

Another key advantage of our architecture is that its base implementation requires no additional constructs to be added to current existing programming languages. In this paper, we provide an overview of the CGC architecture, an evaluation of its performance compared to other architectures that have been proposed in literature, and a prototype implementation using current Java technology and JML.

The fraction of example illustrates how to implement the school registration system using the CGC architecture.

QoM

Abstraction

Integration of multiple heterogeneous data sources continues to be a critical problem for many application domains and a challenge for researchers world-wide. Schema matching, a fundamental aspect of integration, has been a well-studied problem. However researchers have, for the most part, concentrated on the development of different schema matching algorithms, and their performance with respect to the number of matches produced. To the best of our knowledge, current research in schema matching does not address the issue of quality of matching. We believe that quality of match is an important measure that can not only provide a basis for comparing multiple matches, but can also be used as a tool to provide optimization opportunities for existing match algorithms. In this paper, we define the Quality of Match (QoM) metric, and provide qualitative and quantitative analysis techniques to evaluate the QoM of two given schemata. In particular, we introduce a taxonomy of schema matches as a qualitative analysis technique, and a weight-based match model that in concert with the taxonomy provides a quantitative measure of the QoM. We show, via examples, how QoM can be used to distinguish the ``goodness'' of one match in comparison with other matches. QoM also serves as an important tool to enable users to guide the schema matching process, and as a side-effect provides optimization of the schema match algorithm itself. In this paper, we propose a pruning algorithm that based on the desired QoM is able to apriori reduce the search space for the match algorithm, thereby improving schema match performance.

Description of Dissertation

The software evolution is inevitable as a software system is needed to be continuously upgraded to (1) correct system faults, (2) enhance functionalities, and (3) adapt systems to new environments. Upgrading a software system is always tedious, expensive and time-consuming which is unacceptable for mission-critical software systems such as air traffic control and banking systems. A faster and less-intensive evolution is needed to facilitate online software evolution.

     Current trend shows that component-based technology has become the preferred way of producing high quality software systems fast and with less effort. However, the evolution problem still appears as component-based technology improves modularity, by introducing the use of many components as well as the distribution of behavior among these components, with less evolution concern.

     To achieve the evolution problem in component-based technology, we propose the new architecture, CGC (core-Component::Gateway::Contract), that provides (1) the isolation of component behavior and component interaction between components; and (2) a hierarchical component dependency graph. The CGC then offers (1) fast search capability to discover all effected components based on a given change, (2) reduction of the result set of effected components, and (3) minimization the upgrade process. Its runtime performance appears to be linear degraded as the number of interactions increases beyond 10 but this is highly unlikely. However, its evolution performance appears to be much better than the system implementing with traditional component architecture in both search and upgrade processes.

     Component-based evolution can be categorized into three main types: component addition, component removal, and component modification. To support this, component matching is critical to retrieve all matched components from libraries based a query from a user. Here, we proposed (1) four component matching types: totally exact, totally relaxed, partially exact, and partially relaxed matching types, and (2) the retrieving algorithm using the bottom-up strategy which is guaranteed that based on a query from a user all matched components can be found if they are in libraries. However, this strategy must be optimized to reduce matching times and spaces as contrast to the top-down strategy which consume less time but the matched components may not be found even they are available in the libraries.

To support all these, we plan to contribute the system package consisting of:

The drawing editor for the system architecture with CGC

The conversion system to transform the system architecture to the prototyped system using Java programming language

The evolution system initiating by the evolution of the system architecture

The component matching system

The component composition system

References

Software Evolution

Mark Vidger. The Evolution Maintenance, and Management of Component-Based Systems. In Georage T. Hieneman, William T. Council, Component-Based Software Engineering: Putting the Pieces Together. Addison-Wesley 2001 note

Peyman Oreizy and Nenad Medvidovic and Richard N. Taylor. Architecture-Based Runtime Software Evolution. In Proceedings of the 20th international conference on software engineering. IEEE Computer Society, 1998.

Andreas Rausch. Software Evolution in Componentware using Requirements/Assurances Contracts. In Proceedings of the 22th international conference on software engineering. IEEE Computer Society, 2000.

Ivica Crnkovic, Magnus Larsson

Component Matching

Amy Moormann Zaremski and Jeannette M. Wing. Signature Matching: a Tool for Using Software Libaries. ACM 1995 note

Jun-Jang Jeng and Betty H. C. Cheng. Specification Matching for Software Reuse. ACM 1995

Amy Moormann Zaremski and Jeannette M. Wing. Specification Matching of Software Components. ACM 1997

A. Mili, R. Mili, and R. Mittermeir. Storing and Retrieving Software Components: A Refinement Based System. IEEE 1994