Multiple Inheritance Research Articles

Heuristic resolution for multiple inheritance in object-oriented expert system building tools

The inheritance dilemma (the problem of determining inheritance precedence) occurs when multiple superclasses have slots with identical names but different values. Multiple inheritance becomes a controversial feature in object-oriented paradigm because of inheritance dilemma. A consistent approach to this problem is necessary. Conventional approaches, such as static and dynamic approaches, were introduced. Static approaches cannot reflect the states of expert systems during inference, i.e., they lack adaptiveness. Dynamic approaches determine inheritance precedence according to inference results, but they rely heavily on functions in expert system building tools (ESBTs). Heuristic resolution is proposed as an alternative. Heuristic functions can simulate static and dynamic approaches, and can be implemented in object-oriented ESBTs. It is demonstrated that heuristic resolution is a dynamic, domain-independent, and general approach for the inheritance dilemma.

A logical design method for relational databases based on generalization and aggregation semantics

In this paper, a series of design methods for relational databases based on generalization and aggregation semantics is set up. The relationship between a class and its subclass is considered as a scheme constraint. The concept of inheritance dependencies, which describes the multiple inheritance among schemes, is presented in the paper. It is shown that the inference rules for inheritance dependencies are sound and complete. Furthermore, a series of results about the closure of inheritance dependencies and the minimal set of inheritance dependencies, which are analogues to functional dependencies, is obtained. In order to describe the aggregation semantics, the concept of aggregation dependencies is given. It is easy to implement these constraints under relational database management systems.

Decomposition of multiple inheritance DAGs for object-oriented software measurement

Decomposition of multiple inheritance DAGs for object-oriented software measurement

Integration Object-Oriented Software Testing and Metrics

Software testing methodologies and metrics are key issues to improve and assure software quality. They are important areas in the research of Software Engineering. However, not many focus on the testing criteria and metrics evaluation of a class hierarchy. This paper introduces an important concept named URI (Unit Repeated Inheritance) to realize integrated object-oriented testing and object-oriented metrics. The approach describes an ILT (Inheritance Level Technique) method as a guide to test object-oriented software errors and measure the software complexity of a class hierarchy. The proposed technique shows that inheritance has a close relation to object-oriented software complexity and reveals that overuse of repeated(multiple) inheritance will increase software complexity and be prone to implicit software errors. Also, two test criteria: intra level first and inter level first are presented.

Order-sorted feature theory unification

Order-sorted feature (OSF) terms provide an adequate representation for objects as flexible records. They are sorted, attributed, possibly nested structures, ordered thanks to a subsort ordering. Sorts definitions offer the functionality of classes imposing structural constraints on objects. These constraints involve variable sorting and equations among feature paths, including self-reference. Formally, sort definitions may be seen as axioms forming an OSF theory. OSF theory unification is the process of normalizing an OSF term taking into account sort definitions, enforcing structural constraints imposed by an OSF theory. It allows objects to inherit, and thus abide by, constraints from their classes. We propose a formal system that logically models record objects with (possibly recursive) class definitions accommodating multiple inheritance. We show that OSF theory unification is undecidable in general. However, we give a set of confluent normalization rules which is complete for detecting the inconsistency of an object with respect to an OSF theory. Furthermore, a subset consisting of all rules but one is confluent and terminating. This yields a practical complete normalization strategy, as well as an effective compilation scheme.

An object deputy model for realization of flexible and powerful objectbases

In object-oriented databases, data and methods are combined by objects and their classes. Information redundancies are removed by the notions of class hierarchy and inheritance. This contributes the realization of high-performance systems. However, the flexibility of object structures still remains a problem due to its encapsulation feature. In this paper, we introduce an object deputy model which extends conventional object-oriented models with the concepts of deputy objects and deputy classes. A deputy object has its own identifier and may possess its own attributes and methods. It can also have attributes that are computed from values stored within its source object, and can be associated with methods generated from these of the source object. The inheritances are realized by switching operations, which make it possible to realize controllable, selective and dynamic inheritance structures. Schemata of deputy objects are defined by deputy classes which can be derived by an object deputy algebra. An object can have many deputy objects, and several objects can share a single deputy object. Thus, objects can be indirectly divided and combined through their deputy objects. We show that several difficult database problems, such as flexible views, objects with more than one role, object migration, and multiple inheritance become much easier in this model. The data-knowledge coordination model developed for the integration of distributed databases and knowledge-bases can also be realized easily by the object deputy model. Finally, we discuss several advanced database applications of this model, such as geographic databases, virtual office systems, and distant education systems.

Higher-order intersection types and multiple inheritance

We study a natural generalization of SystemFωwith intersection types, establishing basic structural properties and constructing a semantic model based on partial equivalence relations to prove the soundness of typing. As an application of this calculus, we define a simple typed model of object-oriented programming with multiple inheritance.

A monotonic superclass linearization for Dylan

Object-oriented languages with multiple inheritance and automatic conflict resolution typically use a linearization of superclasses to determine which version of a property to inherit when several superclasses provide definitions. Recent work has defined several desirable characteristics for linearizations, the most important being monotonicity, which prohibits inherited properties from skipping over direct superclasses. Combined with Dylan's sealing mechanism, a monotonic linearization enables some compile-time method selection that would otherwise be impossible in the absence of a closed-world assumption.The Dylan linearization is monotonic, easily described, strictly observes local precedence order, and produces the same ordering as CLOS when that is monotonic. We present an implementation based on merging and a survey of class heterarchies from several large programs, analyzing where commonly used linearizations differ.

The basic object system

BOS is a prototype-based, object-oriented toolkit aimed at better supporting evolutionary software development. BOS attempts to support a spectrum of activities in one environment---ranging from rapid prototyping to code hardening. Features enabling rapid prototyping include a prototype-based object model, an interpreted language, run-time argument constraints, position and keyword arguments, and a user interface toolkit. BOS also provides features for code hardening such as multi-methods, multiple inheritance, external code wrapping mechanisms, and interfaces to other packages such as database management systems. BOS thus enables the end-to-end programming of software in an integrated and unified environment. BOS has been used to develop several full-size applications which have been evaluated and delivered externally.

On Sandewall's paper: Nonmonotonic inference rules for multiple inheritance with exceptions

Sandewall (1986) presents a theory of multiple inheritance with exceptions (also called non- monotonic inheritance) based on a set of nonmonotonic inference rules, taking advantage at the same time of theories based on nonmonotonic logic as proposed by Etherington and Reiter and of path-based theories as proposed by Touretzky, Horty and Thomason. Flaws in Sandewall's set of rules are shown and a revised set of rules is proposed. This revised set is shown to provide the same conclusion sets on a hierarchy as path-based theories for three classical variants of preclusion. Moreover, although most approaches to inheritance leave it in the metalanguage, it is shown that putting preclusion in the object language provides extensions with desirable general properties which are not always true in the restricted language of conclusion sets.

ROL: A deductive object base language

This paper presents a novel deductive object-oriented database language, called ROL (Rule-based Object Language), which is being developed at the University of Regina. ROL effectively integrates important features of object-oriented databases and deductive databases into a uniform framework. It supports object identity, complex objects, classes, class hierarchy, multiple inheritance with overriding, and schema. It also supports structured values such as functor objects and sets, treats them as first class citizens, and provides powerful mechanisms for representing both partial and complete information on sets. It is an extension of pure valued-oriented deductive languages such as Datalog and LDL (without grouping) and subsumes them as special cases. Another novelty is the introduction of a new ordering which can capture the intended semantics of nested sets. The ROL language is given a logical semantics based on this new ordering that accounts in a clean and declarative fashion for all of its object-oriented and value-oriented features as well as the usage of schema in a deductive framework.

Static correctness of hierarchical procedures

A system of hierarchical, fully recursive types in a truly imperative language allows program fragments written for small types to be reused for all larger types. To exploit this property to enable type-safe hierarchical procedures, it is necessary to impose a static requirement on procedure calls. We introduce an example language and prove the existence of a sound requirement which preserves static correctness while allowing hierarchical procedures. This requirement is further shown to be optimal, in the sense that it imposes as few restrictions as possible. This establishes the theoretical basis for a general type hierarchy with static type checking, which enables first-order polymorphism combined with multiple inheritance and specialization in a language with assignments. We extend the results to include opaque types. An opaque version of a type is different from the original but has the same values and the same order relations to other types. The opaque types allow a more flexible polymorphism and provide the usual pragmatic advantages of distinguishing between intended and unintended type equalities. Opaque types can be viewed as a compromise between synonym types and abstract types.

Explaining inheritance

Programmers new to the object-oriented paradigm often have difficulty learning how to use inheritance properly. In this paper we introduce an approach to explaining inheritance that is based on understanding the nature of reusability. We show how the important aspect of inheritance is interface conformance , and explain the role this plays in supporting reusability. We then outline a method for determining when and how to use both single inheritance and multiple inheritance, and discuss the implications of our approach.

Order independent and persistent typed default unification

We define an order independent version of default unification on typed feature structures. The operation is one where default information in a feature structure typed with a more specific type, will override default information in a feature structure typed with a more general type, where specificity is defined by the subtyping relation in the type hierarchy. The operation is also able to handle feature structures where reentrancies are default. We provide a formal semantics, prove order independence and demonstrate the utility of this version of default unification in several linguistic applications. First, we show how it can be used to define multiple orthogonal default inheritance in the lexicon in a fully declarative fashion. Secondly, we show how default lexical specifications (introduced via default lexical inheritance) can be made to usefully ‘persist beyond the lexicon’ and interact with syntagmatic rules. Finally, we outline how persistent default unification might underpin default feature propagation principles and a more restrictive and constraint-based approach to lexical rules.

Analysis of inheritance and multiple inheritance

Some of the more common descriptions of inheritance, and particularly multiple inheritance, are analysed; these are frequently unclear, and even contradictory, in much of the published literature. Using abstract data types to provide examples, it is shown how a consistent basis for inheritance and multiple inheritance may be built up, which helps to clarify the true meaning of inheritance.

The Opla System: Designing Complex Systems in an Object-oriented Logic Programming Framework

This paper describes the OPLA language, an object-oriented (OO) logic programming language layered on Common Lisp Object System. OPLA allows the benefits of the OO approach to the design, organization and realization of large logic programs thanks to an OO programming environment. Thanks to a deep link with the underlying CLOS language, OPLA offers important features of the OO paradigm, such as multiple inheritance, multi-methods (multi-argument discrimination) and constraint-based control flow mechanism. These characteristics play an important role in OO Prolog programming, improving the readability of the code and augmenting the maintainability of the applications. This paper presents the OPLA language and some experiences resulting from the design and implementation of graphic interfaces which have been realized in OPLA itself. The OPLA programming style facilitates the management of some difficult problems which are basic issues of user-interface development, such as the management of graphical constraints on windows, the distinction of specifying the graphics of objects from their behavior, and law-based delegation. The implementation methodology which was adopted to realize the bulk of the OPLA system is completely independent of hardware constraints; it exploits an incremental, abstract implementation technique based on a high-level generator mechanism. Our approach has been evaluated both in terms of software design and in terms of overall performances. The novel features of OPLA are quantitatively discussed by reporting their impact in the realization of the significant applications.

Open issues in object-oriented programming—A scandinavian perspective

We discuss a number of open issues within object-oriented programming. The central mechanisms of object-oriented programming appeared with Simula, developed more than 30 years ago; these include class, subclass, virtual function, active object and the first application framework, Class Simulation. The core parts of object-oriented programming should be well understood, but there are still a large number of issues where there is no consensus. The term object-orientation has been applied to many subjects, such as analysis, design implementation, data modeling in databases, and distribution. In this paper the term object-oriented programming is meant to cover all these subjects, since one of the advantages of object-orientation is that it provides a unified approach to these subjects. The issues being discussed in this paper are the following: modeling versus reuse as the main benefit of object-orientation; the need for a language independent conceptual framework; abstraction mechanisms for supporting object-oriented programming, including classification and composition, single and multiple inheritance, inner versus super, genericity versus virtual classes and issues related to typing; class-based versus prototype-based languages; and concurrency. The points of view presented in this paper reflect the author's background in the Scandinavian tradition as manifested in the BETA language and the Mjolner project.

Introducing objects and parallelism to an imperative programming language

The problem of enhancing objects with parallelism has been in the focus of numerous research projects in the recent years, but a satisfactory and commonly accepted solution has not appeared yet. A major problematic point seems to be providing inheritance for parallel objects. The general objective of this paper is to contribute to a better understanding of the language design issues in the area of parallel object-oriented programming (OOP) and, in particular, to design a framework for parallel OOP with multiple inheritance. What makes our proposed framework different from the other parallel OOP languages is its easy to use and efficient multiple inheritance for parallel objects. Our framework is easy-to-use because it is designed as a minimal parallel and OOP enhancement of the imperative programming paradigm—a paradigm which is relatively simple, very popular, and well understood. It is efficient for the same reasons and because the implementation of dynamic binding in our proposed multiple inheritance scheme does not require run-time method tables. Dozens of known serial and parallel OOP languages employ run-time method tables which may impose significant space and time overhead, particularly in a parallel environment.

A meta-language for typed object-oriented languages

In [12] we defined the λ&-calculus, a simple extension of the typed λ-calculus to model typed object-oriented languages. This paper is the continuation or, rather, the companion of [12] since it analyzes the practical counterpart of the theoretical issues introduced there. Indeed, to develop a formal study of type systems for object-oriented languages we define a meta-language based on λ& and we show, by a practical example, how it can be used to prove properties of a language. To this purpose, we define a toy object-oriented language and its type-checking algorithm; then we translate this toy language into our meta-language. The translation gives the semantics of the toy language and a theorem on the translation of well-typed programs proves the correctness of the type-checker of the toy language. As an aside we also illustrate the expressivity of the λ&-based model by showing how to translate existing features like multiple inheritance and multiple dispatch, but also by integrating in the toy language new features directly suggested by the model, such as first-class messages, a generalization of the use of super and the use of explicit coercions. An important novelty with respect to previous systems is that we show how to model multiple dispatch also in the presence of a notion of receiver (i.e. of a privileged argument to which the message is passed), a notion that is absent in languages like CLOS.

An algebraic semantics of subobjects

Existing formalisms of inheritance are not sufficient to model the complexities of the kind of multiple inheritance exemplified in C++. Any satisfactory formalism must model the complicating effects of virtual and non-virtual base classes as well as virtual and non-virtual methods. By abstracting the implementational notion of a subobject and formalizing subobject selection, we develop a formalism to model this combination of features. Not intended as a formal semantics of C++, the resulting model should nevertheless provide an essential level of understanding for language theorists and implementors in their dealings with C++ and related languages.