Multiple Inheritance Research Articles

Minimizing row displacement dispatch tables

Row displacement dispatch tables implement message dispatching for dynamically-typed languages with a run time overhead of one memory indirection plus an equality test. The technique is similar to virtual function table lookup, which is, however, restricted to statically typed languages like C++. We show how to reduce the space requirements of dispatch tables to approximately the same size as virtual function tables. The scheme is then generalized for multiple inheritance. Experiments on a number of class libraries from five different languages demonstrate that the technique is effective for a broad range of programs. Finally, we discuss optimizations of the row displacement algorithm that allow dispatch table construction of these large samples to take place in a few seconds.

Bidirectional object layout for separate compilation

Existing schemes for object layout and dispatch in the presence of multiple inheritance and separate compilation waste space and are slower than systems with single inheritance. This paper describes the bidirectional object layout , a new scheme for object layout that produces smaller objects and faster method invocations than existing schemes by automatically optimizing particular uses of multiple inheritance. The bidirectional object layout is used for the programming language Theta, and is applicable to languages like C++. This paper also demonstrates how to efficiently implement method dispatch when method signatures are allowed to change in subclasses. Most current statically compiled languages require identical signatures for efficiency.

Extensible organization of property descriptions in object modelling for engineering design

Object-oriented information systems capturing engineering-design property information run into a problem of extensibility. While class hierarchies defining generic engineering information may be developed according to a classification based on science and general-purpose engineering, this leaves aside special-purpose properties such as those inspired by a particular type of artefact. These properties may be the deciding factor in a particular design application of the data system; thus the ability to 'add in' property descriptions specified for a specialist view of a design function within an enterprise often determines the practical usefulness of the object model adopted. Partitioned classes are proposed as a modelling mechanism which addresses the need for 'upward customization' of generic knowledge. The solution allows the extension of any class to be partitioned between general- and special-purpose members. Advantages of this scheme over multiple inheritance are demonstrated using relational analysis, and they are illustrated by its implementation within an information retrieval system for the visual display of property data.

Type inference of SELF: Analysis of objects with dynamic and multiple inheritance

AbstractWe have designed and implemented a type inference algorithm for the SELF language. The algorithm can guarantee the safety and disambiguity of message sends, and provide useful information for browsers and optimizing compilers.SELF features objects with dynamic inheritance. This construct has until now been considered incompatible with type inference because it allows the inheritance graph to change dynamically. Our algorithm handles this by deriving and solving type constraints that simultaneously define supersets of both the possible values of expressions and of the possible inheritance graphs. The apparent circularity is resolved by computing a global fixed‐point, in polynomial time.The algorithm has been implemented and can successfully handle the SELF benchmark programs, which exist in the ‘standard SELF world’ of more than 40,000 lines of code.

Denotational semantics of a simple model of Eiffel

A simple abstract model of Eiffel is introduced, and its denotational semantics is defined using VDM style. A static analysis approach is presented to treat multiple inheritance and renaming mechanism. Within the framework of denotational semantics introduced in this paper, the key features of Eiffel, such as identification, classification, multiple inheritance, polymorphism and dynamic binding, can be adequately characterized.

On the declarative and procedural semantics of deductive object-oriented systems

We present declarative and procedural semantics for a deductive object-oriented language, Gulog. The declarative semantics is based on preferred minimal models. We describe both bottom-up and top-down query evaluation procedures and show that they are sound with respect to the declarative semantics. The results contribute to our understanding of the interaction of inheritance, overriding and deduction in the presence of both functional and set-valued methods, and multiple inheritance.

REFERENCE CLASSES AND MULTIPLE INHERITANCES

The reference class problem in probability theory and the multiple inheritances (extensions) problem in non-monotonic logics are special cases of conflicting beliefs. One popular solution accepted in the two domains is the specificity principle. By analyzing an example, several factors beyond specificity are found to be relevant to the priority of a reference class. A new approach, Non-Axiomatic Reasoning System (NARS), is discussed, where these factors are all taken into account. It is argued that the solution provided by NARS is better than the solutions provided by probability theory and non-monotonic logics.

EX6AFS: A data acquisition system for high‐speed dispersive EXAFS measurements implemented using object‐oriented programming techniques

In this paper we describe the design and implementation of a computerized data‐acquisition system for high‐speed energy‐dispersive EXAFS experiments on the X6A beamline at the National Synchrotron Light Source. The acquisition system drives the stepper motors used to move the components of the experimental setup and controls the readout of the EXAFS spectra. The system runs on a Macintosh IIfx computer and is written entirely in the object‐oriented language C++. Large segments of the system are implemented by means of commercial class libraries, specifically the MacApp application framework from Apple, the Rogue Wave class library, and the Hierarchical Data Format datafile format library from the National Center for Supercomputing Applications. This reduces the amount of code that must be written and enhances reliability. The system makes use of several advanced features of C++: Multiple inheritance allows the code to be decomposed into independent software components and the use of exception handling allows the system to be much more reliable in the event of unexpected errors. Object‐oriented techniques allow the program to be extended easily as new requirements develop. All sections of the program related to a particular concept are located in a small set of source files. The program will also be used as a prototype for future software development plans for the Basic Energy Science Synchrotron Radiation Center Collaborative Access Team beamlines being designed and built at the Advanced Photon Source.

Single versus multiple inheritance in object oriented programming

Inheritance is one of the key elements of Object oriented programming. Inheritance is characterized as single or multiple depending on the number of classes a class can inherit from. Single inheritance is simple but restrictive. Multiple inheritance on the other hand is complex but allows a more natural definition of relationships between classes. There has been a significant amount of discussion on the value of multiple inheritance over single inheritance considering the complexity multiple inheritance adds. This paper reviews the two types of inheritance and examines their benefits. The paper then examines the issues and objections that have been raised on the two inheritance mechanisms. Graph, Linear, and Tree oriented implementations of multiple inheritance are reviewed to see how multiple inheritance issues are handled by various object oriented languages.

Introduction to Object-Oriented Design for C++

1. Object-Oriented Program Development. What is Object-Oriented Program Development? Sample Problem: The Convenience Store Owner. Sample Problem: The Changemaker. Compilers and Languages: Making the Program Run. Why Do People Think Object-Oriented Development Is So Important? 2. C++ Tools: Anatomy of a Simple Program. The Convenience Store Owner Program, Line-by-Line. Strong Information. Expressions, Statements, and Numeric Types. C++ Streams. Programming Style: Does It Matter? Making Sure the Analysis, Design, and Implementation are Correct. 3. Implementing Object Behaviors with Functions. C++ Functions that Return Values. Procedures: Functions that Do Not Return Values. Scopes and Lifetimes. Programming Errors and Functions. Refining Object-Oriented Designs. Using Class Libraries. 4. Decision Behavior: Selections and Alternatives. The if and if/else Statements. Evaluating Boolean Expressions. Typedefs and Enumerations. More Alternative Selections, switch Statements. The Conditional Operator: Providing Shorthand for a Simple if/else. Recursive Functions. Testing: The Evaluation Part of the Implementation Process. Application Example: Navigational Running Lights. 5. Iteration Behavior: Loops. The First Structure: while Loops. Constructing Loops: Starting, Quitting, and Getting to the Next Step. An Alternative Loop Structure: Do/While Loops. The Third Loop Structure: for Loops. Nested Loops. Alternative Loop Constructions and the Break Statement. Design Modification: Redesigning the Calculator. A New Problem: Text Analysis. 6. List Objects and Array-Based Implementations. Implementing List Objects with Old Programming Tools. Arrays: the Fundamentals. List Type Objects. Array-Based Implementations of Simple Lists. Sorting and Searching. Strings: Implementation Tool for Names and Phrases. List of Names. Multidimensional Arrays. Redesigning the Changemaker to Fit Implementation Changes. 7. Producing Objects through Classes. Simple Objects: Structs. Implementing Objects with Behaviors: Classes. A Simple List Class with an Array Data Member. Constructors Revisited. A Class with String Data. Classes with Class Type Member Data. An Inventory Table Class. The i. Changemaker Revised with Classes. Organization of Program Source Code and Libraries. Sharing Constant Class Data. 8. First Class Objects. A Numerical Example: Rational Numbers. A Second Example: 3-Dimensional Vectors. Designing First Class Types. Efficiency: In Lining. 9. Storage Management for Objects. Pointers. Dealing with Failures: Exit () and Assert (). References. Dynamic Array Creation. First Class Strings. Extensible Arrays. Implementation Standards for Classes with Pointers Data. 10. Inheritance and Reuse. Incremental Programming: Extending an Existing Class. Single Inheritance: Designing a Class Hierarchy. Multiple Inheritance. Using Inheritance to Organize Code. C++ Streams: Built-In Inheritance. Changing the Changemaker Solution to Incorporate Inheritance. 11. Polymorphism and Generic Classes. Ad Hoc Polymorphism: Overloading and Overriding. Parametrized Polymorphism through Templates. Runtime Polymorphism. Abstract Base Classes. Polymorphism and Cloning for Array-Based Lists. Changemaker, Revisited Again. 12. Container Classes and Linked Lists. Example of Containers. Linked Lists and Traditional List Algorithms. Implementing a Linked List Type via List and Node Classes. Iterator Classes. List Variations Using Inheritance and Templates. Stacks and Queues. Message Passing: Letting the Nodes Do It Recursively. Tables. 13. An Example Reconsidered: Some Issues in Design. An Example Revisited: Some Issues in Design. Has-a vs. Is-a Relationships. Memory Leaks, a Common Flaw. Finite State Machines for specification and Imple- mentation Correctness. Separating Public Interface from Implementation Details. Appendices. A: ASCII Character Codes and Escape Sequences. B: C++ Keywords. C: Operators Precedence. D: Stream Input. E: Stream Output. F: File Streams. Bibliography. Index. 0201765640T04062001

Agora

Agora is a framework for exploring object-oriented languages. In this paper we will discuss a particular prototype-based instance of Agora that features a general mixin-based approach to (multiple) inheritance. One of the major innovations of Agora is that many important features of object-orientation including inheritance, slot access, reification, cloning and inline objects are introduced by means of message passing rather than by ordinary programming structures.The syntax and semantics of Agora is explained and illustrated with examples. Furthermore, an FTP-site is given where a Smalltalk implementation of Agora can be found.

On Stein's paper: resolving ambiguity in nonmonotonic inheritance hierarchies

Inheritance hierarchies provide a simple encoding of common sense knowledge. Though attracted by the simplicity of hierarchies, the artificial intelligence community does not agree on how to deal with the ambiguities caused by the nonmonotonicity of these hierarchies. Stein (1992) presents a theory of multiple defeasible inheritance which is different from the theory of Touretzky et al. (1990, 1991, 1994). We show here that her way of defining an extension with respect to a focus node and as a subgraph of the inheritance graph is very attractive and compatible with Touretzky et al.'s theoretic framework, but that her definition of admissibility is not intuitively satisfactory. Nevertheless, her polynomial algorithm for computing the ideally skeptical conclusion set according to this definition of admissibility provides an interesting heuristic to compute a really skeptical conclusion set, i.e. a subset of the ideally skeptical one. In Touretzky et al.'s theory, ideal skepticism is NP-hard.

Proposal for a monotonic multiple inheritance linearization

Previous studies concerning multiple inheritance convinced us that a better analysis of conflict resolution mechanisms was necessary. In [DHHM92], we stated properties that a sound mechanism has to respect. Among them, a monotonicity principle plays a critical role, ensuring that the inheritance mechanism behaves “naturally” relative to the incremental design of the inheritance hierarchy. We focus here on linearizations and present an intrinsically monotonic linearization, whereas currently used linearizations are not. This paper describes the algorithm in detail, explains the design choices, and compares it to other linearizations, with LOOPS and CLOS taken as references. In particular, this new linearization extends CLOS and LOOPS linearizations, producing the same results when these linearizations are sound.

A massively parallel knowledge-base server using a hypercube multiprocessor

In this paper we study the parallel implementation of a traditional frame based knowledge representation system for a general purpose massively parallel hypercube architecture (such as the Connection Machine CM-2). We show that, using a widely available parallel system (instead of a special purpose architecture), it is possible to provide multiple users with efficient shared access to a large scale knowledge-base. Parallel algorithms are presented for answering multiple inference, assert and retract queries on both single and multiple inheritance hierarchies. In addition to theoretical time complexity analysis, empirical results obtained from extensive testing of a prototype implementation are presented.

Default inheritance in an object-oriented representation of linguistic categories

We describe an object-oriented approach to the representation of linguistic knowledge. Rather than devising a dedicated grammar formalism, we explore the use of powerful but domain-independent object-oriented languages. We use default inheritance to organize regular and exceptional behavior of linguistic categories. Examples from our work in the areas of morphology, syntax and the lexicon are provided. Special attention is given to multiple inheritance, which is used for the composition of new categories out of existing ones, and to structured inheritance, which is used to predict, among other things, to which rule domain a word form belongs.

An algebraic theory of object-oriented systems

The paper presents an algebraic specification of net objects. By net objects we mean those that are defined in object-oriented paradigms and those defined with nested relations in complex database models. An algebraic specification is set up that involves structures of net objects, accesses of net objects, and some features of object-oriented programming, such as multiple inheritance and polymorphism. Objects and their relationships are then characterized formally in the modeling, which utilizes the hierarchical approach in the algebraic theory of abstract data types, and is further developed by adding mechanisms from existing object systems. Categories of net objects are presented with the properties of accesses among them.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A new programming paradigm for engineering design software

Currently available programming and database systems are insufficient for engineering applications. The authors contend that a logical progression from a formal conceptual model of the engineering domain to a computational model will lead to new programming paradigms capable of directly supporting engineering applications in a rigorous, concise manner. A formal domain model devised by the authors, theHybrid Model (HM) of design information, is briefly introduced. It is an extension of axiomatic set theory and is discussed in detail elsewhere. HM forms the basis ofDesigner, a prototype-based object-oriented programming language supporting a signature-based canonical message-passing mechanism and multiple inheritance. Designer is implemented using the Scheme programming language. Because Designer satisfies a formal conceptual model, and because it is based on a formally specified language, its robustness and logical validity are superior to those of other languages not founded on formal principles. Designer combines concepts of functional and object-oriented programming to provide the formal rigor and flexibility to capture the complex and strongly interrelated information that designers use. Examples demonstrate how Designer represents design information. The results of the authors' research indicate that Designer can capture design information (including aspects of functional requirements and design intent) effectively and efficiently.

Selective multiple inheritance

In conventional multiple inheritance, a class must inherit features from all its ancestors. With this proposed generalized method, you can use an embryonic class, in which the classes themselves are instances, to select ancestor subsets without creating a combinatorial explosion in the object diagram.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Acquisition and validation of complex object database schemata supporting multiple inheritance

We present an intelligent tool for the acquisition of object-oriented schemata supporting multiple inheritance, which preserves taxonomy coherence and performs taxonomic inferences. Its theoretical framework is based onterminological logics, which have been developed in the area of artificial intelligence. The framework includes a rigorous formalization of complex objects, which is able to express cyclic references on the schema and instance level; asubsumption algorithm, which computes all impliedspecialization relationships between types; and an algorithm to detectincoherent types, i.e., necessarily empty types. Using results from formal analyses of knowledge representation languages, we show that subsumption and incoherence detection are computationally intractable from a theoretical point of view. However, the problems appear to be feasible in almost all practical cases.

The Evolution of C++: language design in the marketplace of ideas

Part 1 The early years: the evolution of C++ - 1985 to 1989, Bjarne Stroustrup possible directions for C++, Bjarne Stroustrup the design and implementation of InterViews, Mark A. Linton and Paul R. Calder building well-behaved type relationships in C++, R.B. Murray. Part 2 Multiple inheritance: the case against multiple inheritance in C++, T.A. Cargill the case for multiple inheritance in C++, Jim Waldo signature-based polymorphism for C++, Elana D. Granston and Vincent F. Russo. Part 3 Exception handling: exception handling for C++, Andrew Koenig and Bjarne Stroustrup an exception handling implementation for C++, Michael D. Tiemann. Part 4 Runtime typing: runtime access to type information in C++, John A. Interrante and Mark A. Linton type identification in C++, Dmitry Lenkov et al. Part 5 Distributed computing: solving the RPC problem in GNU C++, Michael D. Tiemann reliable distributed programming in C++ - the Arjuna approach, Graham D. Parrington the separation of interface and implementation in C++, Bruce Martin.