===============================
ABSTRACTS OF TECHREPORTS 1999
===============================

#Reference:
vub-prog-tr-99-01
"Optimizing Object-Oriented Languages Through Architectural Transformations"
Tom Tourwe and Wolfgang De Meuter
Published in Proceedings of the 8th International Conference on Compiler Construction. 

#Abstract:
Certain features of the object-oriented paradigm are a serious impediment for the runtime performance of object-oriented programs. Although compiler techniques to alleviate this problem were developed over the years, we will present some real-world examples which show that these solutions fall short in making any significant optimizations to systems that are required to be very flexible and highly reusable. As a solution, we propose a radically different approach: using an open compiler to "compile away" whole designs by performing architectural transformations based on programmer annotations. We will discuss this approach in detail and show why it is more suited to solve the efficiency problems inherently associated with object-oriented programming.

#Keywords:
optimization, open compilers, transformation systems


#Reference:
vub-prog-tr-99-02
"Declaratively Codifying Software Architectures using Virtual Software Classifications"
Kim Mens and Roel Wuyts
Submitted to TOOLS.

#Abstract:
Most current-day software engineering tools and environments do not sufficiently allow
software engineers to declare or enforce the intended software architecture. On the one hand,
architectures are typically described at a too low level, inhibiting their evolution and un-
derstanding. On the other hand most tools provide little support to automatically verify
whether the source code conforms to the architecture. Therefore, a formalism is needed in
which architectures can be expressed at a sufficiently abstract level, without losing the ability
to perform automatic conformance checking. We propose to declaratively codify software ar-
chitectures using virtual software classifications and relationships among these classifications.
We illustrate how software architectures can be expressed elegantly in terms of these virtual
classifications and how to keep them synchronized with the source code.

#Keywords:
software architecture, checking consistency, software classification, declarative reasoning


#Reference:
vub-prog-tr-99-03
"Using Reflective Logic Programming to Describe Domain Knowledge as an Aspect"
Maja D'Hondt, Wolfgang De Meuter, Roel Wuyts
Proceedings of the First International Symposium on Generative and Component-Based Software Engineering (GCSE'99).

#Abstract:
Software applications, mostly consisting of an algorithm applied
to domain knowledge, are hard to maintain and to reuse as a result
of their hard coded combination. We propose to follow the principles of
aspect-oriented programming, separating the domain from the algorithm
and describing them in a logic and conventional programming language
respectively. In this paper, we report on an experiment that was conducted
to validate this hypothesis, and to investigate the requirements
of a programming environment for this configuration. An already existing
environment that uses a logic meta-language to reason about object-oriented
systems, SOUL, is used as a starting point for this experiment.
The result is a working implementation in SOUL, which validates our
ideas, reveals mechanisms that require more research, and points to other
features that should be included.

#Keywords:


#Reference:
vub-prog-tr-99-04
"Managing Unanticipated Evolution of Software Architectures"
Kim Mens, Tom Mens, Bart Wouters, Roel Wuyts
Workshop paper for the Architectural Evolution workshop of ECOOP '99, Lisbon, Portugal, 1999.

#Abstract:
Few existing approaches towards architectural evo-
lution deal with unanticipated evolution. This is
an important restriction, since a lot of architectural
changes are very difficult to anticipate. The reuse
contract formalism has been designed specifically to
deal with unanticipated software evolution, and has
already proven its practical use in different domains.
We claim that the reuse contract approach can be
applied to the domain of software architectures, to
manage unanticipated evolution of software architec-
tures.

#Keywords:
software architecture, unanticipated software evolution, reuse contracts


#Reference:
vub-prog-tr-99-05
"Aspect-Oriented Logic Meta Programming"
Kris De Volder, Theo D'Hondt
Proceedings of Meta-Level Architectures and Reflection, Second International Conference, Reflection'99. LNCS 1616, pp. 250-272, Springer-Verlag, 1999.

#Abstract:
We propose to use a logic meta-system as a general framework
for aspect-oriented programming. We illustrate our approach with
the implementation of a simplified version of the COOL aspect language
for expressing synchronization of Java programs. Using this case as an
example we illustrate the principle of aspect-oriented logic meta programming
and how it is useful for implementing weavers on the one hand and
on the other hand also allows users of AOP to fine-tune, extend and adapt
an aspect language to their specific needs.

#Keywords:
aspect-oriented programming, logic meta programming


#Reference:
vub-prog-tr-99-06
"The Use of Ontologies as a Backbone for Software Engineering Tools"
Dirk Deridder, Bart Wouters
Technical Report, Programming Technology Lab, 1999.

#Abstract:
The last few years research efforts concerning ontologies in computer science and artificial intelligence have been focussed on methodologies, formalisms and tools to build and to browse ontologies. Although everybody is convinced of the power and use of ontologies, until now no real proof exists of their potential in the domain of Software Engineering.
In every phase of software engineering, communication is one of
the major activities (in duration as well as importance). Throughout
the whole software development life-cycle, natural language is one of
the major means to describe the different artifacts used.
One of the most burdensome problems associated herewith is the
natural language ambiguity. Very often mistakes are made because
words can be interpreted in a variety of ways. This could be due to
the fact that those persons work in another domain, speak another
language or simply because the word has multiple meanings and the
context doesn't single out the correct significance or meaning.
As a consequence of such a misunderstanding vast parts of a sys-
tem might have to be rebuilt, remodeled, re-coded and re-debugged
resulting in unanticipated delays and increased costs.

#Keywords:
ontologies, software engineering, tool support

#End
ABSTRACTS OF DISSERTATIONS 1999
-------------------------------

#Reference:
vub-prog-phd-99-01
"A Formal Foundation for Object-Oriented Software Evolution"
Tom Mens
PhD dissertation, Programming Technology Lab, September 1999

#Abstract:

#Keywords:
software evolution, conditional graph rewriting, formal,
reuse contracts, merging


#Reference:
vub-prog-ms-99-01
"Managing Evolution of Software Architectures with Reuse Contracts"
Natalia Romero
Masters dissertation, Programming Technology Lab, August 1999

#Abstract:

#Keywords:
software architecture, software evolution, reuse contracts


#Reference:
vub-prog-ms-99-02
"Definition and Validation of Statically Typed Reuse Contracts"
Veronica Arganaraz
Masters dissertation, Programming Technology Lab, August 1999

#Abstract:

#Keywords:
static typing, software evolution, reuse contracts


#Reference:
vub-prog-ms-99-03
"Full Distribution Transparency, without losing control - AOP to the reuse"
Johan Fabry
European Masters in Object-Oriented Software Engineering, August 1999

#Abstract:

#Keywords:


#Reference:
vub-prog-lic-99-01
"Converting Software into Hardware: Hardware/Software Co-Design for a Virtual Machine"
Wim De Muynck
Licenciate dissertation, Programming Technology Lab, July 1999

#Abstract:

#Keywords
virtual machine


#End