XFindBugs: eXtended FindBugs for AspectJ (original) (raw)
Related papers
Flota: a programmer assistant for locating faulty changes in AspectJ software evolution
2008
Abstract As Aspect-Oriented Programming (AOP) wins more and more popularity, there is increasing interest in using aspects to implement crosscutting concerns in object-oriented software. During software evolution, source code editing and testing are interleaved activities to assure code quality. If regression tests fail unexpectedly after a long session of editing, it may be difficult for programmers to find out the failure causes. In this paper, we present Flota, a fault localization tool for AspectJ programs.
On identifying bug patterns in aspect-oriented programs
2007
Abstract Bug patterns are erroneous code idioms or bad coding practices that have been proved fail time and time again. They mainly arise from the misunderstanding of language features, the use of erroneous design patterns or simple mistakes sharing the common behaviors. Aspect-oriented programming (AOP) is a new technique to separate the cross-cutting concerns for improving modularity in software design and implementation.
Locating faults in AspectJ programs
2007
ABSTRACT As Aspect-Oriented Programming (AOP) wins more and more popularity, there is increasing interest in using aspects to implement crosscutting concerns in object-oriented software. During software evolution, source code editing and testing are interleaved activities to assure code quality. When regression tests fail unexpectedly after a long session of editing, it may be difficult for programmers to find out the failure causes.
2010
Since the proposal of Aspect-Oriented Programming, several candidate fault taxonomies for aspect-oriented (AO) software have been proposed. Such taxonomies, however, generally rely on language features, hence still requiring practical evaluation based on realistic implementation scenarios. The current lack of available AO systems for evaluation as well as historical data are the two major obstacles for this kind of study. This paper quantifies, documents and classifies faults uncovered in several releases of three AO systems, all from different application domains. Our empirical analysis naturally led us to revisit and refine a previously defined fault taxonomy. We identified particular fault types that stood out amongst the categories defined in the taxonomy. Besides this, we illustrate recurring faulty scenarios extracted from the analysed systems. We believe such scenarios should be considered for the establishment of testing strategies along the software development process.
Debugging Aspect-Enabled Programs
Lecture Notes in Computer Science, 2007
The ability to debug programs composed using aspect-oriented programming (AOP) techniques is critical to the adoption of AOP. Nevertheless, many AOP systems lack adequate support for debugging, making it difficult to diagnose faults and understand the program's composition and control flow. We present an AOP debug model that characterizes AOP-specific program composition techniques and AOP-specific program behaviors, and relates them to the AOP-specific faults they induce. We specify debugging criteria that we feel all AOP systems should support and compare how several AOP systems measure up to this ideal.
Usage and testability of AOP: An empirical study of AspectJ
Information and Software Technology, 2013
Context. Back in 2001, the MIT announced aspect-oriented programming as a key technology in the next 10 years. Nowadays, 10 years later, AOP is still not widely adopted. Objective. The objective of this work is to understand the current status of AOP practice through the analysis of open-source project which use AspectJ. Method. First we analyze different dimensions of AOP usage in 38 AspectJ projects. We investigate the degree of coupling between aspects and base programs, and the usage of the pointcut description language. A second part of our study focuses on testability as an indicator of maintainability. We also compare testability metrics on Java and AspectJ implementations of the HealthWatcher aspect-oriented benchmark. Results. The first part of the analysis reveals that the number of aspects does not increase with the size of the base program, that most aspects are woven in every places in the base program and that only a small portion of the pointcut language is used. The second part about testability reveals that AspectJ reduces the size of modules, increases their cohesion but also increases global coupling, thus introducing a negative impact on testability. Conclusion. These observations and measures reveal a major trend: AOP is currently used in a very cautious way. This cautious usage could come from a partial failure of AspectJ to deliver all promises of AOP, in particular an increased software maintainability.
Towards a Catalogue of Refactorings and Code Smells for AspectJ
2006
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.
Automated Test Generation for AspectJ Programs
2000
Aspect-oriented software development (AOSD) is a new paradigm that improves separation of concerns in software development. AOSD has gained popularity with the adoption of languages such as As- pectJ. Automated test generation for AspectJ programs is important for reducing the manual effort in testing AspectJ programs. This position paper proposes Wrasp, a framework for automatic gener- ation of tests for
Aspect-Oriented Programming with AspectJ
Aspect-oriented programming (AOP) is an exciting new development in the field of software engineering. The open-source AspectJt project has taken a leading role in defining what an aspect-oriented programming language should look like and in building tools that enable aspect-oriented techniques to be employed in the development of large-scale commercial software. IBM both contributes to the development of AspectJ and uses it internally with its accompanying IDE (integrated development environment) support, AspectJ Development Tools (AJDT). This paper provides an introduction to aspect-oriented programming using AspectJ and AJDT. We also discuss the role that open source (and being an open-source project) has played in the ongoing development of AspectJ, and how this has facilitated a level of collaboration and exploitation that would not have been possible otherwise.