Results 1 - 10
of
86
A Behavioral Notion of Subtyping
- ACM Transactions on Programming Languages and Systems
, 1994
"... The use of hierarchy is an important component of object-oriented design. Hierarchy allows the use of type families, in which higher level supertypes capture the behavior that all of their subtypes have in common. For this methodology to be effective, it is necessary to have a clear understanding of ..."
Abstract
-
Cited by 398 (13 self)
- Add to MetaCart
The use of hierarchy is an important component of object-oriented design. Hierarchy allows the use of type families, in which higher level supertypes capture the behavior that all of their subtypes have in common. For this methodology to be effective, it is necessary to have a clear understanding of how subtypes and supertypes are related. This paper takes the position that the relationship should ensure that any property proved about supertype objects also holds for its subtype objects. It presents two ways of defining the subtype relation, each of which meets this criterion, and each of which is easy for programmers to use. The subtype relation is based on the specifications of the sub- and supertypes; the paper presents a way of specifying types that makes it convenient to define the subtype relation. The paper also discusses the ramifications of this notion of subtyping on the design of type families.
Analysis of Inheritance Anomaly in Object-Oriented Concurrent Programming Languages
, 1993
"... It has been pointed out that inheritance and synchronization constraints in concurrent object systems often conflict with each other, resulting in inheritance anomaly where re-definitions of inherited methods are necessary in order to maintain the integrity of concurrent objects. The anomaly is seri ..."
Abstract
-
Cited by 163 (1 self)
- Add to MetaCart
It has been pointed out that inheritance and synchronization constraints in concurrent object systems often conflict with each other, resulting in inheritance anomaly where re-definitions of inherited methods are necessary in order to maintain the integrity of concurrent objects. The anomaly is serious, as it could nullify the benefits of inheritance altogether. Several proposals have been made for resolving the anomaly; however, we argue that those proposals suffer from the incompleteness which allows room for counterexamples. We give an overview and the analysis of inheritance anomaly, and review several proposals for minimizing the unwanted effect of this phenomenon. In particular, we propose (partial) solutions using (1) computational reflection, and (2) transactions in OOCP languages. 1 Introduction Inheritance is the prime language feature in sequential OO (Object-Oriented) languages, and is especially important for code re-use. Another important feature is concurrency; although...
The Programming Language Jigsaw: Mixins, Modularity And Multiple Inheritance
, 1992
"... This dissertation provides a framework for modularity in programming languages. In this framework, known as Jigsaw, inheritance is understood to be an essential linguistic mechanism for module manipulation. In Jigsaw, the roles of classes in existing languages are "unbundled," by providing a suite o ..."
Abstract
-
Cited by 138 (4 self)
- Add to MetaCart
This dissertation provides a framework for modularity in programming languages. In this framework, known as Jigsaw, inheritance is understood to be an essential linguistic mechanism for module manipulation. In Jigsaw, the roles of classes in existing languages are "unbundled," by providing a suite of operators independently controlling such effects as combination, modification, encapsulation, name resolution, and sharing, all on the single notion of module. All module operators are forms of inheritance. Thus, inheritance is not in conflict with modularity in this system, but is indeed its foundation. This allows a previously unobtainable spectrum of features to be combined in a cohesive manner, including multiple inheritance, mixins, encapsulation and strong typing. Jigsaw has a rigorous semantics, based upon a denotational model of inheritance. Jigsaw provides a notion of modularity independent of a particular computational paradigm. Jigsaw can therefore be applied to a wide variet...
A Paradigmatic Object-Oriented Programming Language: Design, Static Typing and Semantics
- Journal of Functional Programming
, 1993
"... In order 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 in ..."
Abstract
-
Cited by 110 (9 self)
- Add to MetaCart
In order 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 type-checking 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. In order to achieve greater expressibility while retaining type-safety, we choose to separate the inheritance and subtyping hierarchy in the language. The design of...
The Cecil Language, Specification and Rationale
, 1993
"... Cecil is a new purely object-oriented language intended to support rapid construction of highquality, extensible software. Cecil combines multi-methods with a classless object model, object-based encapsulation, and optional static type checking. Cecil's static type system distinguishes between subty ..."
Abstract
-
Cited by 109 (20 self)
- Add to MetaCart
Cecil is a new purely object-oriented language intended to support rapid construction of highquality, extensible software. Cecil combines multi-methods with a classless object model, object-based encapsulation, and optional static type checking. Cecil's static type system distinguishes between subtyping and code inheritance, but Cecil enables these two graphs to be described with a single set of declarations, optimizing the common case where the two graphs are parallel. Cecil includes a fairly flexible form of parameterization, including both explicitly parameterized objects, types, and methods and implicitly parameterized methods related to the polymorphic functions commonly found in functional languages. By making type declarations optional, Cecil aims to support mixed exploratory and production programming styles. This document describes the design of the Cecil language as of March, 1993. It mixes the specification of the language with discussions of design issues and explanations of...
Systematic Concurrent Object-Oriented Programming
- COMMUNICATIONS OF THE ACM
, 1993
"... Judging by the looks of the two parties, the marriage between concurrent computation and object-oriented programminga union much desired by practitioners in such fields as telecommunications, high-performance computing, banking and operating systems- appears easy enough to arrange. This appearance, ..."
Abstract
-
Cited by 102 (1 self)
- Add to MetaCart
Judging by the looks of the two parties, the marriage between concurrent computation and object-oriented programminga union much desired by practitioners in such fields as telecommunications, high-performance computing, banking and operating systems- appears easy enough to arrange. This appearance, however, is deceptive: the problem is a hard one. This article points the way toward a possible solution. The precise problem examined here is restricted to: What is the smallest, smallest and most convincing extension to the method of systematic object-oriented software construction that can address the need of concurrent and distributed computinng as well as those of sequential computations? The article does not claim to discuss concurrency and distribution in a general and unbiased way
Typechecking and Modules for Multi-Methods
- ACM Transactions on Programming Languages and Systems
, 1995
"... Two major obstacles hindering the wider acceptance of multi-methods are concerns over the lack of encapsulation and modularity and the absence of static typechecking in existing multi-method-based languages. This paper addresses both of these problems. We present a polynomial-time static typecheckin ..."
Abstract
-
Cited by 97 (22 self)
- Add to MetaCart
Two major obstacles hindering the wider acceptance of multi-methods are concerns over the lack of encapsulation and modularity and the absence of static typechecking in existing multi-method-based languages. This paper addresses both of these problems. We present a polynomial-time static typechecking algorithm that checks the conformance, completeness, and consistency of a group of method implementations with respect to declared message signatures. This algorithm improves on previous algorithms by handling separate type and inheritance hierarchies, abstract classes, and graph-based method lookup semantics. We also present a module system that enables independently-developed code to be fully encapsulated and statically typechecked on a per-module basis. To guarantee that potential conflicts between independently-developed modules have been resolved, a simple well-formedness condition on the modules comprising a program is checked at link-time. The typechecking algorithm and module system are applicable to a range of multi-method-based languages, but the paper uses the Cecil language as a concrete example of how they can be applied.
Modularity meets Inheritance
- IN PROC. INTERNATIONAL CONFERENCE ON COMPUTER LANGUAGES
, 1992
"... We "unbundle" several roles of classes in existing languages, by providing a suite of operators independently controlling such effects as combination, modification, encapsulation, name resolution, and sharing, all on the single notion of module. All module operators are forms of inheritance. Thus, ..."
Abstract
-
Cited by 86 (8 self)
- Add to MetaCart
We "unbundle" several roles of classes in existing languages, by providing a suite of operators independently controlling such effects as combination, modification, encapsulation, name resolution, and sharing, all on the single notion of module. All module operators are forms of inheritance. Thus, inheritance not only is not in conflict with modularity in our system, but is its foundation. This allows a previously unobtainable spectrum of features to be combined in a cohesive manner, including multiple inheritance, mixins, encapsulation and strong typing. We demonstrate our approach in a language (called Jigsaw, as in the tool, not the puzzle!). Our language is modular in two senses: it manipulates modules, and it is highly modular in its own conception, permitting various module combinators to be included, omitted, or newly constructed in various realizations.
Strongtalk: Typechecking Smalltalk in a Production Environment
, 1993
"... Strongtalk TM is a typechecker for a downward compatible Smalltalk dialect. It is designed for large-scale production software development, and incorporates a strong, modern structural type system. It not only separates the notions of type and class, but also deals with the more difficult issue of s ..."
Abstract
-
Cited by 74 (3 self)
- Add to MetaCart
Strongtalk TM is a typechecker for a downward compatible Smalltalk dialect. It is designed for large-scale production software development, and incorporates a strong, modern structural type system. It not only separates the notions of type and class, but also deals with the more difficult issue of separating inheritance and subtyping using the notion of inherited types [CHC90, Bru93a] to preserve encapsulation. Strongtalk integrates inherited types, metaclasses, blocks and polymorphic methods into a highly usable, full-scale language. 1 Introduction It is widely accepted that a strong, static type system for a programming language has important benefits, including increased reliability, readability, and (potentially) performance. However, an inadequate type system can constrain the flexibility of a language, and thus its expressiveness. Static typing allows the type safety of source code to be completely determined before execu- 0TM Strongtalk is a trademark of Horizon Technologies...
Traits: A mechanism for fine-grained reuse
- Transactions on Programming Languages and Systems
, 2006
"... 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 i ..."
Abstract
-
Cited by 60 (18 self)
- Add to MetaCart
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.

