Single versus multiple inheritance in object oriented programming

Late binding and subtyping create run-time overhead for object-oriented languages, especially in the context of both multiple inheritance and dynamic loading, for instance for Java interfaces. It is, however, generally agreed that the efficiency of Java and .Net systems comes from the fact that, in these languages, classes are in single inheritance. In this paper, we present the abstract architecture of a virtual machine for unrestricted multiple-inheritance, which should provide the same runtime efficiency as Java and .Net.

Two of the fundamental uses of generalization in object-oriented software development are the reusability of code and better structuring of the description of objects. Multiple inheritance is one of the important features of object-oriented methodologies which enables developers to combine concepts and increase the reusability of the resulting software. However, multiple inheritance is implemented differently in commonly used programming languages. In this paper, we use Chidamber and Kemerer (CK) metrics to study the complexity and reusability of multiple inheritance as implemented in Python, Java, and C++. The analysis of results suggests that out of the three languages investigated Python and C++ offer better reusability of software when using multiple inheritance, whereas Java has major deficiencies when implementing multiple inheritance resulting in poor structure of objects.

A verification environment which is based on a constrained random layered test bench using SystemVerilog OOP is implemented in this paper to verify the functionality of DUT designed with synthesizable constructors of SystemVerilog. Although the uses of multiple inheritance in OOP appear to be less common than those of single inheritance, multiple inheritance is useful for creating class types that combine the properties of two or more class types. Because SystemVerilog OOP technique does not allow multiple inheritance, we adopt SystemC to design a component of verification environment which has multiple inheritance, and we combine SystemC design unit with the SystemVerilog-based layered testbench using SystemVerilog DPI and ModelSim macro. SystemVerilog DPI provides a way to interface with any other foreign language. Functions and tasks registered to shared library using DPI can be called out like native ones. ModelSim recently supports SystemC simulation with built-in compiler for SystemC design unit. In order to simulate SystemC design unit with ModelSim, the SystemC design unit should be modified using some macros provided by ModelSim. In this paper, FIFO channel frequently used in high-level communication is designed as a custom hierarchical channel which has three base classes; sc_channel, channel interface, and data payload interface. The low-layer components of the SystemVerilog-based layered testbench communicate with DUT using virtual interface, and other components can communicate with each other using FIFO channel. DUT in this paper includes BFM because most IPs designed for SoC are connected to a bus and controlled through the bus.

The purpose of this paper is to present a first step in a formal study of inheritance systems.The kind of systems considered are those that support overriding (all definitions being taken as defaults) and multiple inheritance. The overriding is based on the explicit statement of negative information.The basic entities are classes and properties. The system is hierarchic because it is made out of classes which are structured as a hierarchy. We consider both the basic case of properties restricted to atomic propositional formulas and their negations, and the extension to properties defined by rules in the Logic Programming style.A formal definition of hierarchic systems is given for which a model-theoretic 3-valued semantics is in roduced. This semantics is explicitly stated in terms of sets of individuals. It defines the notion of interpretation, the characterization of models, and what is meant by validity of formulas in such structures.The inheritance mechanism is able to choose from a set of inherited default properties which ones must be overriden in order to guarantee that the local program has a model.The notion of characteristic individuals of classes, introduced in our semantics, turns out to play a clarifying role of the relationship between semantic and syntactic aspects of inheritance systems.

We present the problem of class hierarchy complementation: given a partially known hierarchy of together with subtyping constraints (A has to be a transitive subtype of B) complete the hierarchy so that it satisfies all constraints. The problem has immediate practical application to the analysis of partial programs--e.g., it arises in the process of providing a sound handling of phantom classes in the Soot program analysis framework. We provide algorithms to solve the hierarchy complementation problem in the single inheritance and multiple inheritance settings. We also show that the problem in a language such as Java, with single inheritance but multiple subtyping and distinguished class vs. interface types, can be decomposed into separate single- and multiple-subtyping instances. We implement our algorithms in a tool, JPhantom, which complements partial Java bytecode programs so that the result is guaranteed to satisfy the Java verifier requirements. JPhantom is highly scalable and runs in mere seconds even for large input applications and complex constraints (with a maximum of 14s for a 19MB binary).

Late binding and subtyping create run‐time overhead for object‐oriented languages. Dynamic typing and multiple inheritance create even more overhead. Static typing and single inheritance lead to two major invariants, of reference and position, that make the implementation as efficient as possible. Coloring is a technique that preserves these invariants for dynamic typing or multiple inheritance at minimal spatial cost. Coloring has been independently proposed for method invocation under the name ofselector coloring, for subtype tests under the name ofpack encoding, and for attribute access and object layout. This paper reviews a number of uses of coloring for optimizing object‐oriented programming, generalizes them, and specifies several variations, such as bidirectional andn‐directional coloring. Coloring is NP‐hard, hence compilers that use it depend on heuristics. The paper describes two families of heuristics and presents some experimental results which indicate that coloring is both efficient and tractable and that bidirectional coloring gives the best results. Copyright © 2010 John Wiley & Sons, Ltd.

There is currently a significant amount of discussion regarding new ways to insert ergonomics into the business community through adding financial benefits; however, analysis must be performed to justify this type of investment. Occupational problems that could be reduced by ergonomics solutions can be expressed as financial losses. Although the impact and importance of these losses are high, the difficulties in their quantification prevent adequate cost‐benefit analysis. This article aims to document evidence of the difficulties encountered when quantifying the financial losses that are caused by problems that could be reduced by ergonomic solutions. In this study, we performed a literature review concerning the financial costs related to occupational problems from the perspective of ergonomics. The results indicate that losses that occur mainly concern the productivity of the working process or the workers. The chief barriers documented in the scientific literature are the information cost, the multifactorial nature of the problem, the absence of information, and the methods of measurement. © 2012 Wiley Periodicals, Inc.

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.

Traits offer a fine-grained mechanism to compose classes from reusable components while avoiding problems of fragility brought by multiple inheritance and mixins. Traits as originally proposed are stateless, that is, they contain only methods, but no instance variables. State can only be accessed within traits by accessors, which become required methods of the trait. Although this approach works reasonably well in practice, it means that many traits, viewed as software components, are artificially incomplete, and classes that use such traits may contain significant amounts of boilerplate glue code. Although these limitations are largely mitigated by proper tool support, we seek a cleaner solution that supports stateful traits. The key difficulty is how to handle conflicts that arise when composed traits contribute instance variables whose names clash. We present a solution that is faithful to the guiding principle of stateless traits: the client retains control of the composition. Stateful traits consist of a minimal extension to stateless traits in which instance variables are purely local to the scope of a trait, unless they are explicitly made accessible by the composing client of a trait. Naming conflicts are avoided, and variables of disjoint traits can be explicitly merged by clients. We discuss and compare two implementation strategies, and briefly present a case study in which stateful traits have been used to refactor the trait-based version of the Smalltalk collection hierarchy.KeywordsInstance VariableStateful TraitTrait CompositionMultiple InheritanceClient ClassThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The authors 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). It is shown 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.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The article describes the implementation of the mechanism of inheritance of educational programs in the process of electronic development of educational documentation of the university. The purpose of the inheritance mechanism is to improve the processes of automated development of educational programmes and to ensure internal consistency of educational documentation.&#x0D; In the course of the study, the concept of inheritance of educational programs was introduced as a mechanism to take into account the information of parental educational programs when describing the elements of subsidiary programs corresponding to this information. The possibilities of applying the inheritance mechanism in situations: 1) preparation of documentation of similar programs implemented on different forms of training are disclosed; 2) creation of different versions of documentation of educational programs, depending on the year of reception; 3) creating one child program based on several parents; 4) multiple inheritance of a series of related educational programs. Functional requirements for the educational program development tool system are described for each of the above situations. Actual data on the impact of the inheritance mechanism in the development of educational programmes are presented.&#x0D; Thus, the inheritance of educational programs is an effective mechanism for developing educational documentation in an electronic environment. This mechanism significantly reduces the cost of developing similar programs, as well as improving the quality of the university 's educational documentation by improving the consistency of its parts.

In this paper, we provide an extensive analysis of the formal features displayed by Italian diminutives (especially allomorphy) by using surface alternation patterns automatically extracted from a dataset of base-diminutive pairs. Applying the theoretical tools provided by Construction Morphology (CxM), we take alternation patterns as a proxy for paradigmatic relations and locate them into separate hierarchies, exploiting the mechanism of multiple inheritance in order to express generalizations on different, mutually independent factors at play (i.e., lexical category, gender and final segment of the base and derivative, suffixes and antesuffixal phonological material displayed by the derivative). In doing so, we contribute to the exploration of the formal side of Italian diminutives, which have been so far addressed mostly from a semantic perspective, and to the refinement of the representation of formal phenomena such as allomorphy according to the CxM framework.

Scala is a new programming language developed at EPFL and incorporating the most important concepts of object-oriented and functional languages. It aims at integrating well with the Java and .NET platforms: their respective libraries are accessible without glue code, and the compiler can produce programs for both virtual machines. This thesis focuses on the compilation of two important concepts of Scala : mixin inheritance and run time types. The compilation techniques are presented in the context of the Java virtual machine, but could be adapted easily to other similar environments. Mixin inheritance is a relatively recent form of inheritance, offering new capabilities compared to single inheritance, without the complexity of multiple inheritance. We propose two implementation techniques for mixin inheritance: code copying and delegation. The implementation used in the Scala compiler is then presented and justified. Run time types make it possible for a program to examine the type of its values during execution. This possibility is interesting in itself, offering new capabilities to the programmer. Furthermore, run time types are also required to implement other high level concepts, like pattern matching, type-safe serialisation and reflection. We propose an implementation technique based on the representation of types as values, and show how to use the run time types of the underlying virtual machine to implement those of Scala. The techniques presented in this thesis have been implemented in our Scala compiler, scalac. This enabled us to evaluate these techniques, in particular their impact on the performances of programs. This evaluation was performed on several real, non-trivial programs.

A language design development process is presented which leads to a language, gbeta, with a tight integration of virtual classes, general block structure, and a multiple inheritance mechanism based on coarse-grained structural type equivalence. From this emerges the concept of propagating specialization. The power lies in the fact that a simple expression can have far-reaching but well-organized consequences, e.g., in one step causing the combination of families of classes, then by propagation the members of those families, and finally by propagation the methods of the members. Moreover, classes are first class values which can be constructed at run-time, and it is possible to inherit from classes whether or not they are compile-time constants, and whether or not they were created dynamically. It is also possible to change the class and structure of an existing object at run-time, preserving object identity. Even though such dynamism is normally not seen in statically type-checked languages, these constructs have been integrated without compromising the static type safety of the language.

An object-oriented approach to High-Level Petri Nets