===============================
ABSTRACTS OF TECHREPORTS 1995
===============================

#Reference:
vub-prog-tr-95-01
"Construction of the Reflective Tower Based on Open Implementations"
Kris De Volder, Patrick Steyaert
Unpublished

#Abstract:
It is our opinion that the traditional model of reflection, towers of meta-circular interpreters, is not sufficiently detailed. We propose a more fine grained construction of the reflective tower not by means of
meta-circular interpreters, but rather by means of (meta-circular) open implementations. We find that this approach adds precisely the needed amount of detail missing from the traditional tower model.

#Keywords:
reflection, open-implementation, reflective tower


#Reference:
vub-prog-tr-95-02
"A Marriage of Class- and Object-Based Inheritance Without Unwanted Children"
Patrick Steyaert, Wolfgang De Meuter
Published in ECOOPÕ95 Proceedings

#Abstract:
Class-based languages have often been criticised for their rigidity.
Prototype-based languages on the other hand are usually considered too flexible. We claim that this flexibility is inherently correlated to encapsulation problems. We therefore propose a new scale of "encapsulated" inheritance mechanisms on objects that combine the object model of class-based languages with the inheritance mechanism of prototype-based languages. It is shown that they combine the advantages but shun the disadvantages of both paradigms. A denotational semantics of an exemplar encapsulated inheritance mechanism on objects is given and compared with the standard denotational semantics of class- and object-based inheritance. This comparison confirms our claims.

#Keywords:
inheritance, delegation, denotational semantics, mixins, encapsulation, Agora


#Reference:
vub-prog-tr-95-03
"Typing Dynamic Inheritance: A Trade-Off between Substitutability and Extensibility"
Carine Lucas, Kim Mens, Patrick Steyaert
Unpublished

#Abstract:
Recent developments in subjectivity, composition technology and novel prototype-based languages demonstrate that dynamic object extension is an essential feature in modern object-orientation. But the total absence of static type systems for dynamic object extension is a major obstacle for its adoption. The key principle of type-safe dynamic object extension is a trade-off between possible assignments and possible extensions. We describe a static type system using specialisation interfaces to refine the notion of subtyping and to limit dynamic extension. We furthermore argue that the introduction of specialisation interfaces in the system opens up a lot of new perspectives in software engineering in general. The type system is proven to be consistent and complete.

#Keywords:
typing, object-based languages, dynamic object extension, Agora


#Reference:
vub-prog-tr-95-04
"Static Typing of Dynamic Inheritance"
Carine Lucas, Kim Mens en Patrick Steyaert
Presented through a poster session at OOPSLA '95

#Abstract:
Recent developments in subjectivity, composition technology and novel prototype-based languages demonstrate that dynamic object extension is an essential feature in modern object-orientation. The total absence of static type systems for dynamic object extension is a major obstacle for its adoption. We describe a static type system using specialisation interfaces with a trade-off between possible assignments and possible extensions as key principle. We furthermore argue that the introduction of specialisation interfaces in the system opens up a lot of new perspectives in software engineering in general. 

#Keywords:
object oriented, static typing, dynamic inheritance


#Reference:
vub-prog-tr-95-05
"Normalising Class Components"
Marc Van Limberghen
Unpublished

#Abstract:
Class hierarchies are currently often subject to reorganisation even when the intended universe of discourse hasn't changed. These revisions unnecessarily burden the implementation process and are due to the fact that some design information is only implicitly present in the hierarchy. Whereas the relational database community has recognised the import of distributing data attributes over tables, the equivalent in OO class design, i.e. the distribution of attributes with behaviour over class components, has been totally neglected. This paper exactly determines the design information that is equivalent with this kind of attribute distribution and accordingly defines normal forms for class components.

#Keywords:
inheritance, normalisation, class components, class library


#Reference:
vub-prog-tr-95-06
"Encapsulation and Composition as Orthogonal Operators on Mixins: A Solution to Multiple Inheritance Problems."
Marc Van Limberghen and Tom Mens
Object-Oriented Systems Journal, Volume 3, Number 1, Chapman & Hall, February 1996

#Abstract:
In class-based multiple inheritance systems, interpretations as different as duplication, sharing and specialisation are associated with the single phenomenon of name collisions. To deal with those name collisions, various mechanisms have been proposed. But these solutions generally restrain software reusability which is considered to be one of the key features of OO systems. On top of this, most multiple inheritance systems do not completely cover all the different interpretations of name collisions.

This paper shows that the entire multiple inheritance dilemma can and should be seen as a conflict between inheritance and data encapsulation only. Orthogonalising these two concepts in a mixin-based framework will permit us to appropriately solve all the problems listed above. To this extent we propose a formal model together with its denotational semantics. This minimal multiple inheritance model establishes a valuable basis for OO languages and software engineering systems.

#Keywords:
Multiple Inheritance, Name Collisions, Mixins, Encapsulation, Composition


#Reference:
vub-prog-tr-95-07
"Ending the Tyranny of the Link: Adding Paths to the Dexter-model"
Serge Demeyer
Unpublished

#Abstract:
Hypermedia technology is a potential benefit for all computer applications that deal with information. To penetrate new markets, hypermedia systems should be tailorable to specific application domains. We claim that an open, extensible hypermedia system is crucial to attain such tailorability. A hypermedia system should be capable to integrate 1) facilities for incorporating vendor-independent document viewers and 2) flexible linking facilities that access external information repositories.This document describes how we extended the Dexter model with the "path" concept, to model hypermedia systems with extensible link engines. We show that paths absorb the notion of links and make it possible to integrate various strategies for resolving links.  This proves our claim that "paths end the tyranny of the link". This is demonstrated with a case from the Software Engineering Community: a framework browser. The case involves a hypermedia system that integrates a home-cooked world-wide web browser, an off-the-shelf word processor (Microsoft Word) and a programming environment for Smalltalk (VisualWorks). Besides interpreting embedded (HTML style) anchors, the system is able to query the Smalltalk environment to link documentation to Smalltalk source code. The case serves as a proof of concept that an extensible hypermedia system can penetrate specific application domains.

#Keywords:
Hypermedia, Open hypermedia systems, Dexter, Zypher, Software Engineering, Object-oriented framework, Design pattern, Framework browser


#Reference:
vub-prog-tr-95-08
"Self sends as primary construct:a criterion for object-oriented language design"
Tom Mens & Marc Van Limberghen
Unpublished

#Abstract:
Most object-oriented languages provide a self pseudo variable that serves two purposes: invoking methods through self sends and returning a self reference. Current formal models capture this behaviour by introducing a self parameter that fulfils both roles. We will show that this double functionality is incompatible with object-based encapsulation. Moreover we will point out that the separation of both functionalities is needed in type systems. We propose a formal model based on a primitive self send construct, and present its denotational semantics. A self reference is implemented through a self send instead of the other way around. This model is extended formally with an object-based encapsulation mechanism. It allows us to keep inheritance, encapsulation and typing orthogonal. This way we obtain a flexible and incremental software development scheme.

#Keywords:
language design, OO software engineering, formal model, denotational semantics

#End