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: As chair and member of the ERCIM Working Group on Software Evolution, we are honoured to act as guest editors for this issue of ERCIM News with the special theme of Evolving Software. The importance of software in our information society cannot be underestimated: just imagine what would happen if all software systems around us failed. There would be no television, no radio, no Internet, no financial transactions and e-commerce, no energy production, huge problems in public transport, and the list goes on.
Abstract: With the emergence of multicore and manycore processors, engineers must design and develop software in drastically new ways to benefit from the computational power of all cores. However, developing parallel software is much harder than sequential software because parallelism can't be abstracted away easily. Authors Hans Vandierendonck and Tom Mens provide an overview of technologies and tools to support developers in this complex and error-prone task.
Abstract: Context-aware computing is a paradigm for governing the numerous mobile devices surrounding us. In this computing paradigm, software applications continuously and dynamically adapt to different âcontextsâ implying different software configurations of such devices. Unfortunately, modelling a context-aware application (CAA) for all possible contexts is only feasible in the simplest of cases. Hence, tool support verifying certain properties is required. In this article, we introduce the CAA model, in which context adaptations are specified explicitly as model transformations. By mapping this model to graphs and graph transformations, we can exploit graph transformation techniques such as critical pair analysis to find contexts for which the resulting application model is ambiguous. We validate our approach by means of an example of a mobile city guide, demonstrating that we can identify subtle context interactions that might go unnoticed otherwise.
Abstract: Software repository mining research extracts and analyses data originating from multiple software repositories to understand the historical development of software systems, and to propose better ways to evolve such systems in the future. Of particular interest is the study of the activities and interactions between the persons involved in the software development process. The main challenge with such studies lies in the ability to determine the identities (e.g., logins or e-mail accounts) in software repositories that represent the same physical person. To achieve this, different identity merge algorithms have been proposed in the past. This article provides an objective comparison of identity merge algorithms, including some improvements over existing algorithms. The results are validated on a selection of large ongoing open source software projects.
Abstract: What happens if you combine the virtues of software engineering with database engineering? Developers managing the evolution of data-intensive software systems face numerous crucial challenges.
Abstract: To manage the complexity of developing, maintaining, and evolving a critical software-intensive system, its architecture description must be accurately and traceably linked to its implementation.
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: 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: 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: 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: 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: Model-driven engineering (MDE) is an approach to software development where the primary focus is on models, as opposed to source code. The use of models opens up new pos- sibilities for creating, analyzing, manipulating and formally reasoning about systems at a high level of abstraction. To reap all the benefits of MDE, it is essential to install a mechanism of model transformation, that enables a wide range of different automated activities such as trans- lation of models, generating code from models, model synthesis, model improvement, model verification and model simulation. To achieve this, languages, formalisms, techniques, pro- cesses, tools and standards that support model transformation are needed. This article surveys the state-of-the-art on model transformation, and discusses how it can be used to support some essential activities in MDE.
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: The ability to evolve software rapidly and reliably is a major challenge for soft- ware engineering. In this introductory chapter we start with a historic overview of the research domain of software evolution. Next, we briefly introduce the important research themes in software evolution, and identify research challenges for the years to come. Finally, we provide a roadmap of the topics treated in this book, and explain how the various chapters are related.
Abstract: One of the main challenges in model-driven software engineering is to deal with design model inconsistencies. Automated techniques to detect and resolve these inconsistencies are essential. We propose to use the artificial intelligence technique of automated planning for the purpose of resolving software model inconsistencies. We implemented a regression planner in Prolog and validated it on the resolution of different types of structural inconsistencies for generated models of varying sizes. We discuss the scalability results of the approach obtained through several stress-tests and discuss the limitations of our approach.
Abstract: Developing intuitive interactive applications that are easy to maintain by developers is quite challenging, due to the complexity and the many technical aspects involved in such applications. In this article, we tackle the problem in two complementary ways. First, we propose a gestural interface to improve the user experience when interacting with applications that require the manipulation of 3D graphical scenes. Second, we reduce the complexity of developing such appli- cations by modeling their executable behaviour using statecharts. We validate our approach by creating a modular and extensible Java framework for the development of interactive gesture-based applications. We developed a proof- of-concept application using this framework, that allows the user to construct and manipulate 3D scenes in OpenGL by using hand gestures only. These hand gestures are captured by the Kinect sensor, and translated into events and actions that are interpreted and executed by communicating state- charts that model the main behaviour of the interactive ap- plication.
Abstract: In model-driven software engineering (MDE), software is built through the incremental development, composition and transfor- mation of a variety of models. We are inevitably confronted with design models that contain a wide variety of inconsistencies. Interactive and automated support for detecting and resolving these inconsistencies is indispensable. We evaluate an approach to automate the generation of concrete models in which structural inconsistencies are resolved. We im- plemented this approach in the model finder Kodkod and assessed its suitability for model inconsistency resolution based on an objective set of criteria.
Abstract: Numerous empirical studies analyse evolving open source software (OSS) projects, and try to estimate the activity and effort in these projects. Most of these studies, however, only focus on a limited set of artefacts, being source code and defect data. In our research, we extend the analysis by also taking into account mailing list information. The main goal of this article is to find evidence for the Pareto principle in this context, by studying how the activity of developers and users involved in OSS projects is distributed: it appears that most of the activity is carried out by a small group of people. Following the GQM paradigm, we provide evidence for this principle. We selected a range of metrics used in economy to measure inequality in distribution of wealth, and adapted these metrics to assess how OSS project activity is distributed. Regardless of whether we analyse version repositories, bug trackers, or mailing lists, and for all three projects we studied, it turns out that the distribution of activity is highly imbalanced.
Abstract: Empirical software engineering is concerned with statistical studies that aim to understand and improve certain aspects of the soft- ware development process. Many of these focus on the evolution and maintenance of evolving software projects. They rely on repository mining techniques to extract relevant data from software repositories or other data sources frequently used by software developers. We enlarge these empirical studies by exploring social software engineering, study- ing the developer community, including the way developers work, cooperate, communicate and share information. The underlying hypothesis is that social aspects significantly influence the way in which the software project will evolve over time. We present some preliminary results of an empirical study we are carrying out on the different types of activities of the community involved in the GNOME open source ecosystem, and we discuss suggestions for future work.
Abstract: In this article we present an ongoing interuniversity research collaboration in the context of a large ERDF-funded research project aiming to enhance and support the quality of evolving software-intensive systems. The project focuses on two aspects in particular, namely the development of a quality metamodel for measuring and controlling the quality of software-related activities, and the instantiation of this framework to measure the quality of evolving libre software distributions from the point of view of different stakeholders.
Abstract: Nowadays, most empirical studies in open source software evolution are based on the analysis of program code alone. In order to get a better understanding of how software evolves over time, many more entities that are part of the software ecosystem need to be taken into account. We present a general framework to automate the analysis of the evolution of software ecosystems. The framework incorporates a database that stores all relevant information obtained thanks to several mining tools, and provides a unified data source to visualisation tools. One such visualisation tool is integrated in order to get a first quick overview of the evolution of different aspects of the software project under study. The framework is extensible in order to accommodate more and different types of input and output, depending on the needs of the user. We compare our framework against existing solutions, and show how we can use this framework for carrying out concrete ecosystem evolution experiments.
Abstract: Various approaches have been explored to detect and resolve software model inconsistencies in a generic and scalable way. In this position paper, we outline our research that aims to use the technique of automated planning for the purpose of resolving model inconsistencies. We discuss the scalability results of the approach obtained through several stress-tests and we propose several alternatives to the automated plan- ning approach.
Notes: LWI 2010: 3rd Workshop on Living with Inconsistencies in Software Development 2010,
co-located with Automated Software Engineering (ASE), Antwerp, Belgium, September 21st, 2010
Abstract: Software architectures constitute one of the main artefacts of software-intensive system development. They outline the essential components and interconnections of a software system at a high level of abstraction, ignoring unnecessary details. How to address the evolution of software architectures, however, is still an important topic of current research. In this article, we use UML 2 as architectural description language notation and formalise it with graph transformation, with a proof-of-concept implemented in the AGG tool. We use this formalisation to express and reason about architectural evolution patterns that introduce architectural styles.
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: 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: 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: 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: 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: 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: 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 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: 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: 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: 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: 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: 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.
