Towards a unified coupling framework for measuring aspect-oriented programs

In Aspect-Oriented Programming (AOP), a crosscutting concern is extracted from a base program and is modularized into a new construct called aspect. The aspect is weaved back to the program to incorporate the crosscutting behaviors. Many semantic problems, referred to as Aspect Weaving Problems (AWPs) in this paper, could be introduced in the aspect weaving process. The AWPs have been independently defined using different modeling approaches for their detections. In practice, it is difficult for AOP developers to detect these problems, because they have to switch between different tools/methods. This is a time consuming and error-prone process. Consequently, it could increase the production costs of Aspect-Oriented development. This paper proposes a taxonomy of the AWPs to clearly define and classify the problems. Based on the taxonomy and a unified modeling approach to detect the AWPs, a conceptual analysis framework for the AWPs is also proposed. The framework aims at the integration of the unified AWPs detection capabilities into legacy aspect weavers by reusing (adapting) the modeling approach for various AOP languages.

The rapidly growing mobile market has stimulated the demand for more and more complex custom applications for embedded mobile devices, for example, smart phones. To manage this complexity and, at the same time, to keep the time to market small, advanced software engineering methods have to be applied. Aspect-oriented programming (AOP) provides advanced modularization and abstraction mechanisms. The main advantages of this concept are improved maintainability, reusability, and extensibility of applications. Furthermore, dynamic AOP can be used to implement the dynamic adaptation of mobile device applications to changing contexts, like the location. However, the overhead introduced by the additional abstraction mechanisms limits the applicability to embedded mobile devices because they have limited resources (CPU, memory) compared to desktop PCs. To overcome this problem, we present a set of optimizations that significantly reduce the overhead of common AOP mechanisms and, finally, make AOP applicable for embedded mobile devices. The foundation of our work is a thorough analysis of the overhead that is typically generated by the realization of AOP mechanisms. The key idea of our approach is a deep integration of AOP mechanisms into the virtual machine. To this end, we shift mechanisms like the registration of activated aspects to the level of the JVM. Furthermore, we optimize the execution of AOP programs by introducing caching mechanisms and specialized bytecode instructions that are tailored for the execution of AOP mechanisms. Moreover, we analyze AOP-specific semantic code properties in order to develop optimizations that utilize these AOP-specific semantic information and that exploit typical AOP usage schemes. In addition to the AOP optimizations, we realize an efficient dynamic aspect deployment mechanism. We apply our optimizations to the Java-based aspect-oriented programming language ObjectTeams [HHM07] by extending the extremely small and portable JamVM [Lou] Java virtual machine. To evaluate our approach, we execute micro benchmarks, investigate the effect of our optimizations on a real-world application, and finally discuss the transferability of our optimizations to other approaches. Our evaluation shows a considerable performance gain for the aspect activation and the aspect execution of ObjectTeams. In particular, we demonstrate that our optimizations improve the performance of commonly used AOP mechanisms by up to 90%. At the same time, we reduce the code size of the adapted classes, which is also important for small devices. Finally, with our case study, namely the OTPong game application, we show that our approach is capable of significantly optimizing the execution time of real-word applications. Our main contribution is a significant reduction of the overhead of high-level AOP constructs, which is also demonstrated by the results of our experiments. The success of the optimizations provides evidence that advanced high-level abstraction techniques like AOP can be efficiently used in embedded mobile devices. Furthermore, our work shows that efficient dynamic aspect deployment can be supported on the level of the JVM. This substantially enhances the dynamic capabilities of ObjectTeams.

Software is a complex entity, and its development needs careful planning and a high amount of time and cost. To assess quality of program, software measures are very helpful. Amongst the existing measures, coupling is an important design measure, which computes the degree of interdependence among the entities of a software system. Higher coupling leads to cognitive complexity and thus a higher probability occurrence of faults. Well in time prediction of fault-prone modules assists in saving time and cost of testing. This paper aims to capture important aspects of coupling and then assess the effectiveness of these aspects in determining fault-prone entities in the software system. We propose two coupling metrics, i.e., Vovel-in and Vovel-out, that capture the level of coupling and the volume of information flow. We empirically evaluate the effectiveness of the Vovel metrics in determining the fault-prone classes using five projects, i.e., Eclipse JDT, Equinox framework, Apache Lucene, Mylyn, and Eclipse PDE UI. Model building is done using univariate logistic regression and later Spearman correlation coefficient is computed with the existing coupling metrics to assess the coverage of unique information. Finally, the least correlated metrics are used for building multivariate logistic regression with and without the use of Vovel metrics, to assess the effectiveness of Vovel metrics. The results show the proposed metrics significantly improve the predicting of fault prone classes. Moreover, the proposed metrics cover a significant amount of unique information which is not covered by the existing well-known coupling metrics, i.e., CBO, RFC, Fan-in, and Fan-out. This paper, empirically evaluates the impact of coupling metrics, and more specifically the importance of level and volume of coupling in software fault prediction. The results advocate the prudent addition of proposed metrics due to their unique information coverage and significant predictive ability.

Aspect-oriented programming is a promising approach to address separation of concerns. Aspect-oriented programming languages address the problems of scattering and entanglement by providing an abstraction for specifying cross-cutting concerns in a modular manner. The relevant aspects are then composed to derive the desired implementation. However, current aspect-oriented programming languages only allow this composition to be specified in terms of programming language constructs. This is restrictive and can only be used for simple compositions. Many situations in practice need a richer composition context that cannot be expressed using programming language constructs. Models, being at a higher level of abstraction and closer to the problem domain, can be used to capture this information. We propose an approach to extend aspect-oriented programming with a composition mechanism that can make use of the information captured in models. We also outline an implementation of the proposed approach. The proposed approach has been used to seamlessly integrate model-centric and code-centric development.

Aspect-oriented programming (AOP) is a novel topic in the software engineering and languages communities. AOP appears to have the potential to significantly improve the reliability of programs, particularly by modularizing error-handling policies and allowing for easier maintenance and better reuse. In this article, we introduce AspectJ, the first AOP language, and demonstrate how you can use it to construct more reliable software.

Nowadays, software development has become more complex and dynamic; they are expected more flexible, scalable and reusable. Under the umbrella of aspect, Aspect-Oriented Software Development (AOSD) is relatively a modern programming paradigm to improve modularity in software development. Using Aspect-Oriented Programming (AOP) language to implements crosscutting concerns through the introduction of a new construct Aspect like Class is defined as a modular unit of crosscutting behavior that affect multiple classes into reusable modules. Several quality models to measure the quality of software are available in literature. However, keep on developing software, and acceptance of new environment (i.e. AOP) under conditions that give rise to an issue of evolvability. After the evolution of system, we have to find out how the new system needs to be extensible? What is the configurable status? Is designed pattern stable for new environment and technology? How the new system is sustainable? The objective of this paper is to propose a new quality model for AOSD to integrating some new quality attributes in AOSQUAMO Model based which is based on ISO/IEC 9126 Quality Model, is called Aspect- Oriented Quality (AOSQ) Model. Analytic Hierarchy Process (AHP) is used to evaluate an improved hierarchical quality model for AOSD.

AspectJ is a well-established programming language for the implementation of aspect-oriented programs. It supports the aspect-oriented programming paradigm by providing a special unit, called aspect, which encapsulates crosscutting code. While with AspectJ a suitable aspect-oriented programming language is at hand, no feasible modeling language is available that supports the design of AspectJ programs. In this work, such a design notation for AspectJ programs is presented based on the UML. It provides representations for all language constructs in AspectJ and specifies an UML implementation of AspectJ's weaving mechanism. The design notation eases the perception of aspect-orientation and AspectJ programs. It carries over the advantages of aspect-orientation to the design level.

Developing a machine model natively supporting aspect-oriented programming (AOP) is fruitful not only for implementing interpreters and compilers for AOP languages but also for understanding the essence of the AOP paradigm. This position paper shows a machine model based on open classes and predicate dispatch and it briefly describes a list of predicates that are necessary for modeling AspectJ. This machine model is useful for comparing AOP and object-oriented programming (OOP) on a side-by-side basis. Our initial observation is that AOP is a natural extension to OOP with respect to language constructs.

In this paper we discuss an approach to support declarative reasoning over aspect-oriented (AO) programs, adopting AspectJ as a representative technology. The approach is based on the transformation of source code into a set of facts and rules, stored into a Prolog database. Declarative analysis allows us to extract complex information through its rich and expressive syntax. Our approach has two contributions. First, it aims to improve the comprehension of AspectJ programs. The type of knowledge provided is categorized in three main groups: i) general knowledge, ii) bad smells, and iii) quality metrics. The second contribution is the provision of dependency analysis of AspectJ programs. To that end, we identify dependencies in aspect-oriented programs, and translate them into Prolog rules. Expected beneficiaries of our approach include system maintainers who can obtain comprehension and perform dependency analysis through querying the Prolog database during the change planning stage of system evolution.

In this pauper, we present two new pointcuts and two new primitives to Aspect-Oriented Programming (AOP) languages that are needed for systematic hardening of security concerns. The two proposed pointcuts allow to identify particular join points in a progiam's control flow graph (CFG). The first one is the GAFlow, the Closest Guaranteed Ancestor, which returns the closest ancestor join point to the pointcuts of interest that is on all their runtime paths. The second one is the GDFlow, the Closest Guaranteed Descendant, which returns the closest child join point that can be reached by all paths starting from the pointculs of interest. The two proposed primitives are called ExportParameter and ImportParameter and are used to pass parameters between two pointcuts.

Aspect-Oriented Programming (AOP) is a programming paradigm that implements crosscutting concerns in a modular way. People have witnessed the prosperity of AOP languages for Java and C++, such as AspectJ and AspectC++, which has propelled AOP to become an important programming paradigm with many interesting application scenarios, e.g., runtime verification. In contrast, the AOP languages for C are still poor and lack compiler support. In this paper, we design a new general-purpose and expressive aspect-oriented C programming language, namely Aclang, and implement a compiler for it, which brings fully-fledged AOP support into the C domain. We have evaluated the effectiveness and performance of our compiler against two state-of-the-art tools, ACC and AspectC++. In terms of effectiveness, Aclang outperforms ACC and AspectC++. In terms of performance, Aclang outperforms ACC in execution time and outperforms AspectC++ in both execution time and memory consumption.

Web service technology allows for the development of client applications independently of the Web services they use. In this article, we propose a dynamic invocation mechanism for unanticipated Web services that offers support for conversational messaging, based on dynamic aspect oriented programming (AOP) techniques. Aspects are used to store the communication details and the conversational context of the Web service. In case of service failures, the conversation can be replayed on another semantically equivalent Web service, in a transparent way for the client. Code examples are given in the dynamic AOP language JAsCo, and a prototype, called Web services management layer, is discussed as a proof of concept.

Since its inception in 1996, aspect-oriented programming (AOP) has been believed to reduce the effort required to maintain software systems by replacing cross-cutting code with aspects. However, little convincing empirical evidence exists to support this claim, while several studies suggest that AOP brings new obstacles to maintainability. This paper discusses two controlled experiments conducted to evaluate the impact of AspectJ (the most mature and popular aspect-oriented programming language) versus Java on software evolvability. We consider evolvability as the ease with which a software system can be updated to fulfill new requirements. Since a minor language was compared to the mainstream, the experiments were designed so as to anticipate that the participants were much more experienced in one of the treatments. The first experiment was performed on 35 student subjects who were asked to comprehend either Java or AspectJ implementation of the same system, and perform the corresponding comprehension tasks. Participants of both groups achieved a high rate of correct answers without a statistically significant difference between the groups. Nevertheless, the Java group significantly outperformed the AspectJ group with respect to the average completion time. In the second experiment, 24 student subjects were asked to implement (in a non-invasive way) two extension scenarios to the system that they had already known. Each subject evolved either the Java version using Java or the AspectJ version using AspectJ. We found out that a typical AspectJ programmer needs significantly fewer atomic changes to implement the change scenarios than a typical Java programmer, but we did not observe a significant difference in completion time. The overall result indicates that AspectJ has a different effect on two sub-characteristics of the evolvability: understandability and changeability. While AspectJ decreases the former, it improves one aspect of the latter.

In traditional engineering disciplines, design is a problem solving process. It aims at mapping problems to realizable solutions, expressed using the artifacts in the corresponding engineering domain. Traditional engineering disciplines have introduced the concepts of canonical component models, systemic models, system construction rules and multiple (simultaneous) models. The emerging phenomena of the aspect-oriented software development techniques can be explained and motivated within this context. The concepts of component models, systemic models, system construction rules, multiple models as defined in traditional engineering disciplines correspond respectively to the concepts of base-level models, aspect models, join point models and multi-dimensional separation of concerns of aspect-oriented languages. Aspect-oriented languages can model the natural systemic properties of problem domains. This allows them to be a better representation than conventional object-oriented languages. This talk will explain the principles of aspect-oriented programming languages from the problem solving perspective. Based on this conceptual framework, aspect-oriented language design dimensions will be outlined. In the second part of the talk, the approach taken by the composition filters model will be explained. The talk will end by comparing filters with other approaches, advantages and shortcomings.

In aspect-oriented programming, aspects are essentially incremental modifications to their base classes. Therefore aspect-oriented programs can be tested in an incremental fashion – we can first test the base classes and then test the base classes and aspects as a whole. This paper demonstrates that, in this incremental testing paradigm, we can prioritize aspect tests so as to report failure earlier. We explore test prioritization for testing aspect-oriented programs against their state models with transition coverage and round-trip coverage. Aspect tests are generated from woven state models obtained by composing aspect models into their base class models. We prioritize aspect tests by identifying the extent to which an aspect modifies its base classes. The modification is measured by the number of new and changed components in state transitions (start state, event, precondition, postcondition, end state). Transitions with more changes have higher priorities for test generation. We evaluate the impact of aspect test prioritization through mutation analysis of two AspectJ programs, where all aspects and their base classes can be modeled by finite state machines. We create aspect mutants of each AspectJ program according to a comprehensive AspectJ fault model. Then we test each mutant with the test suites generated without prioritization and with prioritization, respectively. Our experiment results show that prioritization of aspect tests has accelerated failure report.