An exemplar based Smalltalk

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.

1997

Many object-oriented programming languages provide reflective features which may be used to control the interpretive mechanism of the language. Often, these features are defined with respect to a golden braid consisting of objects, classes and metaclasses. This paper describes the Smalltalk golden braid and generalize it for multiple inheritance. Multiple inheritance leads to choices between many different inheritance strategies.

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

1995

1996

Object-oriented programming languages oopl's provide important support for today's large-scale software development projects. Unfortunately, the typing issues arising from the object-oriented features that provide this support are substantially di erent from those that arise in typing procedural languages. Attempts to adapt procedural type systems to object-oriented languages have resulted in languages like Simula, C++, and Object Pascal, which h a v e o v erly restrictive t ype systems. Among other things, the rigidity of these systems frequently force programmers to use type casts, which are a notorious source of hard-to-nd bugs. These restrictive type systems also mean that many programming idioms common to untyped oopl's such as Smalltalk are not typeable. One source of this lack of exibility is the con ation of subtyping and inheritance. Brie y, inheritance is an implementation technique in which new object de nitions may be given as incremental modi cations to existing de nitions. Subtyping concerns substitutivity: when can one object safely replace another? By tying subtyping to inheritance, existing oopl's greatly reduce the number of legal substitutions in a system, and hence their degree of polymorphism. Attempts to x this rigidity h a v e resulted in unsound type systems, most notably Ei el's.

Springer eBooks, 1997

We present a mathematical theory of class. The theory is general, in that it encompasses many different approaches to type abstraction, such as type constructors, generic parameters, classes, inheritance and polymorphism. The theory is elegant, in that it is based on a simple generalisation of F-bounds. The theory has timely implications for emerging OMG standards and future language designs.

Periodica Polytechnica Electrical Engineering, 2007

A low-level data structure always has a predefined representation which does not fit into an object of traditional objectoriented languages, where explicit type tag denotes its dynamic type. This is the main reason why the advanced features of object-oriented programming cannot be fully used at the lowest level. On the other hand, the hierarchy of low-level data structures is very similar to class-trees, but instead of an explicit tag-field the value of the object determines its dynamic type. Another peculiar requirement in system programming is that some classes have to be polymorphic by-value with their ancestor: objects must fit into the space of a superclass instance. In our paper we show language constructs which enable the system programmer to handle all data structures as objects, and exploit the advantages of object-oriented programming even at the lowest level. Our solution is based on Predicate Dispatching, but adopted to the special needs of system programming. The techniques we show also allow for some classes to be polymorphic by-value with their super. We also describe how to implement these features without losing modularity.

2002

We develop further the old idea that object-oriented languages could support also the inverse of inheritance (specialisation): generalisation or “exheritance”. It is easy as far as only interfaces are concerned, but attributes and method implementations cause problems. Renaming appears to be a very desirable language feature for exheritance. Combinations of inheritance and exheritance can be interesting and useful.

Electronic Notes in Theoretical Computer Science, 1998

We compare di erent kinds of rst-order models of objects and message passing, as found in object-oriented programming languages. We show that generic function models can easily simulate record models for static, class-based languages. We explore type systems for such languages, and show that our simulation preserves typing. Algebraic models emerge as abstractions of the generic function model that suppress details that are irrelevant for client code.