Inheritance is the fundamental reuse mechanism in object-oriented programming languages; its most prominent variants are single inheritance, multiple inheritance, and mixin inheritance. In the first part of this paper, we identify and illustrate the conceptual and practical reusability problems that arise with these forms of inheritance. We then present a simple compositional model for structuring object-oriented programs, which we call traits. Traits are essentially groups of methods that serve as building blocks for classes and are primitive units of code reuse. In this model, classes are composed from a set of traits by specifying glue code that connects the traits together and accesses the necessary state.

Abstract 1 Refactorings are behavior-preserving program transformations that automate design level changes in object-oriented applications. Our previous research established that many schema transformations, design patterns, and hotspot meta-patterns are automatable. This research evaluates whether refactoring technology can be transferred to the mainstream by restructuring non-trivial C++ applications. The applications that we examine were evolved manually by software engineers. We show that an equivalent evolution could be reproduced significantly faster and cheaper by applying a handful of general-purpose refactorings. In one application, over 14K lines of code were transformed automatically that otherwise would have been coded by hand. Our experiments identify benefits, limitations, and topics of further research related to the transfer of refactoring technology to a production environment. 1.

te Method: Template Method uses inheritance to implement some part of an algorithm. . Walker: Walker provides an extra level of abstraction on aggregate structures. It is used to implement methods on aggregates eliminating the need to define the same methods for all aggregates. References

Although program faults are widely studied, there are many aspects of faults that we still do not understand, particularly about OO software. In addition to the simple fact that one important goal during testing is to cause failures and thereby detect faults, a full understanding of the characteristics of faults is crucial to several research areas. The power that inheritance and polymorphism brings to the expressiveness of programming languages also brings a number of new anomalies and fault types. This paper presents a model for the appearance and realization of OO faults and defines and discusses specific categories of inheritance and polymorphic faults. The model and categories can be used to support empirical investigations of object-oriented testing techniques, to inspire further research into objectoriented testing and analysis, and to help improve design and development of object-oriented software.

Multiple inheritance is still a controversial feature in traditional object-oriented languages, as evidenced by its omission from such languages as Modula-3, Objective C and Java^TM. Nonetheless, users of such languages often complain about having to work around the absence of multiple inheritance. Automating delegation, in combination with a multiple subtyping mechanism, provides many of the same benefits as multiple inheritance, yet sidesteps most of the associated problems. This simple feature could satisfy both the designers and the users of class based object oriented languages. In this paper, we discuss why automated delegation is desirable. We also present Jamie, a freeware preprocessor-based extension to Java that offers such an alternative. Automated Delegation is a Viable Alternative to Multiple Inheritance in Class Based Languages John Viega Dept. Of Computer Science University Of Virginia Charlottesville, VA 22903 viega@list.org Bill Tutt Microsoft Corporat...

: the Guide language is an object-oriented language dedicated for programming distributed applications on top of the Comandos platform. This language faithfully reflects all the capabilities of the Comandos model. It combines the facilities of a strongly typed object model with a powerful computational model. Key features of the language are: separation between types and classes, conformant subtyping, distribution transparency, concurrent activities, synchronisation mechanism for shared objects, exception handling. This paper presents the design choices for the Guide language and discusses programming experience gained from the use of the language for the construction of distributed applications. 1. INTRODUCTION Comandos (Construction and Management of Distributed Open Systems) is a cooperative project under the ESPRIT European program aiming at providing an integrated development environment for distributed applications [8]. To achieve this goal, Comandos provides a conceptual m...

Inheritance mechanisms are used to express many different programming concepts. In this paper we analyse these inheritance concepts to determine the requirements for an inheritance mechanism which is to support the concepts well. On the basis of this analysis we identify weaknesses in current mechanisms, particularly in the areas of modelling and signature modification and show how an inheritance mechanism can better fulfil the requirements while remaining type-safe.

In nominal type systems, the subtype relation is between names of types, and subtype links are explicitly declared. In structural type systems, names are irrelevant; in determining type compatibility, only the structure of types is considered, and a type name is just an abbreviation for the full type. We analyze structural and different flavors of nominal subtyping from the perspective of component-based programming, where issues such as blame assignment and modular extensibility are important. Our analysis puts various existing subtyping mechanisms into a common frame of reference and delineates the frontiers of the subtyping design space. In addition, we propose a new subtyping definition in one particularly interesting corner of the design space which combines the safety of nominal subtyping with the flexibility of structural subtyping. 1

Recently, there has been a debate over what the notion of inheritance means [1, 9, 13, 15, 16]. For example, Winkler [16] points to the dichotomy between the concept-oriented view (COV) and the program-oriented view (POV) of classes and inheritance. Wegner [15] has referred to COV as “logical” and POV as “physical. ” According to COV, squares form a subclass of rectangles. But this leads to some major problems in POV, where the set of operations applicable to a subclass is seen as a monotonic extension of its superclass. This is because applying operations such as “set-width ” to a square object would allow one to change the width of a square independently of its length. To remedy this situation, Winkler proposes an object-oriented view (OOV) of inheritance that replaces the term “class, ” “subclass ” and “superclass ” with “object type, ” “extension type ” and “base type, ” respectively. Winkler makes it seem to be a dichotomy of two different, overlapping but not identical, views of inheritance that can be resolved by renaming the concepts involved. But it turns out to be a more complex issue on deeper reflection. To realize the full complexity underlying the notion of inheritance, we must take a closer look at what Winkler has casually dubbed COV. Is inheritance from a conceptual point of view always (or often) unambiguous? Is a square always a rectangle? While one may be tempted to answer both these questions in the affirmative at first, a further reflection reveals that things are more subtle. For instance, if we were to just think of a class of all squares and a class of all rectangles, then obviously the former is a proper subclass of

We investigate a modeling issue arising when object-oriented databases meet object-oriented programming languages like C++. For the application modeling process we argue that a taxonomic view is superior to the implementation view popular in C++. As a consequence we require classes to have both types and extensions. At the object definition level taxonomic modeling needs integrity constraints in form of functional constraints. However, if implemented naively taxonomic modeling may incur a considerable storage penalty. We present an automatic storage optimization algorithm, which in practical cases achieves the same low storage requirements as tailored C++ solutions. Our second focus is on software reuse, which demands proper adaptation measures to ensure semantically correct inheritance of update methods. We present a new adaptation algorithm that can be carried out automatically at schema compile time. Finally we demonstrate how to rapidly implement taxonomic modeling on top of a stan...