===============================
ABSTRACTS OF TECHREPORTS 2002
===============================

#Reference:
vub-prog-tr-02-01
"A Concept-Oriented Approach to Support Software Maintenance and Reuse Activities"
Dirk Deridder
Proceedings of the 5th Joint Conference on Knowledge-Based Software Engineering, Maribor, Slovenia, September 11-13, 2002

#Abstract:
A major activity in software development is to obtain knowledge and insights about the application domain. Even though this is supported by a wide range of tools and techniques, a lot of knowledge remains implicit in the resulting artefacts (e.g. class diagrams). Examples of such implicit knowledge are amongst others the links between the different artefacts, the knowledge that is lost as a result of iterative refinements, and the knowledge that is regarded common sense by the involved parties. Most of this knowledge resides in the heads of the stakeholder, the domain experts, and the developers. As it is likely that they can no longer remember it or that they are no longer available when software reuse and maintenance activities are initiated, this poses a problem. In this paper we present ongoing research in which we focus on our use of an ontology as a medium to tackle this problem. Making the different kinds of knowledge explicit will be accomplished by representing them as concepts in the ontology. Subsequently we will link these concepts to the artefacts created during analysis, design and implementation. This enables a bi-directional navigation between the concepts and the artefacts which consequently will serve as a vehicle to start reuse and maintenance activities.

#Keywords:


#Reference:
vub-prog-tr-02-02
"Maintaining Software through Intentional Source-Code Views"
Kim Mens, Tom Mens, Michel Wermelinger
Published in International Conference on Software Engineering and Knowledge Engineering

#Abstract:
Maintaining the source code of large software systems is hard. One underlying cause is that existing modularisation mechanisms are inadequate to handle crosscutting concerns. We propose intentional source-code views as an intuitive and lightweight means of modelling such concerns. They increase our ability to understand, modularise and browse the source code by grouping together source-code entities that address the same concern. They facilitate software development and evolution, because alternative descriptions of the same intentional view can be checked for consistency and relations among intentional views can be defined and verified. Finally, they enable us to specify knowledge developers have about source code that is not captured by traditional program documentation mechanisms. Our intentional view model is implemented in a logic metaprogramming language that can reason about and manipulate object-oriented source code directly. The proposed model has been validated on the evolution of a medium-sized object-oriented application in Smalltalk, and a prototype tool has been implemented.

#Keywords:
crosscutting concerns, modularisation, logic metaprogramming, software maintenance and evolution, validation and verification.


#Reference:
vub-prog-tr-02-03
"Formalising Behaviour Preserving Program Transformations"
Tom Mens, Serge Demeyer, Dirk Janssens
Published in International Conference on Graph Transformation

#Abstract:
The notion of refactoring -- transforming the source-code of an object-oriented program without changing its external behaviour-- has increased the need for a precise definition of refactorings and their properties. This paper introduces a graph representation of those aspects of the source code that should be preserved by a refactoring, and graph rewriting rules as a formal specification for the refactoring transformations themselves. To this aim, we use type graphs, forbidden subgraphs, embedding mechansims, negative application conditions and controlled graph rewriting. We show that it is feasible to reason about the effect of refactorings on object-oriented programs independently of the programming language being used. This is crucial for the next generation of refactoring tools.

#Keywords:
refactoring, graph transformation, graph rewriting, behaviour preservation


#Reference:
vub-prog-tr-02-04
"Towards Linguistic Symbiosis of an Object-Oriented and a Logic Programming Language"
Johan Brichau, Kris Gybels, Roel Wuyts
Publication information unknown

#Abstract:

#Keywords:


#Reference:
vub-prog-tr-02-05
"Towards a taxonomy of software evolution"
Tom Mens, Jim Buckley, Awais Rashid, Matthias Zenger
Submitted to Workshop on Unanticipated Software Evolution, Warshau, Poland, 2003

#Abstract:
Previous taxonomies of software evolution have focused on the purpose
of the change rather than the underlying mechanisms. The aim of
this paper is to propose a taxonomy of software evolution based on the
mechanisms of change and the factors that impact upon these mechanisms.
This categorization has the following dimensions: temporal facets,
facets of the change, system facets, change process, object of change and
drivers of change. The goal of this taxonomy is to position concrete tools,
formalisms and techniques within the domain of software evolution, so
that it becomes easier to compare and combine them, or to evaluate their
potential use for a particular change scenario.

#Keywords:
software evolution, taxonomy, comparison


#Reference:
vub-prog-tr-02-06
"High-Level Transformations to Support Framework-Based Software Development"
Tom Tourwe, Tom Mens
Published in Electronic Notes in Theoretical Computer Science 74(4), 2002

#Abstract:
In this paper, we show how elaborate support for framework-based software development
can be provided based on explicit documentation of the hot spots of
object-oriented application frameworks. This support ranges from automatically
verifying whether appropriate design constraints are preserved, over providing highlevel
transformations that guide a developer when instantiating applications from a
framework, to supporting software upgrades based on these transformations. The
hot spots are documented by means of design patterns, and we use metapatterns
as an abstraction to define the associated design constraints and high-level transformations.

#Keywords:
object-oriented software, transformations, design pattern, metapattern, application framework


#Reference:
vub-prog-tr-02-07
"A Graph-Based Metamodel for Object-Oriented Software Metrics"
Tom Mens, Michele Lanza
Published in Electronic Notes in Theoretical Computer Science 72(2), 2002

#Abstract:
Metrics are essential in object-oriented software engineering for
several reasons, among which quality assessment and improvement of
development team productivity. While the mathematical nature of
metrics calls for clear definitions, frequently there exist many
contradicting definitions of the same metric depending on the
implementation language. We suggest to express and define metrics
using a language-independent metamodel based on graphs. This
graph-based approach allows for an unambiguous definition of
generic object-oriented metrics and higher-order metrics. We also
report on some prototype tools that implement these ideas.

#Keywords:
software metrics, object-oriented software, graphs, metamodel


#Reference:
vub-prog-tr-02-08
"Analysing Object-Oriented Application Frameworks Using Concept Analysis"
Gabriela Arevalo, Tom Mens
MASPEGHI Workshop, Lecture Notes in Computer Science, 2002

#Abstract:
This paper proposes to use the formal technique of Concept Analysis
to analyse how methods and classes in an object-oriented inheritance hierarchy
are coupled by means of the inheritance and interfaces relationships. Especially
for large and complex inheritance hierarchies, we believe that a formal analysis of
how behaviour is reused can provide insight in how the hierarchy was built and
the different relationships among the classes. To perform this analysis, we use
behavioural information provided by the self sends and super sends made in each
class of the hierarchy. The proposed technique allows us to identify weak spots
in the inheritance hierarchy that may be improved, and to serve as guidelines
for extending or customising an object-oriented application framework. As a first
step, this paper reports on an initial experiment with the Magnitude hierarchy in
the Smalltalk programming language.

#Keywords:
concept analysis, object-oriented software, inheritance hierarchy, application framework, Smalltalk


#Reference:
vub-prog-tr-02-09
"Fine-Grained Interlaced Code Loading for Mobile Systems"
Luk Stoops, Tom Mens, Theo D'Hondt
Published in Int. Conf. Mobile Agents 2002

#Abstract:
In the advent of ubiquitous mobile systems in general and mobile agents in particular, network latency becomes a critical factor. This paper investigates interlaced code loading, a promising technique that permutes the application code at method level and exploits parallelism between loading and execution of code to reduce network latency. It allows many applications to start execution earlier, especially programs with a predictable startup phase (such as building a GUI). The feasibility of the technique has been validated by implementing a prototype tool in Smalltalk, and applying it to three applications and a wide range of different bandwidths. We show how existing applications can be adapted to maximally benefit from the technique and provide design guidelines for new applications. For applications that rely on a GUI, the time required to build the GUI can be reduced to 21 % on the average.

#Keywords:
network latency, mobile systems, code loading, GUI 


#Reference:
vub-prog-tr-02-10
"Supporting Software Evolution with Intentional Software Views"
Kim Mens, Tom Mens, Michel Wermelinger
Proc. Int. Workshop Principles of Software Evolution, 2002

#Abstract:
Maintaining and evolving large software systems is hard. One underlying
cause is that existing modularisation mechanisms are inadequate
to handle crosscutting concerns. We propose intentional
software views as an intuitive and lightweight means of modelling
such concerns. They increase our ability to understand, modularise
and browse the implementation by grouping together source-code
entities that address a same concern. Alternative descriptions of
the same intentional view can be provided and checked for consistency.
In addition, the model supports the declaration, verification
and enforcement of relations among intentional views. This facilitates
software evolution by providing the ability to detect invalidation
of important intentional relationships among concerns when
the software is modified.

#Keywords:
intentional software views, crosscutting concerns, modularisation, evolution conflict detection


#Reference:
vub-prog-tr-02-11
"Supporting Development of Enterprise JavaBeans Through Declarative Meta Programming"
Johan Fabry
Proc. Object-Oriented Information Systems (OOIS 2002), LNCS 2425, pp. 280-285, Springer-Verlag, 2002

#Abstract:
Enterprise JavaBeans is a successful component model for the
development of distributed business applications. Enterprise JavaBeans
have to adhere to a set of rules and guidelines which, amongst others,
require that a significant amount of glue code between the components
is written. By using Declarative Meta Programming (DMP) we can codify
these rules and guidelines as a logic program which operates on the
Java code. Our DMP development tool can not only generate Java code,
but can also verify compliance of developer code.

#Keywords:
declarative meta programming, Enterprise JavaBeans


#Reference:
vub-prog-tr-02-12
"Generating User Interfaces by means of Declarative Meta Programming"
Sofie Goderis, Wolfgang De Meuter
Workshop on Generative Programming, Ecoop 2002, Malaga, Spain

#Abstract:

#Keywords:
dmp, ui generation


#Reference:
vub-prog-tr-02-13
"A case in Multiparadigm Programming : User Interfaces by means of Declarative Meta Programming"
Sofie Goderis, Wolfgang De Meuter, Johan Brichau
Workshop on Multiparadigm programming with Object-Oriented Languages, Ecoop 2002, Malaga, Spain

#Abstract:

#Keywords:
generative programming, dmp, ui generation


#Reference:
vub-prog-tr-02-14
"Workshop Proceedings - Declarative Meta Programming to Support Software Development"
Tom Mens, Roel Wuyts, Kris De Volder, Kim Mens
Technical Report

#Abstract:

#Keywords:
declarative meta programming


#Reference:
vub-prog-tr-02-15
"A Comparison of Software Refactoring Tools"
Jocelyn Simmonds and Tom Mens
Technical Report

#Abstract:
The principal aim of this paper is to apply the Taxonomy of
Software Evolution, developed by Mens et. al,
to position various software tools that support the activity of
software refactoring as part of the evolutionary process. This
taxonomy is based on the mechanisms of change and the factors that
impact upon these mechanisms. The goal of this taxonomy is to
position concrete tools and techniques within the domain of
software evolution, so that it becomes easier to compare and
combine them. In this paper, we apply the taxonomy to four tools
that provide explicit support for refactoring. The tools that were
considered for this detailed study are the following: Smalltalk
VisualWorks v7, Eclipse v2, Guru (for SELF v4) and Together
ControlCenter v6. After a detailed
discussion and comparison of these tools, we analyse the
strengths, weaknesses and limitations of the evolution taxonomy
that was used.


#Keywords:
refactoring, tool support, taxonomy



#Reference:
vub-prog-tr-02-16
"Separation of Concerns for Software Evolution"
Tom Mens, Michel Wermelinger
Published in JOURNAL OF SOFTWARE MAINTENANCE AND EVOLUTION: RESEARCH AND PRACTICE 2002, Vol.14, pp. 311-315, http://www.interscience.wiley.com/

#Abstract:
This special issue reports on approaches that apply the idea of
separation of concerns to software evolution. In this context,
separation of concerns allows us to separate parts of the software
that exhibit different rates of change or different types of
change. This makes it possible to provide better evolution support
for those parts that have a higher change rate, or to provide
different evolution techniques for different views on the
software. Another common way to achieve separation of concerns is
by raising the level of abstraction to the level of software
architectures, business rules and metamodels. This makes software
evolution more manageable. The above ideas emerged as important
conclusions of the workshop on Formal Foundations of
Software Evolution, which was co-located with the Conference on
Software Maintenance and Re-engineering in Lisbon in March 2001.
Of the 12 original position papers, 5 have been selected for
revision and inclusion in this special issue of the Journal
of Software Maintenance and Evolution.

#Keywords:
software engineering, formal foundations, abstraction, rates of change


#EndABSTRACTS OF DISSERTATIONS 2002
-------------------------------

#Reference:
vub-prog-phd-02-01
"Automated Support for Framework-Based Software Evolution"
Tom Tourwe
PhD dissertation, Programming Technology Lab, September 2002

#Abstract:
Despite its popularity and its many software engineering advantages, framework-based software development suffers from a number of important problems. More specifically, instantiation and evolution of a framework present developers with various difficulties, since they should make sure the framework and its corresponding applications adhere to the intended design, in order to ensure correct behaviour. In this dissertation, we show how explicitly documenting a framework's design enables us to provide elaborate automated tool support for its instantiation and evolution.

#Keywords:
object-oriented application framework, framework-based software development, software evolution, framework instantiation


#End