Inheritance Anomaly — A Formal Treatment

Proceedings 33rd International Conference on Technology of Object-Oriented Languages and Systems TOOLS 33, 2000

The rules for inheritance of classes with respect to data and function members are well defined. For example, the proposals for programming by contract in Eiffel ensure additional consistency between superclasses and subclasses. In object-oriented design, it is common to capture the behaviour of classes with lifecycles which are expressed in the form of finite state machines. In this context, there are very few proposals for what constitutes consistency between superclasses and subclasses. This paper presents proposals for consistency between superclasses and subclasses in the context of the Petri Net formalism, which is a form of finite state machine with explicit provisions for concurrency. The paper cites the applicability of these proposals in the context of network protocols, and argues for a similar applicability in the context of object lifecycles.

The Journal of Object Technology, 2008

We present an enhanced form of untyped object-based inheritance for classless languages, as implemented in our Delta language, comparing to the prevalent practices of delegation and embedding. Through a case scenario we reveal a design flaw of delegation that damages polymorphism and extensibility. Then, we show why embedding is impractical for object-based uninheritance (undoing inheritance on individual objects) and non-monotonic object evolution (dynamically adding or removing object members). We introduce dynamic object trees, adopting the metaphoric notions of inheritance from class-based languages, without compromising the compositional flexibility of untyped inheritance. We implement inherit and uninherit as library functions, discussing how our member lookup algorithm preserves monotonicity. Finally, we show that if prototypes are prototypical objects they may break their own invariant. To this end, we propose class objects as a more precise metaphor, implementing in the Delta language a function for dynamic mixin composition of class objects. AN ENHANCED FORM OF DYNAMIC UNTYPED OBJECT-BASED INHERITANCE 102 J OURNAL OF OBJECT TECHNOLOGY V OL. 7, NO. 4 AN ENHANCED FORM OF DYNAMIC UNTYPED OBJECT-BASED INHERITANCE 104 J OURNAL OF OBJECT TECHNOLOGY V OL. 7, NO. 4

Journal of Logic and Algebraic …, 2001

Lecture Notes in Computer Science, 2000

We introduce an object-oriented design pattern called Twin that allows us to model multiple inheritance in programming languages that do not support this feature (e.g. Java, Modula-3, Oberon-2). The pattern avoids many of the problems of multiple inheritance while keeping most of its benefits. The structure of this paper corresponds to the form of the design pattern catalogue in [GHJV95].

This thesis develops a semantic model of inheritance and investigates its applications for the analysis and design of programming languages. Inheritance is a mechanism for incremental programming in the presence of self-reference. This interpretation of inheritance is formalized using traditional techniques of fixed-point theory, resulting in a compositional model of inheritance that is directly applicable to object-oriented languages. Novel applications of inheritance revealed by the model are illustrated to show that inheritance has wider significance beyond object-oriented class inheritance. Constraints induced by self-reference and inheritance are investigated using type theory and yield a formal characterization of abstract classes and a demonstration that the subtype relation is a direct consequence of the basic mechanism of inheritance. The model is proven equivalent to the operational semantics of inheritance embodied by the interpreters of object-oriented languages like Smalltalk. Concise descriptions of inheritance behavior in several object-oriented languages, including Smalltalk, Beta, Simula, and Flavors, are presented in a common framework that facilitates direct comparison of their features.

Journal of Functional Programming, 1994

To illuminate the fundamental concepts involved in object-oriented programming languages, we describe the design of TOOPL, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes and inheritance. It has proven to be quite difficult to design such a language which has a secure type system. A particular problem with statically type checking object-oriented languages is designing typechecking rules which ensure that methods provided in a superclass will continue to be type correct when inherited in a subclass. The type-checking rules for TOOPL have this feature, enabling library suppliers to provide only the interfaces of classes with actual executable code, while still allowing users to safely create subclasses. To achieve greater expressibility while retaining type-safety, we choose to separate the inheritance and subtyping hierarchy in the language. The design of TOOPL has been guided by an analysis of the semantics of the language, which is given in terms of a model of the F-bounded second-order lambda calculus with fixed points at both the element and type level. This semantics supports the language design by providing a means to prove that the type-checking rules are sound, thus guaranteeing that the language is type-safe. While the semantics of our language is rather complex, involving fixed points at both the element and type level, we believe that this reflects the inherent complexity of the basic features of object-oriented programming languages. Particularly complex features include the implicit recursion inherent in the use of the keyword, self, to refer to the current object, and its corresponding type, MyType. The notions of subclass and inheritance introduce the greatest semantic complexities, whereas the notion of subtype is more straightforward to deal with. Our semantic investigations lead us to recommend caution in the use of inheritance, since small changes to method definitions in subclasses can result in major changes to the meanings of the other methods of the class.

Lecture Notes in Computer Science, 2016

Code reuse is a fundamental aspect of object-oriented programs, and in particular, the mechanisms of inheritance and late binding provide great flexibility in code reuse, without semantical limitations other than typecorrectness. However, modular reasoning about late binding and inheritance is challenging, and formal reasoning approaches place semantical restrictions on code reuse in order to preserve properties from superclasses. The overall aim of this paper is to develop a formal framework for modular reasoning about classes and inheritance, supporting unrestricted reuse of code, as well as of specifications. The main contribution is a Hoarestyle logic supporting free reuse, worked out for a high-level concurrent object-oriented language. We also show results on verification reuse, based on a combination of Hoare-style logic and static checking. An example illustrates the difference to comparable reasoning formalisms.

Lecture Notes in Computer Science, 1996

A model of subobjects and subobject selection gives us a concise expression of key semantic relationships in a variety of inheritancebased languages. Subobjects and their selection have been di cult to reason about explicitly because they are not explicit in the languages that support them. The goal of this paper is to present a relatively simple calculus to describe subobjects and subobject selection explicitly. Rather than present any deep theorems here, we develop a general calculus that can be used to explore the design of inheritance systems.

Although multiple inheritance (MI) is al- ready a feature of the C# language, there is a debate going on about its good and bad sides. In this paper, I am defending MI. At the same time, many of the rules and principles of inheritance in current C# seem to me to need improvements. The suggested modifications are relatively simple, do not introduce many new re- served words, and should not affect other parts of the language. I do not find the current rules totally adequate even for single inheritance (SI). The problems lie in the mean- ing of access levels and in the redefinability of virtual functions. Additional inconsistencies in C# virtual functions appear in so-called independent multiple in- heritance (IMI), which is in principle the easy case of MI. The most difficult problems are caused by so- called fork-join inheritance (FJI), which is the most complicated kind of inheritance. One essential cause of complexity is private inheritance because of its intransitive nature. The m...

Lecture Notes in Computer Science, 1992

A simple language is presented which supports inheritance in object-oriented languages. Using rids language, the definitions for the semantics of inheritance given in [CHC90] and [Mit90] are compared and shown to be equivalent. The equivalence is shown by presenting and comparing two denotational semantics of the simple language which capture the essence of each of the earlier semantics.