Research
This page gives a high-level overview of my research. For more detailed information, please consult my publications or contact me.
Intensional Views and Constraints (top)
One of the techniques developers use to deal with the inherent complexity of software systems is to systematically introduce regularities in the source code of a system. These regularities express different conventions, idioms and patterns that are used to communicate the developers’ design intent or to regulate the implementation of a particular concern by relying on a proven solution. However, since these regularities are neither explicitly documented in the source code nor are they first-class entities of the development process, the causal connection between the regularities and the implementation can be severed during development. Consequently, changes to either the regularities or the source code can result in mismatches which might lead to an inconsistent or incorrect implementation.
In my PhD dissertation I propose an approach that emphasises this causality between regularities and source code by turning regularities into an integral and explicit part of the development process. This integration is attained by offering a formalism (namely intensional views and constraints) and a lightweight methodology which enables the co-design and co-evolution of regularities and the source code by making the regularities and the causal connection with the implementation explicit and verifiable.
Using our approach, the source-code entities implementing a concept which a regularity is applicable are documented by intensional views. Such an intensional view offers a classification mechanism that groups the source-code entities that belong to the implementation of that concept. An intensional view can consist of a set of classes, methods, variables, packages, and so on. A key characteristic of intensional views is that the set of source-code entities belonging to the view is not specified by manually enumerating these entities. Instead, an intensional view is defined by means of an executable description which, upon execution, yields the set of source-code entities that belong to the intensional view.
While an intensional view creates explicit documentation for the concept which a regularity is applicable to, this actual regularity is captured by means of intensional constraints. Such intensional constraints can be imposed on one or more intensional views and implement a verifiable condition that is applicable to the entities belonging to an intensional view.
By proposing a scheme in which these intensional views and constraints are designed in unison with the source code, and in which the validity of this documentation is frequently verified with respect to the implementation, our approach aims at maintaining the causality between the documented regularities and the source code of a system.
- Currently working on this topic together with Kim Mens and Johan Brichau.
- Our implementation of the model of intensional views and constraints, namely the IntensiVE tool suite, has a dedicated web page.
- This work fits in the larger context of declarative meta programming, one of the major research themes at the Programming Technology Lab.
- Find out more:
Co-evolving code and design using Intensional Views - A Case Study
Kim Mens, Andy Kellens, Frederic Pluquet, Roel Wuyts
Computer Languages, Systems & Structures, Volume 32, Issues 2-3, July-October 2006, p. 140-156, 2006- IntensiVE, a toolsuite for documenting and testing structural source-code regularities
Kim Mens, Andy Kellens
10th Conference on Software Maintenance and Re-engineering (CSMR), p. 239-248, 2006 - Maintaining causality between design regularities and source code
Andy Kellens
PhD thesis
Model-based pointcuts (top)
The fragile pointcut problem, one of the open evolution problems within the field of aspect-oriented programming, presents a particular instantiation of the problem of maintaining causality between design regularities and source code (see the section about intensional views and constraints above). The quantification mechanism employed by aspect-oriented pointcut languages introduces a tight coupling between pointcut expressions and how the source code of a base program is structured. Consequently, seemingly safe modifications to the base program can result in erratic behaviour of the aspects imposed on this program.
We propose to alleviate this fragile pointcut problem by means of model-based pointcuts. This model-based pointcut mechanism strives to decouple the actual pointcut definition from the implementation structure of the concepts in the source code which the pointcut relies on as well as to render the causal link between these concepts and the implementation structure explicit and verifiable. Using our approach, pointcuts are expressed in terms of a conceptual model: a first-class reification of the different concepts in the source code which a pointcut relies on. In order to aid in keeping this conceptual model synchronised with the source code, we propose to impose constraints on this conceptual model.
As a particular instantiation of model-based pointcuts, we provide an extension of the CARMA logic pointcut language such that pointcuts can be expressed in terms of intensional views representing different concepts in the implementation of the base program. By imposing intensional constraints over these views, this instantiation of model-based pointcuts renders the causal link between the source code and the concepts explicit and verifiable and aids in maintain causality upon evolution of the source code.
- Currently working on this topic together with Johan Brichau, Kim Mens and Kris Gybels.
- For more information about the CARMA logic pointcut language, see this page.
- Find out more:
- Application-specific Models and Pointcuts using a Logic Meta Language
Johan Brichau, Andy Kellens, Kris Gybels, Kim Mens, Robert Hirschfeld, Theo D’Hondt
Computer Languages, Systems & Structures, 2007 (to appear) - Managing the Evolution of Aspect-Oriented Software with Model-based Pointcuts
Andy Kellens, Kim Mens, Johan Brichau, Kris Gybels
20th European Conference on Object-Oriented Programming (ECOOP), LNCS 4067, p.501-525, 2006
Aspect mining and refactoring (top)
The advantages claimed to be offered by aspect-oriented programming can not only be applied to the development of new software systems, but can also be used to improve the modularity of already existing systems. Aspect mining and refactoring are two research domains within aspect-orientation that focus on respectively identifying crosscutting concerns in legacy code and transforming these crosscutting concerns into aspects.
Within aspect mining, we have proposed the technique of unique methods as a simple, heuristic-based approach for identifying crosscutting concerns. This technique is based on the assumption that the implementation of certain crosscutting concerns in legacy applications is characterised by multiple invocations to one particular entity in the system. For example, the prototypical logging concern is often implemented by scattered calls to a single Logging entity.
Our activities within aspect refactoring are focussed on the topic of pointcut generation. One important limitation of current-day aspect refactoring techniques is that the pointcut expression that is created by such refactorings is not pattern-based. As a result, these - often enumerative - pointcuts can be brittle with respect to evolution of the base program. We propose a technique to automatically induce such pattern-based pointcuts by using inductive logic programming, a technique originating from the domain of machine learning and data mining.
- Work in collaboration with Kris Gybels, Kim Mens, Mathieu Braem and Wim Vanderperren
- Find out more:
- A Survey of Automated Code-Level Aspect Mining Techniques
Andy Kellens, Kim Mens, Paolo Tonella
Transactions on Aspect-Oriented Software Development IV, LNCS 4640, p. 143-162, Springer Verlag, 2007 - Automated Pattern-Based Pointcut Generation
Mathieu Braem, Kris Gybels, Andy Kellens, Wim Vanderperren
Software Composition (SC), LNCS 4089, p. 66-81, 2006 - Experiences with Identifying Aspects in Smalltalk Using 'Unique Methods'
Kris Gybels, Andy Kellens
Linking Aspect Technology and Evolution (LATE), collocated with AOSD, 2005 - Issues in Performing and Automating the 'Extract Method Calls' Refactoring
Andy Kellens, Kris Gybels
Software Engineering Properties of Languages and Aspect Technologies (SPLAT), collocated with AOSD, 2005
Artefacts (top)
The Intensional Views Environment, or IntensiVE for short, can be found at this website.