Defining and Detecting Bad Smells of Aspect-Oriented Software

Abstract

Bad Smells are software patterns that are generally associated with bad design and bad programming. They can be removed by using the refactoring technique which improves the quality of software. Aspect-Oriented (AO) software development, which involves new notions and the different ways of thinking for developing software and solving the crosscutting problem, possibly introduces different kinds of design flaws. Defining bad smells hidden in AO software in order to point out bad design and bad programming is then necessary. This paper proposes the definition of new AO bad smells. Moreover, appropriate existing AO refactoring methods for eliminating each bad smell are presented. The proposed bad smells are validated. The results show that after removing the bad smells by using appropriate refactoring methods, the software quality is increased.

Empirical taxonomy of refactoring methods for aspect‐oriented programming

“… Pull up advice – When all sub‐aspects use the same advice acting on a pointcut declared in the super‐aspect, we can move the advice to the super‐aspect. Push down advice – When there is a piece of advice used by only some sub‐aspects, or when each sub‐aspect requires a different advice, we can move the advice to the sub‐aspects that use it. Pull up declare parents – When all sub‐aspects use the same declare parents, we can move the declare parents to the super‐aspect. Push down declare parents – When a declare parents in a super‐aspect is not relevant to all the sub‐aspects, then we can move the declare parents to the sub‐aspects where it is relevant. Pull up inter‐type declaration – If we have an inter‐type declaration that would be best placed in the super‐aspect, then we could move the inter‐type declaration to the super‐aspect. Push down inter‐type declaration – If there is an inter‐type declaration that would be best placed in a sub‐aspect, then we can move the inter‐type declaration to the sub‐aspect where it is relevant. Pull up pointcut – If all sub‐aspects declare identical pointcuts, then we can move the pointcuts to the super‐aspect. Push down pointcut – If there is a pointcut in the super‐aspect that is not used by some sub‐aspects inheriting it, then we can move the pointcut to those sub‐aspects that use it. Eliminating borrowed pointcut – when a pointcut is referred by advices of the aspects that are not sub‐aspects. Eliminating duplicated pointcut – When pointcuts collect the same set of joinpoints in base code, we can apply this refactoring method to eliminate the duplications. Move static introduction – To move a static inter‐type member introduction to a different aspect, we can inline (localize) it from the original aspect into its target types and then extract it into the desired target aspect.…”

“…In , they introduced AspectJ programming laws that can be used to derive or create behavior preserving transformations (refactorings) for a subset of AspectJ. Srivisut et al proposed a definition of new aspect‐oriented bad smells and presented appropriate AOR methods for eliminating each bad smell. The authors proposed a set of bad‐smell metrics to use as indicators to verify if a particular fraction of aspect‐oriented code contains bad smells.…”

“…Each one includes the motivation of why the refactoring should be performed and step-bystep description of how to carry out the refactoring. In addition, many other refactorings have been proposed and used [4,10,15,18,23]. In our study, we divided the specific refactorings for aspectoriented constructs into two different groups.…”

“…• Push down pointcut [10] -If there is a pointcut in the super-aspect that is not used by some subaspects inheriting it, then we can move the pointcut to those sub-aspects that use it. • Eliminating borrowed pointcut [23] when a pointcut is referred by advices of the aspects that are not sub-aspects. • Eliminating duplicated pointcut [23] -When pointcuts collect the same set of joinpoints in base code, we can apply this refactoring method to eliminate the duplications.…”

“…• Eliminating borrowed pointcut [23] when a pointcut is referred by advices of the aspects that are not sub-aspects. • Eliminating duplicated pointcut [23] -When pointcuts collect the same set of joinpoints in base code, we can apply this refactoring method to eliminate the duplications. • Move static introduction [15] -To move a static inter-type member introduction to a different aspect, we can inline (localize) it from the original aspect into its target types and then extract it into the desired target aspect.…”