===============================
ABSTRACTS OF TECHREPORTS 1996
===============================

#Reference:
oopartners-tr-96-01
"PSI: From custom developed applications to domain specific frameworks"
Arlette Vercammen, Wilfried Verachtert
Addendum to the Proceedings of OOPSLA '96 Conference on Object-Oriented Programming, Systems, Languages and Applications, San Jose, California, ACM Press

#Abstract:
This paper describes the experience we had at OO Partners with the design and implementation of PSI, a custom developed planning application for a TV-station, and its evolution into a complete domain specific framework that has been successfully installed at several TV-stations in Europe.
We report on our experience with object technology, in particular with Smalltalk, and on the barriers we encountered in designing and implementing the PSI framework. Furthermore, we expound on how we have organised ourselves to increase the productivity of our team and to obtain higher quality software that is more adaptable and reusable.
Due to our project approach, OO Partners has built up solid domain knowledge, which is the key to our success with PSI. Gathering this domain knowledge constitutes the major part of the investment. Frameworks are essential to leverage this investment. This experience also applies to other vertical markets.

#Keywords:
PSI, frameworks, software engineering, reuse


#Reference:
vub-prog-tr-96-01
"Class-management using Logical Queries, Application of a Reflective User Interface Builder"
Roel Wuyts
Proceedings of the Groningen Student Conference on Information Technology (GronicsÕ96)

#Abstract:
Current browsers for object-oriented languages suffer from restricted query
capabilities that only allow for class-oriented views on the classsystem. As
a result, browsers are very poor in providing support for software engineering
techniques that go beyond single classes, like  frameworks, contracts and
design patterns. This paper proposes the combination of a logical query language
and user interface components as a foundation for non class-oriented,
customizable browsers able to support recent and future object-oriented software
engineering techniques. Validation of this proposal is done by building browsers
for different domains in Smalltalk.

#Keywords:
Object-Oriented Programming, Programming environments, Logic Programming


#Reference:
vub-prog-tr-96-02
"Reflective Application Builders"
Patrick Steyaert, Koen De Hondt, Serge Demeyer, Niels Boyen
In Chris Zimmermann, editor, Advances in Object-Oriented Metalevel Architectures and Reflection. CRC Press Inc., Boca Raton, Florida

#Abstract:
Current visual application builders and application frameworks do not live up to their expectations of rapid application development or non-programming-expert application development. They fall short when compared to component-oriented development environments in which applications are built with components that have a strong affinity with the problem domain (i.e. being domain-specific). Although the latter environments are very powerful, they are hard to build and, in general, do not allow much variation in the problem domain that is covered. In this paper we show how this apparent conflict between generality and domain specificity can be overcome by considering application building itself as the problem domain. This naturally leads to the notion of a reflective application builder, i.e. an application framework-application builder pair that incorporates all the tools for the visual construction of (domain-specific) application builders.

#Keywords:
Reflection, Application Builders, ApplFLab


#Reference:
vub-prog-tr-96-03
"Formalising Operations on ACIDs and Their Interactions"
Kim Mens, Carine Lucas, Patrick Steyaert
Theoretical version of vub-prog-tr-96-05. Unpublished.

#Abstract:
This paper provides a formal foundation of the concept of Abstract Class Interface Descriptions (ACIDs). It gives a definition of both ACIDs and the operations defined on them and proves a number of properties concerning their interactions. In class libraries and frameworks documented with ACIDs these properties can be used to provide a better understanding of their layered structure and to help in assessing the impact of changes.

#Keywords:
adaptability, design reuse, ACIDs, abstract classes, class libraries, frameworks


#Reference:
vub-prog-tr-96-04
"The Zypher Meta Object Protocol"
Serge Demeyer - Koen De Hondt - Patrick Steyaert - Wim Codenie - Roel Wuyts - Theo D'Hondt
Presented at the second workshop on open hypermedia systems (Washington DC, US Ñ 1996)
Published in Wiil, U. K. / Demeyer, S. (Ed) "Proceedings of the 2nd Workshop on Open Hypermedia Systems - Hypertext'96"; UCI-ICS Technical Report 96-10. Department of Information and Computer Science, University of California, Irvine, CA 92717-3425.

#Abstract:
This paper discusses the necessity of a meta object protocol in the design of an open hypermedia system. It shows that a meta object protocol enables to tailor the behaviour and configuration of the hypermedia system, independent of its constituting elements.
The approach is demonstrated by means of the Zypher Open Hypermedia Framework, where the meta object protocol eases the incorporation of system services (i.e. caching, logging, authority control and integrity control) and flexible reconfiguration (i.e. run-time extensibility and cross-platform portability).

#Keywords:
hypermedia, open hypermedia systems, open implementation, meta object protocol


#Reference:
vub-prog-tr-96-05
"Reuse Contracts: Managing the Evolution of Reusable Assets"
Patrick Steyaert, Carine Lucas, Kim Mens, Theo D'Hondt
OOPSLA '96 Proceedings, ACM Press.

#Abstract:
A critical concern in the reuse of software is the propagation of changes made to reusable artefacts. Without techniques to manage these changes, multiple versions of these artefacts will propagate through different systems and reusers will not be able to benefit from improvements to the original artefact. We propose to codify the management of change in a software system by means of reuse contracts that record the protocol between managers and users of a reusable asset. Just as real world contracts can be extended, amended and customised, reuse contracts are subject to parallel changes encoded by formal reuse operators: extension, refinement and concretisation. Reuse contracts and their operators serve as structured documentation and facilitate the propagation of changes to reusable assets by indicating how much work is needed to update previously built applications, where and how to test and how to adjust these applications.

#Keywords:
abstract classes, design reuse, reuse contracts, software evolution


#Reference:
vub-prog-tr-96-06
"A Formalisation of Encapsulated Modification of Objects"
Kim Mens, Kris De Volder, Tom Mens
Unpublished

#Abstract:
Currently existing formalisations of object orientation are unsatisfactory w.r.t. inheritance. This is due to an inherent conflict between inheritance and encapsulation. To solve this conflict, we present a formal model with a clear syntactic distinction between Òinheritable entitiesÓ and objects. This model naturally gives rise to two types of incremental modification of objects without compromising encapsulation. Both types of modification are complementary from a software engineering point of view.

#Keywords:
formal object model, encapsulated object modification, software engineering, OPUS tNG


#Reference:
vub-prog-tr-96-07
"A Layered Calculus for Encapsulated Object Modification: Theoretical Results"
Kim Mens, Kris De Volder, Tom Mens
Theoretical version of vub-prog-tr-96-06. Unpublished.

#Abstract:
In this paper we formally present a layered calculus for encapsulated modification of objects. Its denotational as well as operational semantics are given. The confluency of the calculus is proven, and a translation of lambda calculus into our calculus is presented.

#Keywords:
object calculus, encapsulated object modification, denotational semantics, formal foundation, OPUS tNG


#Reference:
vub-prog-tr-96-08
"Building frameworks through specialisable nested objects"
Marc Van Limberghen
Published in TOOLS USA '96 Proceedings, Prentice Hall

#Abstract:
If a framework that internally creates objects is to be specialisable, then not only procedure calling must be subject to late-binding, but also object creation. In OO languages with compile-time classes, complicated extra code is needed that only serves to bypass the static character of class instantiation. The programmer has to maintain this code during framework specialisation. In languages with first-class classes or with prototypes, a structure of classes respectively prototypes has to be constructed and maintained during specialisation, an equally complicated task. 
This paper proposes specialisable nested objects to deal directly with late bound object creation in frameworks. Nesting is exploited between a framework and the objects that belong to it. Object-based encapsulation is provided to develop the framework and its specialisations more independently. 

#Keywords:
frameworks, object creation, object-based encapsulation, LENS


#Reference:
vub-prog-tr-96-09
"Reuse Contracts: Managing Evolution in Adaptable Systems"
Kim Mens, Patrick Steyaert, Carine Lucas
Presented at the ECOOP Ô96 Workshop on Adaptability in Object-Oriented Software Development. Published in ECOOP Ô96 Workshop Proceedings, Dpunkt Verlag

#Abstract:
Adaptable systems are often described as being composed of a persistent part that remains more or less stable throughout the evolution of the system and of more transient parts which are derived from the persistent part. Current research on adaptability seems to be biased towards adaptable systems of which the persistent part does not evolve at all. We argue that the issue of managing the evolution of the persistent part itself is not only a central issue in the practical application of adaptability, but is a key question in the understanding of adaptability: although changes to the persistent part occur only occasionally, most often these changes have a very large impact on the rest of the system; only very controlled changes guarantee that the rest of the system will remain more or less consistent. We propose to manage these changes by means of reuse contracts and reuse operators. Rather than having a template rigidly enforced by the builder of the adaptable system, with reuse contracts a reuser declares on which parts of the adaptable system he relies, what parts of the design he respects and what parts he violates. This enables evolution of the adaptable system, reuse of adaptations to different adaptable systems, and a more layered approach to adaptation.

#Keywords:
Reuse contracts, adaptability, transient, persistent, change propagation, evolution


#Reference:
vub-prog-tr-96-10
"Research Topics in Composability"
Carine Lucas, Patrick Steyaert, Kim Mens
Presented at the ECOOP Ô96  Workshop on Composability Issues in Object-Orientation. Published in ECOOP Ô96 Workshop Proceedings, Dpunkt Verlag

#Abstract:
While composability is a much desired quality for software artefacts, there is no consensus whatsoever on what composability really is, nor on how it can be achieved. In this position paper we discuss three inhibitors of composability and hint at possible solutions. It is our conjecture that tackling these three problems is crucial to achieve true composability.

#Keywords:
Reuse contracts, composability, documentation, change propagation, evolution


#Reference:
vub-prog-tr-96-11
"Effort Estimation for Changing Requirements"
Patrick Steyaert, Wim Codenie, Wilfried Verachtert
Presented at the OOPSLA Ô96 Workshop on OO Process and Metrics for Effort Estimation

#Abstract:
Complex software systems have to cope with a steady stream of changing requirements. However, current software engineering techniques are ill equipped for assessing the impact of changes, either within a single system or across reused assets and the systems in which they are reused. This is a critical inhibitor for (amongst others) effort estimation in the object-oriented development process where reuse and incremental development play a crucial role. We have been confronted with this problem in deriving a commercial domain specific framework from a custom built application (in the area of broadcast planning). In this case the problem boils down to efficient effort estimation of customisations of the framework early in the development process. In the context of a research project we are investigating reuse contracts as a possible solution.

#Keywords:
Reuse contracts, evolution, metrics, effort estimation


#Reference:
vub-prog-tr-96-12
"Documenting Evolving Software Systems through Reuse Contracts"
Kim Mens, Patrick Steyaert, Carine Lucas
Presented at the OOPSLA Ô96  Workshop on Object-Oriented Software Evolution and Re-engineering

#Abstract:
Current methodological and tool support for managing the evolution of large, long-lived software systems, focuses mainly on minimising dependencies between system parts. However, the question what happens when these dependencies are changed at some point during the evolution process is largely neglected. Documenting these dependencies by means of reuse contracts and reuse operators allows us to signal such changes and to assess their impact. Many tools to support the use of reuse contracts for managing software evolution can be conceived. When adopted, reuse contracts may significantly enhance the way in which software is being built and managed.

#Keywords:
Reuse contracts, evolution, re-engineering


#Reference:
vub-prog-tr-96-13
"Agora: Reintroducing Safety in Prototype-based Languages"
Wolfgang De Meuter, Tom Mens, Patrick Steyaert
Presented at the ECOOP '96 Workshop on Prototype-Based Languages

#Abstract:
Prototype-based languages are often described as being more flexible and expressive than class-based languages. This greater flexibility makes prototype-based languages well-suited for rapid prototyping and exploratory programming, but comes with a serious loss of safety. Examples of this are the encapsulation problem and the prototype corruption problem most prototype-based languages suffer from. These problems preclude prototype-based languages from being widely used. We propose a prototype-based language that eliminates these problems and thus reintroduces safety in prototype-based languages.

#Keywords:
Agora, mixin methods, encapsulation problems, prototype-based languages


#Reference:
vub-prog-tr-96-14
"A lens on the encapsulation operator"
Marc Van Limberghen, Tom Mens
Unpublished.

#Abstract:
In [VanLimberghen&Mens96] we showed how an orthogonal combination of two operators,
inheritance and encapsulation, provided a solution for multiple inheritance problems
in class-based systems. In this document we elaborate further upon this idea in two ways.
First we present a small prototype-based language called LENS incorporating the two
operators. Secondly we focus on the encapsulation operator, and argument a further
decomposition of this operator in two more primitive operators, namely preventInvocation
and preventSpecialisation.

#Keywords:
LENS, orthogonality, encapsulation, object-oriented language design


#Reference:
vub-prog-tr-96-15
"Encapsulation and Composition as Orthogonal Operators on Mixins: A Solution to Multiple Inheritance Problems"
Marc Van Limberghen, Tom Mens
Object-Oriented Systems Journal, Volume 3, Issue 1, Chapman & Hall, pp. 1-30

#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:
mixins, multiple inheritance, encapsulation, composition


#Reference:
vub-prog-tr-96-16
"A Layered Calculus for Encapsulated Object Modification"
Kim Mens, Kris De Volder, Tom Mens
Unpublished.

#Abstract:
Current prototype-based languages suffer from an inherent conflict between
inheritance and encapsulation. Whereas encapsulation tries to hide implementation details from
the user, inheritance depends at least to some extent on exposing these implementation details.
We propose a powerful calculus with dynamic object modification which solves this conflict.
This calculus constitutes a formal foundation of prototype-based languages with a clean
interaction between encapsulation and inheritance.


#Reference:
vub-prog-tr-96-17.pdf
"A Layered Calculus for Encapsulated Object Modification -- Extended Abstract"
Kim Mens, Kris De Volder, Tom Mens, Patrick Steyaert
Extended Abstract.

#Abstract:
Current prototype-based languages suffer from an inherent conflict between inheritance and encapsulation. Whereas encapsulation tries to hide implementation details from the user, inheritance depends at least to some extent on exposing these implementation details.
We propose a powerful calculus with dynamic object modification which does not have this
conflict. This calculus constitutes a formal foundation of prototype-based languages with a
clean interaction between encapsulation and inheritance.

#End