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.

Inheritance is well-known and accepted as a mechanism for reuse in object-oriented languages. Unfortunately, due to the coarse granularity of inheritance, it may be difficult to decompose an application into an optimal class hierarchy that maximizes software reuse. Existing schemes based on single inheritance, multiple inheritance, or mixins, all pose numerous problems for reuse. To overcome these problems we propose traits, pure units of reuse consisting only of methods. We develop a formal model of traits that establishes how traits can be composed, either to form other traits, or to form classes. We also outline an experimental validation in which we apply traits to refactor a non-trivial application into composable units.

This paper presents a model and prototype implementation, called obligations, for handling flexible, dynamic changes to workflows. The model uses multiple inheritance and an overhead transparency metaphor to construct a network of activities. Each `sheet' holds portions of the network to be constructed. Some of these sheets contain local modifications that are not shared among other similar activities and others hold general specifications that all instances should follow, assuming that they have not been locally modified. When all the sheets are stacked together, they create a composite view of the network. Individual sheets can be removed and replaced with newer, presumably compatible, sheets that change the network. This type of replacement can be encoded into surrogates which automatically carry out the replacements to keep the obligation up-to-date. The obligation system has a built in error detection scheme that determines if network construction is invalid and, if so, disallows ...

www.iam.unibe.ch/∼scg Unanticipated changes to complex software systems can introduce anomalies such as duplicated code, suboptimal inheritance relationships and a proliferation of run-time downcasts. Refactoring to eliminate these anomalies may not be an option, at least in certain stages of software evolution. Classboxes are modules that restrict the visibility of changes to selected clients only, thereby offering more freedom in the way unanticipated changes may be implemented, and thus reducing the need for convoluted design anomalies. In this paper we demonstrate how classboxes can be implemented in statically-typed languages like Java. We also present an extended case study of Swing, a Java GUI package built on top of AWT, and we document the ensuing anomalies that Swing introduces. We show how Classbox/J, a prototype implementation of classboxes for Java, is used to provide a cleaner implementation of Swing using local refinement rather than subclassing.

We develop an imperative calculus that provides a formal model for both single and mixin inheritance. By introducing classes and mixins as the basic object-oriented constructs in a -calculus with records and references, we obtain a system with an intuitive operational semantics. New

This paper presents a mixin based class and method combination mechanism with block structure propagation. Traditionally, mixins can be composed to form new classes, possibly merging the implementations of methods (as in CLOS). In our approach, a class or method combination operation may cause any number of implicit combinations. For example, it is possible to specify separate aspects of a family of classes, and then combine several aspects into a full-fledged class family. The combination expressions would explicitly combine whole-family aspects, and by propagation implicitly combine the aspects for each member of the class family, and again by propagation implicitly compose each method from its aspects. As opposed to CLOS, this is type-checked statically; and as opposed to other systems for advanced class combination/merging/weaving, it is integrated directly in the language, ensuring a clear semantics and a seamless interaction with the type system. Moreover, the ba...

Abstract. Despite the undisputed prominence of inheritance as the fundamental reuse mechanism in object-oriented programming languages, the main variants — single inheritance, multiple inheritance, and mixin inheritance — all suffer from conceptual and practical problems. In the first part of this paper, we identify and illustrate these problems. We then present traits, a simple compositional model for structuring object-oriented programs. A trait is essentially a group of pure methods that serves as a building block for classes and is a primitive unit 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. We demonstrate how traits overcome the problems arising from the different variants of inheritance, we discuss how traits can be implemented effectively, and we summarize our experience applying traits to refactor an existing class hierarchy.

Rapide is a programming language framework designed for the development of large, concurrent, real-time systems by prototyping. The framework consists of a type language and default executable, specification and architecture languages, along with associated programming tools. We describe the main features of the type language, its intended use in a prototyping environment, and rationale for selected design decisions. 1 Introduction Rapide is a programming language framework with an associated toolset. The framework consists of a set of languages, while the toolset provides related program development and diagnostic tools. The framework includes a type language, a default executable language, a default specification language, and an architecture language. Although these languages together provide a complete programming language, Rapide is intended to accommodate additional implementation and specification languages, besides the default ones provided by the framework. The constant of the...

Software process models are meant to describe software engineering activities around evolving software products. Process models will need modifications due to gained experience, changed policies or projectspecific requirements, and a set of versions of the original models must be maintained. Thus, software process models are evolving products and should be under control of a configuration management system. EPOS models Software Processes in an objectoriented data model. Both Process models and running instances are stored in a versioned database. EPOS Software Process Models may be evolved and reused by the same CM techniques as used for software systems. 1 Introduction Configuration Management (CM) is the discipline of managing the evolution of complex systems. Software CM is needed to assist in designing and engineering software products. CM assumes a shared and versioned repository to store software products, consisting of general software components and their dependencies. A soft...

Programming is a modeling process where phenomena and abstractions from a referent system are expressed using a programming language. To improve the efficiency of program development, programming languages should be designed to reflect human conceptualization as well as possible. This will make programs easier to comprehend, thus aiding during both development and maintenance, and it will aid in making the developed programs conform better to the users expectations. This paper will present a model of the interactions between epistemology, concept formation, programming language analysis and design, and programming. The model will be used to develop a taxonomic framework for analyzing and designing abstraction mechanisms found in object-oriented languages. keywords: object oriented modeling, language design, language comparision, programming paradigms 1 Introduction This paper is an attempt to define and illustrate an approach to programming which we call conceptual programming. The m...