Miguel Pessoa Monteiro

Towards a catalog of aspect-oriented refactorings

In this paper, we present a collection of aspect-oriented refactorings covering both the extraction of aspects from object-oriented legacy code and the subsequent tidying up of the resulting aspects. In some cases, this tidying up entails the replacement of the original implementation with a different, centralized design, made possible by modularization. The collection of refactorings includes the extraction of common code in various aspects into abstract superaspects. We review the traditional object-oriented code smells in the light of aspect-orientation and propose some new smells for the detection of crosscutting concerns. In addition, we propose a new code smell that is specific to aspects.

Reusable aspect-oriented implementations of concurrency patterns and mechanisms

In this paper, we present a collection of well-known high-level concurrency patterns and mechanisms, coded in AspectJ. We discuss benefits of these implementations relative to plain Java implementations of the same concerns. We detect benefits from using AspectJ in all the cases presented, in the form of higher modularity, reuse, understandability and unpluggability. For most of the implementations, two alternatives can be used: one based on traditional pointcut interfaces and one based on annotations.

Towards a catalogue of refactorings and code smells for aspectj

In this paper, we contribute to the characterisation of a programming style specific to aspect-oriented programming. For this purpose, we present a collection of refactorings for aspect-oriented source code, comprising refactorings to enable extraction to aspects of crosscutting concerns from object-oriented legacy code, the subsequent tidying up of the extracted aspects and factoring out of common code from similar aspects to superaspects. The second group of refactorings is documented in detail. In addition, we propose some new aspect-oriented code smells, including one smell that is specific to aspect modules. We also propose a reinterpretation of some of the traditional object-oriented code smells in the light of aspect-orientation, to detect the presence of crosscutting concerns.

Refactoring a Java code base to AspectJ: an illustrative example

This paper describes a refactoring process transforming a Java code base into an AspectJ equivalent. The process illustrates 17 aspect-oriented refactorings covering extraction of implementation elements to aspects, internal reorganization of extracted aspects, and extraction of commonalities to superaspects.

Reducing Subjectivity in Code Smells Detection: Experimenting with the Long Method

Guidelines for refactoring are meant to improve software systems internal quality and are widely acknowledged as among software’s best practices. However, such guidelines remain mostly qualitative in nature. As a result, judgments on how to conduct refactoring processes remain mostly subjective and therefore non-automatable, prone to errors and unrepeatable. The detection of the Long Method code smell is an example. To address this problem, this paper proposes a technique to detect Long Method objectively and automatically, using a Binary Logistic Regression model calibrated by expert’s knowledge. The results of an experiment illustrating the use of this technique are reported.

Aspect oriented pluggable support for parallel computing

In this paper, we present an approach to develop parallel applications based on aspect oriented programming. We propose a collection of aspects to implement group communication mechanisms on parallel applications. In our approach, parallelisation code is developed by composing the collection into the application core functionality. The approach requires fewer changes to sequential applications to parallelise the core functionality than current alternatives and yields more modular code. The paper presents the collection and shows how the aspects can be used to develop efficient parallel applications.

A domain-specific language for parallel and grid computing

This paper overviews a Domain-Specific Language (DSL) for parallel and grid computing, layered on top of AspectJ. This DSL aims to bridge the gap between sequential code and parallel/grid applications, by avoiding invasive source code changes in scientific applications. Moreover, it aims to promote the localization of parallelization and gridification issues into well defined modules that can be (un)plugged (from)to existing scientific applications. This paper builds on previous work based on AspectJ and presents the main motivations for implementing a DSL in preference to a pure-AspectJ solution. The paper presents the DSLs design rationale, overviews current implementation and open research issues.

Enriching MATLAB with aspect-oriented features for developing embedded systems

This article presents an approach to enrich the MATLAB language with aspect-oriented modularity features, enabling developers to experiment different implementation characteristics and to acquire runtime data and traces without polluting their base MATLAB code. We propose a language through which programmers configure the low-level data representation of variables and expressions. Examples include specifically-tailored fixed-point data representations leading to more efficient support for the underlying hardware, e.g., digital signal processors and application-specific architectures, without built-in floating point units. This approach assists developers in adding handlers and monitoring features in a non-invasive way as well as configuring MATLAB functions with optimized implementations. Different aspect modules can be used to retarget common MATLAB code bases for different purposes and implementations. We validate the proposed approach with a set of representative examples where we attain a simple way to explore a number of properties. Experiment results and collected aspect-oriented software metrics lend support to the claims on its usefulness.

Design pattern implementation in object teams

Implementing the 23 Gang-of-Four design patterns in the aspect-oriented programming language Object Teams/Java (OT/J) yields modularity and reusability results roughly comparable to those obtained in a similar study of AspectJ, though not in the same exact set of patterns. Due to differences in composition mechanisms, the two languages seem complementary rather than overlapping. AspectJ is clearly superior to OT/J in terms of quantification capability while OT/J is clearly superior to AspectJ as regards extensibility of pattern modules.

A pattern language for parallelizing irregular algorithms

In irregular algorithms, data sets dependences and distributions cannot be statically predicted. This class of algorithms tends to organize computations in terms of data locality instead of parallelizing control in multiple threads. Thus, opportunities for exploiting parallelism vary dynamically, according to how the algorithm changes data dependences. This paper presents the first part of a pattern language for creating parallel implementations of irregular algorithms and applications. Four patterns are proposed: Amorphous Data-Parallelism, Data-Parallel Graph, Optimistic Iteration and In-Order Iteration.