Reuse, CORBA, and knowledge-based systems

John H. Gennari, Heyning Cheng, Russ B. Altman, Mark A. MusenInternational Journal of Human-Computer Studies 1998 · DOI

TL;DR

This paper presents an architecture for building reusable knowledge-based systems using CORBA for distributed component communication. They introduce "mediating components" to isolate adaptations, making it easier to reuse problem-solving methods across different tasks and knowledge bases, thereby reducing development costs.

What Problem Does This Paper Address?

Developing and maintaining knowledge-based systems (KBS) is notoriously expensive. A key strategy to reduce this cost is component reuse, where developers adapt existing software components instead of building from scratch. However, several obstacles hinder cost-effective reuse in KBS:

  • High adaptation costs: Modifying components to fit new tasks or knowledge bases can be time-consuming and complex.
  • Lack of standardization: Different development environments use idiosyncratic ways of specifying components, making it difficult to share them across platforms.
  • Difficulty in finding and understanding components: Without clear descriptions of a component's capabilities and semantics, developers struggle to identify and integrate them.

The authors aim to address these issues by creating a framework for a distributed, platform-independent library of reusable problem-solving methods and knowledge bases.

Methods

The core of their approach is a reuse architecture built upon:

  • CORBA (Common Object Request Broker Architecture): This standard provides a platform-independent way for distributed objects to communicate. By using CORBA, components developed in different environments can interoperate.
  • Mediating Components: These are crucial for minimizing adaptation costs. Instead of directly modifying a problem-solving method or knowledge base, mediators act as intermediaries. They translate and adapt information between the method and the knowledge base, isolating task-specific customizations. This allows the core method to remain generic and reusable.
  • Ontologies: These are used to formally describe the terms and relations within components (methods and knowledge bases). Ontologies help developers understand the semantics of components, facilitating their selection and integration.
  • Knowledge-Base Server: This component provides access to knowledge bases over the network, allowing methods to retrieve information at runtime without needing to load entire knowledge bases. They leverage the Open Knowledge Base Connectivity (OKBC) protocol for this.
  • Legacy Method Reuse: The paper demonstrates the reuse of a legacy problem-solving method, "propose-and-revise," originally designed for an elevator configuration task, for molecular biology problems. This highlights the flexibility of their architecture in accommodating existing code.

Datasets

The paper uses example tasks and knowledge bases from the field of molecular biology, specifically:

  • 30S Ribosome Subunit Configuration: This involves determining the 3D configuration of the ribosome, using experimental data about RNA bases, protein locations, secondary structures, and distance constraints.
  • Transfer RNA (tRNA) Configuration: This involves determining the 3D structure of tRNA, also based on experimental data and constraints.

These are not presented as new benchmark datasets but rather as real-world problems to demonstrate the reuse architecture.

Key Insights and Ideas

  • Mediators are key to cost-effective reuse: Directly modifying components for new tasks is costly and hinders reuse. Mediators abstract away these adaptations, keeping core components generic.
  • CORBA as a unifying standard: Using CORBA enables interoperability across diverse development environments, which is critical for building a shared, large-scale reuse library.
  • Separation of concerns: The architecture cleanly separates problem-solving methods, knowledge bases, and the adaptation logic (mediators), promoting modularity and reusability.
  • Legacy code can be integrated: The successful reuse of the "propose-and-revise" method demonstrates that existing, well-understood algorithms can be incorporated into a modern, distributed architecture.
  • Ontologies are essential for understanding: Beyond syntactic interfaces (like IDL), semantic descriptions via ontologies are crucial for developers to understand and select appropriate components.

Key Results

The paper presents a proof-of-concept demonstrating the proposed architecture. They successfully:

  • Wrapped a legacy "propose-and-revise" method as a CORBA service.
  • Developed mediating components to adapt this method to two distinct molecular biology configuration tasks (ribosome and tRNA).
  • Showcased how a knowledge-base server, using OKBC, can provide access to knowledge bases.

While the paper doesn't present quantitative results on cost savings or performance improvements due to the single example, it establishes the feasibility and conceptual soundness of their approach. The primary qualitative result is the demonstration that a single problem-solving method can be reused across different domains and tasks with minimal adaptation costs through the use of mediators and CORBA.

Limitations and Future Work

Limitations: * Single example of reuse: The authors acknowledge that a single case study is insufficient to make claims about actual work saved or to measure the ease of component retrieval and adaptation. * Mediator construction effort: While mediators reduce adaptation costs, building them still requires effort. * OKBC semantics: There are semantic differences between the OKBC protocol and the Protégé/CLIPS knowledge model that need to be resolved for a complete OKBC server.

Future Work: * Building a larger reuse library: The authors plan to expand their library of reusable components and collect more reuse cases to better assess cost savings and ease of adaptation. * Developing a method-description language: This language would help developers find, understand, and select methods, and could potentially support semi-automatic mediator construction. * Investigating decomposable methods: Breaking down methods into sub-methods could further enhance reusability, allowing developers to swap out specific sub-components. * Semi-automatic mediator construction: Developing tools to automate or semi-automate mediator creation is a long-term goal to further reduce adaptation costs. * Exploring dynamic mediation: For methods that require runtime querying of knowledge bases, dynamic mediation strategies are being investigated.

Summary updated

Abstract

By applying recent advances in the standards for distributed computing, we have developed an architecture for a CORBA implementation of a library of platform-independent, sharable problem-solving methods and knowledge bases. The aim of this library is to allow developers to reuse these components across different tasks and domains. Reuse should be cost-effective; therefore, the library will include standard problem-solving methods whose semantics are well understood and are described with a language for stating the requirements and capabilities of a component. In addition, when a developer needs toadapta component to a new task, the adaptation costs should be minimal. Thus, we advocate the use of separate mediating components that isolate these adaptations from the original component. We demonstrate our approach with an example: an implementation of a problem-solving method, a knowledge-base server, and mediating components that adapt the method to different knowledge bases and tasks.
BibTeX
@article{gennari1998reuse,
  author = {John H. Gennari and HEYNING CHENG and Russ B. Altman and Mark A. Musen},
  title = {{Reuse, CORBA, and knowledge-based systems}},
  journal = {International Journal of Human-Computer Studies},
  year = {1998},
  doi = {10.1006/ijhc.1998.0217},
}
Figure