===============================
ABSTRACTS OF TECHREPORTS 1998
===============================

#Reference:
vub-prog-tr-98-01
"Agora: The Story of the Simplest MOP in the World - or - The Scheme of Object-Orientation"
Wolfgang De Meuter
Published in Prototype-based Programming, Springer Verlag, 1998. Eds: J. Noble, I. Moore, A. Taivalsaari

#Abstract:
This paper discusses the design and implementation of the Agora language.  Many ideas behind Agora come from Scheme, to our opinion, still one of the pearls of programming languages.
The most prominent ideas of Scheme are 1) Everything is a first class value, 2) Scheme programs look the same as Scheme data structures, 3) Function application and special form application are the only control structures, and 4) The language can be extended by writing new special forms.
One of the contributions of Agora is to transform these features into object-orientation. 1) In Agora, everything is an object.  2) Agora programs themselves are nothing but objects, the data structures of
Agora.  3) The only control structures of Agora are messages and `reifier messages', the object-oriented analogue of special forms.  4) Agora can be easily extended by writing new reifier messages.
We will show that all these Agora characteristics are an immediate consequence of its extremely simple meta-object protocol (MOP).

#Keywords:
prototypes, reflection, Agora


#Reference:
vub-prog-tr-98-02
"Giving Precise Semantics to Reuse in UML"
Tom Mens, Carine Lucas, Patrick Steyaert
Published in Proceedings of PSMT '98 Workshop on Precise Semantics for Software Modeling Techniques, Technical Report TUM-I9803, Technische Universitat Munchen

#Abstract:
In UML there is little support for reusing specifications and designs. To deal with this problem, we enhance UML with support for definition, reuse and evolution of reusable components. This is not a trivial task, since some language concepts lack a precise semantics, while the interpretation of others is simply "beyond the scope of UML". By providing our own definitions in these cases, and by making use of packages, refinements, and the built-in extension mechanisms, a precise semantics is given to reuse of UML models. Among others, this precise semantics allows us to detect reuse conflicts automatically.

#Keywords:
UML, reuse, precise semantics, reuse contracts, incremental modification


#Reference:
vub-prog-tr-98-03
"Type-Oriented Logic Meta Programming for Java"
Kris De Volder
Unpublished.

#Abstract:
This paper presents type-oriented logic meta-programming. The idea is based on a representation of programs as sets of logic propositions focusing on the type properties of the base-language program. This representation allows generation of base-level code from compile-time logic meta programs that manipulate code fragments and their type properties. We apply this idea to Java and present TyRuBa, a type-oriented logic meta-programming system for Java. We illustrate that TyRuBa subsumes existing proposals for adding parametric and bounded parametric polymorphism to Java and surpasses them in expressive power.

#Keywords:
Java, code generation, logic programming, types, meta programming


#Reference:
vub-prog-tr-98-04
"Supporting Disciplined Reuse and Evolution of UML Models"
Tom Mens, Carine Lucas, Patrick Steyaert
Published in The Unified Modeling Language. <<UML>>'98: Beyond the Notation. Proceedings of First International Workshop, Selected Papers, LNCS 1618, Springer-Verlag, 1999. Eds: P.-A. Muller, J. Bezivin

#Abstract:
UML provides very little support for modelling evolvable or reusable specifications
and designs. To cope with this problem, the UML needs to be extended with support
for reuse and evolution of model components. As a first step, this paper enhances
the UML metamodel with the "reuse contract" formalism to deal with evolution of
collaborating class interfaces. Such a formal semantics for reuse allows us to
detect evolution and composition conflicts automatically.

#Keywords:
disciplined reuse, disciplined evolution, model components, collaborations, UML metamodel


#Reference:
vub-prog-tr-98-05
"Declarative Reasoning about the Structure of Object-Oriented Systems"
Roel Wuyts
Published in Proceedings of TOOLS USA '98.

#Abstract:
The structure of object-oriented systems typically forms 
a complicated, tangled web of interdependent classes. Understanding 
this implicit and hidden structure poses severe problems to developers 
and maintainers who want to use, extend or adapt those systems. This 
paper advocates the use of a logic meta-language to express and 
extract structural relationships in class-based object-oriented 
systems. As validation the logic meta-language SOUL was implemented 
and used to construct a declarative framework that allows reasoning 
about the structure of Smalltalk programs. The declarative 
framework's usefulness is illustrated by expressing different 
high-level structural relationships such as those described by design 
patterns.

#Keywords:
logic programming, meta programming, design, Smalltalk


#Reference:
vub-prog-tr-98-06
"Towards an Explicit Intentional Semantics for Evolving Software"
Kim Mens
Doctoral Symposium Proceedings of the 13th IEEE Automated Software Engineering Conference. October 13, 1998, Honolulu, Hawaii.

#Abstract:
The subject of this work is the study of software engineers'
intentions and the importance of using the information provided
by such intentions during the software engineering process. More
specifically, we will study how explicit software intentions can
contribute to a better understanding of the software, and how 
automated reasoning about explicit software intentions can facilitate
many software engineering activities, and software evolution in
particular.

#Keywords:
software engineering, intention, software evolution,
software understanding


#Reference:
vub-prog-tr-98-07
"Applying Reuse Contracts in a Product Line Approach"
Carine Lucas, Kim Mens, Patrick Steyaert, Wilfried Verachtert
Presented at the OOPSLA'98 Workshop on Object Technology and Product Lines

#Abstract:
Our research on reuse contracts demonstrated how a better documentation of
the dependencies between reusable assets and their reusers can help in
managing the evolution of reusable assets and in achieving disciplined
reuse. However, in trying to apply our results to product lines we still
encounter multiple problems. This position paper shortly introduces reuse
contracts and then raises some topics of research we feel are crucial in
order to set up successful product lines.

#Keywords:
reuse contracts, product line, software evolution


#Reference:
vub-prog-tr-98-08
"Annotating Evolving Software with Explicit Intentions"
Kim Mens
Workshop paper. Proceedings of the International Workshop on Principles of Software Evolution IWPSE98, Kyoto, Japan, April 20 and 21, pages 140-145, 1998.

#Abstract:
Our position statement is that current software evolution techniques suffer
from a lack of documentation on software developers' intentions and that
mechanisms to support evolution can vastly be improved by making these
intentions explicit in the software. We provide an intuitive definition of
``intentions'', explain which kinds of intentions can be distinguished,
discuss how such intentions can be made explicit in the software by
attaching annotations to software artefacts and argue how such information
can provide support during the software development process (and during
software evolution in particular). Because of the preliminary status of
this work, we mainly try to discover the important research questions to be
answered and research topics to be investigated.

#Keywords:


#Reference:
vub-prog-tr-98-09
"Assessing the Architectural Quality of Evolvable Systems"
Tom Mens, Kim Mens
Extended abstract for ECOOP'98 Workshop on Techniques, Tools and Formalisms for
Capturing and Assessing Architectural Quality in Object-Oriented Software. A two-page
summary of this submission can be found in the ECOOP '98 Workshop Reader, Springer-Verlag.

#Abstract:
Object-oriented software systems have a natural tendency to evolve. This can be
due to many different reasons such as changing requirements, software maintenance,
etcetera. Current trends even seem to indicate that continuously evolving systems will
become the norm for most organisations. To cope with this fact, architectures and designs
should be made as adaptable and reusable as possible. This is the only way to facilitate the
evolution and maintenance of software systems, and to avoid them turning into legacy
systems. We propose the reuse contract formalism as a methodology to make architectures
and designs more reusable.

#Keywords:
software quality, reusability, evolvability, software architectures, reuse contracts


#Reference:
vub-prog-tr-98-10
"Workshop Report on Tools and Environments for Business Rules"
Kim Mens, Roel Wuyts, Dirk Bontridder, Alain Gryseels
Workshop Report for ECOOP '98 Workshop on Tools and Environments for Business Rules

#Abstract:
This workshop focussed on the requirements for tools and
environments that support business rules in an object-oriented setting
and attempted to provide an overview of possible techniques and tools for
the handling, definition and checking of these rules and the constraints
expressed by them during analysis, design and development of object-
oriented software.

#Keywords:
business rules


#Reference:
vub-prog-tr-98-11
"A Basic Formalism for Systematic Software Evolution"
Tom Mens
Position Paper at ICSE '98 International Workshop on Principles of Software Evolution

#Abstract:
In this extended abstract, we present reuse contracts as a simple
but powerful formalism for dealing with software evolution in a
systematic way.

#Keywords:
reuse contracts, software evolution, conflict detection

#Reference:
vub-prog-tr-98-12.pdf
"Reuse Contracts : Connecting Bottom-Up and Top-Down Reuse"
Kim Mens, Carine Lucas, Patrick Steyaert, Wilfried Verachtert
Position paper, OOPSLA 1998 Workshop on Object Technology, Architecture, and Domain Analysis-- Experiences in Making the Connection

#Abstract:
Whereas most object-oriented technologies traditionally achieve reuse in a bottom-up fashion, the research areas of architectures and domain analysis advocate a top-down approach to achieve systematic reuse. Practice shows that a combination of both is often desired or needed. The reuse contracts model can provide such a combination and can make the connection between object technology, architectures and domain analysis.

#Keywords:


#End
ABSTRACTS OF DISSERTATIONS 1998
-------------------------------

#Reference:
vub-prog-phd-98-01
"Type-Oriented Logic Meta-Programming"
Kris De Volder
PhD thesis, Programming Technology Lab, 1998

#Abstract:
The dissertation shows that undecidable and ambiguous type
systems have useful applications and should therefore be considered
viable options for future statically typed
object-oriented languages.
Traditionally, type systems have been included into programming languages
for the following reasons
 - documentation: Static types improve the readability of programs.
 - robustness: Detection of ``type errors''.
 - efficiency: Optimizations based on static type knowledge.
The aforementioned uses are passive in the sense that types have
mostly a descriptive nature. This makes them great as
documentation. The type checker verifies whether the description is a
consistent one and this increases robustness by eliminating type
errors. Optimizers also make use of the descriptive nature of types to
perform optimizations.
We want to draw attention in this dissertation to the potential of
''actively'' using static types, writing real programs that manipulate
types: consult them, construct them, or make decisions regarding
interfaces or internal representations of classes. In short, we want
to draw attention to the potential of active manipulation of types by
real ''type programs'', expressed with a real, Turing-complete,
type-programming language. It is in this active type manipulation that
lies the currently unharvested potential which makes undecidable and
ambiguous type systems potentially useful.

To prove our thesis we implemented a system which offers a
full-fledged logic programming language with which types can be constructed,
consulted and implemented. This approach is highly reminiscent of and
inspired by the flavor of instance declarations for type and
constructor classes in the functional languages Gofer and Haskell.
Because of limited resources we have been forced to take a less than
perfect approach.  The system we implemented is not a real type system
in the true sense of the word since it does no type checking of its
own. Type systems for object-oriented languages being very complicated
artifacts both theoretically and implementation wise, this was not a
feasible option to us. Instead, our system generates Java code and
leaves type checking to the Java compiler. Potential type errors are
therefore only detected in as far as the generated output code
violates the Java typing rules. Clearly this is not what one wants
for a production level environment. However, since the added potential
of having a Turing-complete type language is in active type
manipulation rather than in the type-checking aspect of the system,
this is sufficient to prove our point.
The dissertation provides several examples that illustrate the
usefulness of having a real, Turing complete, type-programming
language. These examples show how type-oriented meta programming
complements the expressiveness of the base programming
language. Amongst others, we discuss how type-oriented logic meta
programming is potentially useful to support aspect-oriented
programming.  

#Keywords:



#Reference:
vub-prog-phd-98-02
"A Novel Approach to Architectural Recovery in Evolving Object-Oriented Systems"
Koen De Hondt
PhD thesis, Programming Technology Lab, December 1998

#Abstract:
Coping with evolution is one of the major issues in software development today. Software evolution is necessary to keep software from ageing in the rapidly changing world we live in. Software evolution is a continuous process that requires models of the software, in particular models of the software architecture. In absence of appropriate and reliable software documentation, reverse engineering is often the only way to acquire a mental model of the software.
The thesis of this research is that the software development environment should provide support for recording models that result from reverse engineering efforts, so that the models become online software documentation that can be exploited in subsequent software development activities.
This dissertation proposes software classification as an approach to architectural recovery in evolving object-oriented systems. The results of recovery are tangible entities in the software development environment. Software classification has two aspects: the software classification model and the software classification technique.
The software classification model is very simple - classifications are containers of items and items can be classified in multiple classifications - but apparently it is a powerful model to organise software entities in a exible and uniform manner. The software classification technique is the act of classification. Several software classification strategies are conceivable. In this work, four classification strategies are used in the applications of software classification: manual classification, virtual classification, classification with advanced navigation tools, and automatic classification through method tagging.
Five applications of software classification are discussed: expressing multiple views on software, recovery of collaboration contracts, recovery of reuse contracts, recovery of architectural components, and management of changes.
The viability of the proposed concepts, methods and tools is demonstrated by applying
them on parts of a large and complex object-oriented software system developed in industry.

#Keywords:
software classiffication, collaboration contracts, reuse contracts, software evolution, reverse engineering, architectural recovery, object-oriented software development environments


#Reference:
vub-prog-lic-98-01
"A Framework for Replication of Objects Using Aspect-Oriented Programming"
Johan Fabry
Licentiate Thesis, Programming Technology Lab, July 1998

#Abstract:

#Keywords:


#End