===============================
ABSTRACTS OF TECHREPORTS 2000
===============================

#Reference:
vub-prog-tr-00-01
"Conditional Graph Rewriting as a Domain-Independent Formalism for Software Evolution"
Tom Mens
Proceedings of Agtive '99 Workshop, LNCS, Springer-Verlag, 2000.

#Abstract:
This paper presents a formal approach for managing unanticipated software evolution. Labelled typed nested graphs are used to represent arbitrarily complex software artifacts, and conditional graph rewriting is used for managing evolution of these artifacts. More specifically, we detect structural and behavioural inconsistencies when merging parallel evolutions of the same software artifact. The approach is domain-independent, in the sense that it can be customised to many different domains, such as software architectures, UML analysis and design models, and software code.

#Keywords:
software evolution, software merging, domain-independence, graph rewriting, formal foundation


#Reference:
vub-prog-tr-00-02
"Automating Support for Software Evolution in UML"
Tom Mens, Theo D'Hondt
Automated Software Engineering Journal 7:1, pp. 37-57, February 2000.

#Abstract:
Disciplined support for evolution of software artifacts is important in all phases of the software life-cycle. In order to achieve this support, a uniform underlying foundation for software evolution is necessary. While, in the past, reuse contracts have been proposed as such a formalism in a number of different domains, this paper generalises the formalism, and integrates it into the UML metamodel. As such, support for evolution becomes readily available for many kinds of UML models, ranging from requirements to the implementation phase.

#Keywords:
software evolution, UML metamodel, reuse contracts

#Reference:
vub-prog-tr-00-03
"Co-Evolution of Object-Oriented Software Design and Implementation"
Theo D'Hondt, Kris De Volder, Kim Mens, Roel Wuyts
Published in TACT Symposium Proceedings, Kluwer Academic Publishers.

#Abstract:
Modern-day software development shows a number of feedback loops between various phases in its life cycle; object-oriented software is particularly prone to this. Whereas descending through the different levels of abstraction is relatively straightforward and well supported by methods and tools, the synthesis of design information from an evolving implementation is far from obvious. This is why in many instances, analysis and design is used to initiate software development while evolution is directly applied to the implementation. Keeping design information synchronised is often reduced to a token activity, the first to be sacrificed in the face of time constraints. In this light, architectural styles are particularly difficult to enforce,  since they can, by their very nature, be seen to crosscut an implementation. This contribution reports on a number of experiments that use logic meta-programming (LMP) to augment an implementation with enforceable design concerns, including architectural concerns. LMP is an instance of hybrid language symbiosis, merging a declarative (logic) meta-level language with a standard object-oriented base language. This
approach can be used to codify design information as constraints or even as a process for code generation. LMP is an emerging technique, not yet quite out of the lab. However, it has already been shown to be very expressive: it incorporates mechanisms such as pre/post conditions and aspect-oriented programming. We found the promise held by LMP extremely attractive, hence this paper.

#Keywords:
co-evolution, declarative meta-programming, object-orientation


#Reference:
vub-prog-tr-00-04
"A Uniform Declarative Framework for Automated Software Merging"
Tom Mens, Kim Mens
Submitted to the ASE 2000 Conference.

#Abstract:
We report on a prototype tool that automates the time-consuming and error-prone process of
software merging. Our tool is significantly more flexible than existing merge techniques, as it can
detect syntactic, structural as well as semantic conflicts. It is implemented as a general framework for
software evolution that can be customised to many different domains. Because of this, it can be used to
support evolution of any kind of software artifact, independent of the target language or the considered
phase in the software life cycle.

#Keywords:
software merging, software evolution, conflict detection, tool support, declarative programming

#Reference:
vub-prog-tr-00-05
"The Use of an Ontology to Support a Coupling between Software Models and Implementation"
Dirk Deridder, Bart Wouters, Wim Lybaert
ECOOP 2000, International Workshop on Model Engineering.

#Abstract:
During the software development life cycle, a system to be built is documented by textual and graphical specifications of the requirements. The overall process of documenting and keeping this documentation internally consistent is a major and time-consuming task. Some of the most burdensome problems associated herewith are the problem of ambiguity of textual documentation, the generality of graphical representations and the problem of keeping the documentation externally consistent towards the implementation.
In this paper we follow a more structured approach to document a system as well as to implement it, by linking artifacts from the documentation and the implementation using an ontology.  This results in a shared meta-documentation, which provides a coupling between the results of the analysis/design phase to the results of the implementation phase.  The business rules that represent the concepts as well as the relations and the rules will be expressed in the Smalltalk Open Unification Language (SOUL).  Our approach will enable better changes management and impact analysis amongst others.

#Keywords:
Ontology, Software Models

#Reference:
vub-prog-tr-00-06
"The use of Ontologies as a backbone for use case management"
Bart Wouters, Dirk Deridder, Ellen Van Paesschen
ECOOP 2000, Workshop : Objects and Classifications, a natural convergence.

#Abstract:
Towards end-users, use cases provide an intuitive and easy to understand
notation to capture the requirements of a system.  This is a major benefit,
and is also the main reason why software engineers favor them above other
notations.  However, as a result of this simplicity, they are less suitable
to communicate the requirements in a precise, and unambiguous format towards
developers.  Also managing large sets of use cases becomes a troublesome and
almost impossible task. In this paper we present ongoing research on a case
based semi-formal approach for use cases, supported by a notion of
ontologies, to resolve this drawback amongst others.

#Keywords:
Ontology, Use Case Management

#Reference:
vub-prog-tr-00-07
"Declarative Composable Aspects"
Johan Brichau
OOPSLA 2000, Workshop: Advanced Separation of Concerns

#Abstract:
Our position paper argues that a logic programming (i.e. 
declarative) approach to separation of concerns enables a composition 
technology that is much easier to handle than standard approaches. 
Concerns are 'declared' by writing logic facts. Combinations of 
concerns arise by writing rules that are to be seen as compositely 
declared concerns that consist of more elementary concerns. By using 
logic programs, the 'concern programmer' only has to focus on what 
the concerns are about and not about how they will be combined by the 
weaver. The latter is the job of the inference engine.

#Keywords:
aspect oriented programming, separation of concerns, 
declarative aspects, composition of aspects, logic metaprogramming

#Reference:
vub-prog-tr-00-08
"Jumping Aspects"
Johan Brichau, Wolfgang De Meuter, Kris De Volder
ECOOP 2000, Workshop: Aspects & Dimensions of Concerns workshop

#Abstract:
In this paper we identify a need for AOP-approaches dealing 
with "jumping aspect code". This is a cross-cutting phenomenon which 
occurs because code needs to be added to components depending on 
their usage-context. As a result it is very hard to identify the 
specific join points at which aspect code needs to inserted. The join 
points seem to be jumping around the code depending on the context in 
which a component is used.

#Keywords:
aspect oriented programming, separation of concerns

#Reference:
vub-prog-tr-00-09
"Declarative Meta Programming for a Language Extensibility Mechanism"
Johan Brichau
ECOOP 2000, Workshop : Reflection and Meta Level Architectures

#Abstract:
As an open mechanism to extend a programming language, we 
propose to use a transformation language that benefits from the 
pattern matching and unification algortihms present in a logic 
language. Therefore, our approach boils down to a macro-mechanism 
with declarative meta programming as an expansion mechanism.

#Keywords:

#Reference:
vub-prog-tr-00-10
"Logic Meta Components as a Generic Component Model"
Kris De Volder, Johan Fabry, Roel Wuyts
Fifth International Workshop on Component-Oriented
Programming, Proceedings of ECOOP'2000, Cannes, France, 2000

#Abstract:
Current component models depend on the modularization mechanism of the language in which they are defined. This significantly restricts what the functionality and contents of potential components can be. We propose a logic meta programming view on a software system. This allows not only component composition orthofonal to and independent of base language modularization mechanisms, but also the creation of generic components.

#Keywords:

#Reference:
vub-prog-tr-00-11.pdf
"Distribution as a Set of Cooperating Aspects"
Johan Fabry
ECOOP2000 workshop on Distributed Objects Programming Paradigms

#Abstract:
This paper describes work done in the Aspect-oriented Programming (AOP) community, whose goal is to simplify development of programs by enabling the application of the principle of separation of concerns where this was previously not possible. 
The AOP community has performed work relating to a number of aspects of particular significance to the field of distributed computing: coordination, replication, and the handling of remote methods. The combination of these three aspects would allow distribution to be treated as a separate concern, which would significantly simplify the implementation and maintenance of distributed systems. Furthermore, as work is performed on more aspects relevant to distribution, this work could also be integrated, which would further simplify the implementation of distributed systems.
However, note that treating distribution as a separate concern does not mean that the programmer is totally unaware of the fact that the system is a distributed system. The program must still be structured accordingly, but the implementation and maintenance is simplified significantly by using aspects. This is due to the extension of the conceptual separation of the distribution concern into a separation at an implementation level.

#Keywords:
reuse, frameworks, reasoning, expert systems

#Reference:
vub-prog-tr-00-12.pdf
"Reasoning with Design Knowledge for Interactively Supporting Framework Reuse"
Wolfgang De Meuter, Maja D'Hondt, Sofie Goderis, Theo D'Hondt
submitted to scase01

#Abstract:
The paper explains our efforts in using a rule-based reasoning engine
to actively support reuse of object-oriented frameworks.  The engine
is embedded in the programming environment and is able to reason about
the developed source code.  By means of explicitly encoded design
knowledge, it is able to actively guide the reuse process by
intelligently assisting the programmer in taking the appropriate reuse
steps.  Reuse thus becomes an interaction between the programmer and
the reasoning engine.
Two conducted experiments are explained in this paper, illustrating
the applicability of such an embedded rule-based inference engine to
explicitly guide both black box and white box reuse.

#Keywords:


#Reference:
vub-prog-tr-00-13
"On the Use of Declarative Meta Programming for Managing Architectural Software Evolution"
Tom Mens, Kim Mens, Roel Wuyts
Position paper, ECOOP 2000 Workshop on Object-Oriented Architectural Evolution

#Abstract:
When looking at existing tools that provide support for architectural software
evolution, we can distinguish between support for run-time, pre-execution time and designtime
evolution; between support for unconstrained and constrained evolution; and between
proactive, reactive and retroactive support for evolution. Current tools that support
architectural evolution can only deal with a subset of the above issues. Moreover, they
typically address only some particular aspects of software evolution (e.g., impact analysis,
reverse engineering, etc ). We propose declarative meta programming as an expressive and
uniform medium for building tools that support architectural evolution. Amongst others, this
enables the integration and combination of such tools, and allows the construction of new
tools by sharing and reusing earlier codified knowledge.

#Keywords:


#Reference:
vub-prog-tr-00-14
"Codifying High-Level Software Abstractions as Virtual Classifications",
Kim Mens, Tom Mens
Position paper, ECOOP 2000 Workshop on Objects and Classification: a Natural Convergence

#Abstract:
Current-day software abstractions (architectures, coding conventions, design patterns,
interaction protocols) are often not explicitly linked to the code. This lack of traceability
causes problems like architectural drift and software erosion. In order to alleviate these
problems, we propose to use virtual classiffications to codify high-level software abstrac-
tions as logic predicates over the implementation. Besides being explicitly linked to the
code, these classiffications have the additional advantage that they allow us to declare
software abstractions in an expressive, concise, readable and intentional way.

#Keywords:


#Reference:
vub-prog-tr-00-15
"Multiple Cross-Cutting Architectural Views",
Kim Mens
Position paper, Second Workshop on Multi-Dimensional Separation of Concerns in Software Engineering (co-located with ICSE 2000), 2000

#Abstract:
With this position paper we want to make a case for the relevance of the ideas of multi-dimensional separation of concerns at the architectural level. Traditional approaches towards software architecture seem to take for granted that a software system exhibits a single software architecture, of which the elements map more or less directly to design or implementation-level components. We claim that multiple, potentially overlapping, cross-cutting architectural views can provide a much better insight in the overall structure, organization and functionality of a software system than one single architecture which is often strongly biased to the implementation structure of the system.

#Keywords:

#Reference:
vub-prog-tr-00-16.pdf
"On the use of Knowledge Representation Techniques for Modeling Software Architectures"
Kim Mens, Michel Wermelinger
Position paper, submitted to the 4th International Software Architecture Workshop (ISAW-4), 4 and 5 june 2000, Limerick, Ireland, in conjunction with ICSE 2000

#Abstract:
We take the position that it could prove worth to reconcile ideas of the knowledge representation and software architecture research communities. Many existing knowledge representation techniques and formalisms seem to exhibit a lot of potential for representing different aspects of software architectures. To illustrate our case, we show how the theory of conceptual graphs could be a useful candidate to describe software architectures, to model architectural styles and patterns, and to serve as a formal foundation for compliance checking of architectures to architectural styles, as well as for checking conformance of the implementation of a software system to its architecture.

#Keywords:

#EndABSTRACTS OF DISSERTATIONS 2000
-------------------------------

#Reference:
vub-prog-phd-00-01
"Multi-Paradigm Design"
James O. Coplien
PhD dissertation, Programming Technology Lab, May 2000

#Abstract:
This thesis examines the broad question of software design. It attempts to do
so from first principles of abstraction, both in the tradition of software and
the classical models of abstraction behind it, as well as from the perspective
of more powerful abstraction models emerging from contemporary category theory
The thesis builds on the broadly acclaimed importance of software design in
reducing software cost, reducing time to market, and in the intentionality that
makes systems easier to understand and more likely to meet their needs than
poorly designed systems with obscure structures.  The approach achieves these
goals through the following approaches:  formalizing the concept of paradigm
in a domain analysis basis;  using meta-design to select paradigms suitable to
the problem domain; dealing explicitly with dependencies between domains;
dealing with the problem of "negative variability" when commonalities fail
to hold under exceptional design conditions; and generalizing to the semantics
of many design patterns, placing them in the context of a commonality analysis
framework.

#Keywords:
commonality analysis, negative variability, design patterns,
generic programming, overloading, solution domain, application domain,
C++


#Reference:
vub-prog-lic-00-01
"A Reflective Forward-Chained Inference Engine to Reason About Object-Oriented Systems"
Sofie Goderis
Dissertation, Programming Technology Lab, June 2000

#Abstract:
Recently, a lot of research concerning co-evolution has been done. Co-evolution is a brand new
approach that tries to find a solution for the problem of the missing link between the design
and the implementation of object-oriented software systems. To date this has been done by
using a rule-based backward chained reasoning mechanism as a declarative meta layer on top
of the implementation of an object-oriented system. However, one of the major drawbacks of
this approach is the fact that a goal should be clearly specified. Such a (specification of the)
goal is very often not available.
In this dissertation we will show that in some specific cases a rule-based backward chained
reasoning mechanism is not sufficient. Therefore, as an alternative mechanism we suggest a
rule-based forward chained reasoning mechanism to implement the declarative meta layer, in
order to handle these specific cases. We will validate this thesis by means of some experiments
done with a forward chained prototype we built. The prototype is based on the expert
system tool KAN and implemented in Squeak. The conducted experiments confirm our
thesis. Especially in cases where no specific goal can be specified and in cases where the
reasoning state has to be preserved, our alternative approach proved to be preferable.

#Keywords:


#Reference:
vub-prog-phd-00-02.pdf
"Automating Architectural Conformance Checking by means of Logic Meta Programming"
Kim Mens
PhD dissertation, Programming Technology Lab, October 2000

#Abstract:
In this dissertation, we propose an expressive architectural language in
which to describe software architectures and their mapping to some software implementation. The language supports the declaration of multiple architectures, called architectural views, on the same software system. Each such views focuses on a different aspect of the structure of that system. In addition to this architectural language, we propose an algorithm which reasons about the descriptions in the architectural language to automatically check conformance of the implementation of some software system to its architectural views. The approach we adopt is a logic meta-programming approach. I.e., we express both the architectural language and the conformance checking algorithm in a logic programming language which is used as a meta-programming language to reason about implementation artifacts in some (object-oriented) base language.

#Keywords:
Conformance checking, software architecture, logic programming, logic meta programming

#End