Tom Mens obtained the degrees of Licentiate in Mathematics in 1992, Advanced Master in Computer Science in 1993 and PhD in Science in 1999 at the Vrije Universiteit Brussel, Belgium. He was a teaching and research assistant at the Vrije Universiteit Brussel for six years, and a postdoctoral fellow of the Fund for Scientific Research - Flanders (FWO) for three years. In October 2003 he became a lecturer at the Université de Mons, where he founded and directs a research lab on software engineering. Since November 2008 he is full professor. His main research interest lies in the underlying foundations of, and tool support for, evolving software. He published numerous peer-reviewed articles on this research topic in international journals and conferences. He has been co-organiser, program committee member and reviewer of international symposia and workshops on model-driven software engineering and software evolution. He is involved in several interuniversity research projects and networks, and is founder and chair of the ERCIM Working Group on Software Evolution.
Abstract: Software has become omnipresent and vital in our information-based society, so all software producers should assume responsibility for its reliability. While "reliable" originally assumed implementations that were effective and mainly error-free, additional issues like adaptability and maintainability have gained equal importance recently. For example, the 2004 ACM/IEEE Software Engineering Curriculum Guidelines list software evolution as one of ten key areas of software engineering education.
Mens and Demeyer, both international authorities in the field of software evolution, together with the invited contributors, focus on novel trends in software evolution research and its relations with other emerging disciplines such as model-driven software engineering, service-oriented software development, and aspect-oriented software development. They do not restrict themselves to the evolution of source code but also address the evolution of other, equally important software artifacts such as databases and database schemata, design models, software architectures, and process management. The contributing authors provide broad overviews of related work, and they also contribute to a comprehensive glossary, a list of acronyms, and a list of books, journals, websites, standards and conferences that together represent the communityâs body of knowledge.
Combining all these features, this book is the indispensable source for researchers and professionals looking for an introduction and comprehensive overview of the state of the art. In addition, it is an ideal basis for an advanced course on software evolution.
Abstract: This article proposes a case study to evaluate the suitability of graph transformation tools for program refactoring. In order to qualify for this purpose, a graph transformation system must be able to (i) import a graph-based representation of models of Java programs , (ii) allow these models to be transformed interactively with well-known program refactorings, and (iii) export the resulting models in the same graph-based format used as input. The case study aims to enable comparison of various features of graph transformation tools, such as their expressiveness and their ability to interact with the user. The model of Java programs is presented and some examples for translating Java source code into the model are provided. The refactorings selected for the case study are speciï¬ed in detail.
Abstract: After more than a decade of research in Model-Driven Engineering (MDE), the state-of-the-art and the state-of-the-practice in MDE has significantly progressed. Therefore, during this workshop we raised the question of how to proceed next, and we identified a number of future challenges in the field of MDE. The objective of the workshop was to provide a forum for discussing the future of MDE research and practice. Seven presenters shared their vision on the future challenges in the field of MDE. Four breakout groups discussed scalability, consistency and co-evolution, formal foundations, and industrial adoption, respectively. These themes were identified as major categories of challenges by the participants. This report summarises the different presentations, the MDE challenges identified by the workshop participants, and the discussions of the breakout groups.
Abstract: Applying refactoring in a model-driven software engineering context raises many new challenges that need to be addressed. In
this paper, we consider model-driven software development based on the
code generation framework AndroMDA. Considering the UML profile for
AndroMDA, we come up with a number of domain-specific model refactorings. In its most recent version, the AndroMDA code generation can
be based on the Eclipse Modeling Framework (EMF) which has evolved
towards the de facto standard technology to specify UML models. We
show how domain-specific refactorings can be specified by EMF transformation incorporating graph transformation concepts. This opens up
the possibility to reason about domain-specific refactorings in a formal way.
Abstract: In this paper, we consider a large variety of solutions for the
generation of Sierpinski triangles, one of the case studies for the AGTIVE
graph transformation tool contest [15]. A Sierpinski triangle shows a
well-known fractal structure. This case study is mostly a performance
benchmark, involving the construction of all triangles up to a certain
number of iterations. Both time and space performance are involved.
The transformation rules themselves are quite simple.
Abstract: In collaborative ontology engineering, contexts are key to
manage the complexity of different dependency types between ontological artefacts. Instead of being frustrated by out-of-control evolution pro-
cesses, proper context dependency management will allow human experts
to focus on the meaning interpretation and negotiation processes. This
requires support for the detection and resolution of meaning ambiguities
and conflicts. In this article, we explore to which extent the theory of
graph transformation can be used to support this activity. More specifically, we propose the use of critical pair analysis as a formal means
to analyse conflicts between ontologies that are evolving in parallel. We
illustrate this with an example from a realistic case study.
Abstract: Model-driven engineering is an emerging software engineering approach that relies on model transformation. Typical kinds of model transformations are model refinement and model refactoring. Whenever such a transformation is applied to a consistent model, we would like to know whether the consistency is preserved by the transformation. Therefore, in this article, we formally define and explore the relation between behaviour inheritance consistency of a refined model with respect to the original model, and behaviour preservation of a refactored model with respect to the original model. As it turns out, there is a strong similarity between these notions of behaviour consistency and behaviour preservation. To illustrate this claim, we formalised the behaviour specified by UML 2.0 sequence and protocol state machine diagrams. We show how the reasoning capabilities of description logics, a decidable fragment of first-order logic, can be used in a natural way to detect behaviour inconsistencies. These reasoning capabilities can be used in exactly the same way to detect behaviour preservation violations during model refactoring. A prototype plug-in in a UML CASE tool has been developed to validate our claims.
Abstract: Transformation-based techniques such as refactoring, model transformation and model-driven development, architectural reconfiguration, etc. are at the heart of many software engineering activities, making it possible to cope with an
ever changing environment. This workshop, held as satellite event of the 3rd International Conference on Graph
Transformation (ICGT 2006) in Natal, Rio Grande do Norte, Brazil on 22nd September 2006, provided a forum for discussing these techniques, their formal foundations
and applications.
Abstract: A taxonomy of model transformations was introduced in [T. Mens, P.V. Gorp, A taxonomy of model transformation, in: Proc. Int'l Workshop on Graph and Model Transformation (GraMoT 2005), Electronic Notes in Theoretical Computer Science 152]. Among others, such a taxonomy can help developers in deciding which language, formalism, tool or mechanism is best suited to carry out a particular model transformation activity. In this paper we apply the taxonomy to the technique of graph transformation, and we exemplify it by referring to four representative graph transformation tools. As a byproduct of our analysis, we discuss how well each of the considered tools carry out the activity of model transformation.
Abstract: Flexibility has been recognised as a desirable quality of software since the earliest days of software engineering. Classic and contemporary software design literature suggests that particular implementations are more flexible than others, but stops short of suggesting objective criteria for quantifying such claims. To measure software flexibility in precise terms, we introduce the notion of evolution complexity and demonstrate how it can be used to measure and compare the flexibility of (1) programming paradigms (Object-Oriented against Procedural programs), (2) architectural styles (Shared Data, Pipes and Filters, and Abstract Data Type) and (3) design patterns (Visitor and the Abstract Factory). We also demonstrate how evolution complexity can be used to choose the most flexible design policy. We conclude with experimental results corroborating our claims.
Abstract: This article proposes a taxonomy of model transformation, based on the discussions of a working group on model transformation of the Dagstuhl seminar on Language Engineering for Model-Driven Software Development. This taxonomy can be used, among others, to help developers in deciding which model transformation language or tool is best suited to carry out a particular model transformation activity.
Abstract: Refactorings are program transformations that improve the software structure while preserving the external behaviour. In spite of this very useful property, refactorings can still give rise to structural conflicts when parallel evolutions to the same software are made by different developers. This paper explores this problem of structural evolution conflicts in a formal way by using graph transformation and critical pair analysis. Based on experiments carried out in the graph transformation tool AGG, we show how this formalism can be exploited to detect and resolve refactoring conflicts.
Notes: A more recent paper on this topic has been published in Elsevier's SOSYM journal in 2007.
Abstract: In this paper we provide an detailed overview of existing research in the field of software restructuring and refactoring, from a formal as well as a practical point of view. Next, we propose an extensive list of open questions that indicate future research directions, and we provide some partial answers to these questions.
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 high-level 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.
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, five have been selected for revision and inclusion in this special issue of the Journal of Software Maintenance and Evolution.
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.
Abstract: In class-based multiple inheritance systems, interpretations as different as duplication, sharing and specialization 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. Orthogonalizing these two concepts
in a mixin-based framework permits appropriate solutions of all the problems listed above. To this extent a formal
model is proposed together with its denotational semantics. This minimal multiple inheritance model establishes a
valuable basis for OO languages and software engineering systems.
Abstract: In this chapter, we explore the emerging research domain of model-driven
software refactoring. Program refactoring is a proven technique
that aims at improving the quality of source code. Applying refactoring
in a model-driven software engineering context raises many new
challenges such as how to define, detect and improve model quality, how
to preserve model behavior, and so on. Based on a concrete case study
with a state-of-the-art model-driven software development tool,
AndroMDA, we will explore some of these challenges in more detail.
We propose to resolve some of the encountered problems by relying on
well-understood techniques of meta-modeling, model transformation and
graph transformation.
Abstract: This article presents a preliminary and exploratory study of the relationship between size, on the one hand, and effort, duration and team size, on the other, for 11 Free/Libre/Open Source Software (FLOSS) projects with current size ranging between between 0.6 and 5.3 million lines of code (MLOC). Effort was operationalised based on the number of active committers per month. The extracted data did not ï¬t well an early version of the closed-source cost estimation model COCOMO for proprietary software, overall suggesting that, at least to some extent, FLOSS communities are more productive than closed-
source teams. This also motivated the need for FLOSS-speciï¬c effort models. As a ï¬rst approximation, we evaluated 16 linear regression models involving different pairs of attributes. One of our experiments was to calculate the net size, that is, to remove any suspiciously large outliers or jumps in the growth trends. The best model we found involved effort against net size, accounting for 79 percent of the variance. This model was based on data excluding a possible outlier (Eclipse), the largest project in our sample. This suggests that different effort models may be needed for certain categories of FLOSS projects. Of the 11 projects, 3 have grown superlinearly, 5 linearly and 3 sublinearly, suggesting that in the most of the cases accumulated complexity is either well controlled
or do not constitute a growth constraining factor.
Notes: Read also: The Evolution of Eclipse, published in ICSM 2008.
Abstract: We present Maispion , a tool for analysing software developer communities. The tool, developed in Smalltalk, mines mailing list and version repositories, and provides visualisations to provide insights into the ecosystem of open source software (OSS) development. We show how Maispion can analyze the history of medium to large OSS communities, by applying our tool to three well-known open source projects: Moose, Drupal and Python.
Abstract: Due to the increasing use of models, and the inevitable model inconsistencies that arise during model-based software development and evolution, model inconsistency detection is gaining more and more attention. Inconsistency checkers typically analyse entire models to detect undesired structures as deï¬ned by inconsistency rules. The larger the models become, the more time the inconsistency detection process takes. Taking into account model evolution, one can signiï¬cantly reduce this time by providing an incremental checker. In this article we propose an incremental inconsistency checker based on the idea of representing models as sequences of primitive construction operations. The impact of these operations on the inconsistency rules can be computed to analyse and reduce the number of rules that need to be re-checked during a model increment.
Abstract: We present a metrics-based study of the evolution of Eclipse, an open source integrated development environment, based on data from seven major releases, from releases 1.0 to 3.3. We investigated whether three of the laws of software evolution were supported by the data. We found
that Eclipse displayed continual change and growth, hence supporting laws 1 and 6. Six size indicators, out of eight, closely followed trend models. Four were linear and two superlinear. We found evidence of increasing complexity (law 2) in only two indicators, out of ï¬ve. At subproject
level, size and complexity are not distributed uniformly, and subproject size can be modelled as a negative exponential function of the rank position. We encountered a range of different size and complexity trends across subprojects. Our approach and results can help in evaluating the future evolution of Eclipse, the evolution of other systems and in performing comparisons.
Abstract: Nowadays, large-scale industrial software systems may involve
hundreds of developers working on hundreds of different but
related models representing parts of the same system
specification. Detecting and resolving structural inconsistencies
between these models is then critical. In this article we propose to
represent models by sequences of elementary construction
operations, rather than by the set of model elements they contain.
Structural and methodological consistency rules can then be
expressed uniformly as logical constraints on such sequences. Our
approach is meta-model independent, allowing us to deal with
consistency between different models whatever their kind. We
have validated our approach by building a Prolog engine that
detects violations of structural and methodological constraints
specified on UML 2.1 models and requirement models. This
engine has been integrated into two contemporary UML-based
modelling environments, Eclipse EMF and Rational Software
Architect (RSA).
Abstract: Continuous alterations and extensions of a software system introduce so called god classes, accumulating ever more responsibilities. As god classes make essential steps in program comprehension harder, it is expected that effective and efficient techniques to resolve them will facilitate future maintenance tasks. This work reports on a laboratory experiment with 63 computer science students, in which we verified whether the decomposition of a god class using well-known refactorings can affect comprehensibility of the relevant code part. Five alternative god class decompositions were derived through application of refactorings, by which the responsibilities of a natural god class were increasingly split into a number of collaborating classes. Our results indicate that the derived class decompositions differed significantly with regard to the ability of students to map attributes in the class hierarchy to descriptions of the problem domain. Moreover, this effect has been found to interact with the institution in which the participants were enrolled, confirming that comprehensibility is a subjective notion for which we have to take into account peopleâs skills and expectations. This work indicates that improving comprehensibility is within the grasp of a single maintainer preparing for future change requests by redistributing the responsibilities of a god class using well-known refactorings.
Abstract: With the increased interest in refactoring, UML tool vendors seek ways to support software developers in applying a (sequence of) refactoring(s). The problem with such tools is that the UML metamodel â on which their repository is based â is inadequate to maintain the consistency between the model and the code while one of them gets refactored. Therefore, we propose a set of minimal extensions to the UML metamodel, which is sufficient to reason about refactoring for all common OO languages. For instance, by specifying pre- and postconditions in OCL, we are able to compose primitive refactorings, verify preservation of program behavior, and trigger refactorings based on code smells. This way, we provide future MDA tools with the ability to improve existing UML designs, yet keeping them in synch with the underlying code base.
Abstract: In this paper, we show how elaborate support for framework-based software evolution can be provided based on explicit documentation of the hot spots of object-oriented application frameworks. Such support includes high-level transformations that guide a developer when instantiating applications from a framework by propagating the necessary changes, as well as application upgrading facilities based on these transformations. The approach relies on active declarative documentation of the design and evolution of the frameworkâs hot spots, by means of metapatterns and their associated transformations.
Abstract: A software design is often modelled as a collection of UML diagrams. There is an inherent need to preserve consistency between these diagrams. Moreover, through evolution those diagrams get modified leading to possible inconsistency between different versions of the diagrams. State-of-the-art UML CASE tools provide poor support for consistency maintenance. To solve this problem, an extension of the UML metamodel enabling support for consistency maintenance and a classification of inconsistency problems is proposed. To achieve the detection and resolution of consistency conflicts, the use of description logic (DL) is presented. DL has the important property of being a decidable fragment of first-order predicate logic. By means of a number of concrete experiments in Loom, we show the feasibility of using this formalism for the purpose of maintaining consistency between (evolving) UML models.
Abstract: In this paper, we show how automated support can be provided for identifying refactoring opportunities, e.g., when an applicationâs design should be refactored and which refactoring(s) in particular should be applied. Such support is achieved by using the technique of logic meta programming to detect so-called bad smells and by defining a framework that uses this information to propose adequate refactorings. We report on some initial but promising experiments that were applied using the proposed techniques.
Abstract: OPUS is an elementary calculus that models object-orientation. It expresses in a direct way the crucial features of object-oriented
programming such as objects, encapsulation, message passing and incremental modification. This is illustrated by numerous examples. Thanks to the way objects are constructed in this calculus, we can deal with self-reference, recursion and even mutual recursion in a straightforward way. We also illustrate that it is relatively easy to model different kinds of inheritance mechanisms. Finally, we argue to which extent our calculus can be used for modeling and investigating object-oriented concepts.
Notes: See also our related OOIS 1994 conference article.
