Abstract. Aspect composition often involves advice interference and this is a crucial problem in aspect oriented programming. When multiple advices are woven at the same join point, the advices often interfere with each other. Giving appropriate precedence order is a typical solution of this problem but it cannot resolve all kinds of advice interference. To address this problem, we propose a novel language extension named Airia, which provides a new kind of around advice for resolving advice interference. This kind of advice named a resolver is invoked only at the join points when given advices conflict with each other. The resolvers can call an extended version of proceed, which takes as an argument precedence order among remaining advices. Furthermore, the resolvers are composable. They can be used to resolve interference among other resolvers and advices.

No abstract

Abstract. The optional feature problem in feature-oriented programming is that implementing the interaction among features is difficult. Either of the modules for the interacting features cannot contain the code for the interaction if those features are optional. A modular approach for implementing such interaction is separating it into a module called derivative. However, as the number of derivatives increases, it does not scale. This paper shows how derivatives for combinations of features from each group are efficiently implemented. A group of features are implemented by using the inheritance of feature modules. A super feature module works as a common interface to members of that group. It thereby allows to describe a generic derivative applicable for the groups. This paper also presents a feature-oriented programming language, FeatureGluonJ, which provides language constructs for this approach. Feature-Oriented ProgrammingFeature-oriented programming (FOP) [26] is a programming paradigm where source code is decomposed for each feature. Although it was originally an approach for implementing similar classes, it now refers to an approach for implementing similar software products; such a family of products is called a software product line (SPL). This allows developers by just selecting the features for that necessary product.In FOP, the code for each feature is separately described in a module called a feature module. A feature module is a collaboration of the classes needed for the feature and/or extensions to the classes belonging to other features. The extensions can be aspects in AspectJ; advices can attach code for the feature to existing code; inter-type declarations can add new fields to an existing class. Several product lines such as the feature-oriented version of Berkeley DB [18] and MobileMedia [30] not contain the code for the interaction since the code must be effective only when those interacting features are selected. Although a possible approach is separating such code into independent modules called derivatives [21,22], the number of derivatives tends to be large as the numbers of features increases. This paper proposes a design principle to reduce the effort in implementing derivatives. A group of features are implemented by inheriting their common super feature module. This module works as an interface common to its subfeatures and allows implementing a derivative in a reusable manner for every combination of sub-features. To demonstrate this principle, we developed a new FOP language, FeatureGluonJ, which provides a language construct called a generic feature module for reusable implementation of derivative as well as a feature-oriented module system supporting inheritance. The Optional Feature ProblemThis section explains a difficulty in feature-oriented decomposition known as the optional feature problem [21,22]. We can see this problem in the MobileMedia SPL. MobileMedia is a family of multimedia-management application for mobile devices and widely used in the research community of...

In feature-oriented programming (FOP), code clones are also important issue. Although an approach called a software product line (SPL) enables to implement products efficiently by reusing most of their code, SPLs implemented by FOP contain a lot of code clones. Code clones are often caused by alternative features and we also found clones in derivatives among alternative features. To resolve this problem, we propose a new FOP language named FeatureGluonJ, which supports family polymorphism with revisers. The code clones among alternative features are separated into another feature and can be shared among the alternative features by extending that feature. Furthermore, clones in derivatives can be removed as well.