A framework based approach for unified detection of Aspect Weaving Problems

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.

The need for adaptability in software is growing, driven in part by the emergence of autonomic computing. In many cases, it is desirable to enhance existing programs with adaptive behavior, enabling them to execute effectively in dynamic environments. The peer-to-peer (p2p) paradigm is attracting increasing attention from both the research community and software engineers, due to potential performance, reliability and scalability improvements. P2P model has opened many new avenues for research and applications within the field of distributed computation, so performance evaluation is unavoidable. In this paper we are using Aspect oriented programming (AOP) to enable dynamic adaptation in existing p2p JXTA Services. We propose an approach to implement dynamic adaptability especially in existing p2p JXTA Service programs and Aspect weaving in p2p JXTA using AOP. We have used AspectJ; Java based language to create aspects in Eclipse supported framework.KeywordsDynamic adaptationAspect Oriented ProgrammingAspectJp2p JXTA Services and Reusability

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.

There is nowadays a wide recognition that low coupling is a main tenet in the measurement of high-quality modular software. In fact, coupling is one of the few internal software attributes that has been both theoretically and empirically shown to have a large impact on a variety of external software qualities, such as reusability, maintainability, evolvability and testability. Aspect-oriented programming (AOP) is an emerging technique that advocates enhanced modularization of certain widely-scoped system properties, the so-called crosscutting concerns. However, there is a poor common understanding of coupling in the context of AOP. Most of the existing metrics and assessment frameworks concentrate on the coupling evaluation of the AspectJ programming language. In addition, they took their own particular view of what coupling means in this particular language. This paper presents the definition of a generic coupling framework that takes into account both AspectJ and CaesarJ, two representatives of the most well-known families of available AOP languages. The current version of the proposed framework allows for the definition of different coupling metrics, which in turn permits the analysis and comparison of Java, AspectJ and CaesarJ implementations. We also illustrate how the framework can be applied to the characterization of existing coupling metrics.

Despite of the proliferation of object-oriented and component technology, their application to real-time operating systems (RTOS) has been limited since most design concerns in RTOSes crosscut software components and these are critical to deliver required performance and functionality. Aspect-Oriented Programming (AOP) is a very effective means to solve the crosscutting problem. However, we have observed the following limitations of the current AOP framework: (1) the current text-based AOP languages cannot clearly show how aspects are weaved together, (2) their granularity is too coarse to capture all aspects in an RTOS, (3) it is difficult to control the weaving process, since aspect weavers are usually hard-coded. In this paper, we propose a new AOP framework that provides (1) a graphical aspect programming environment that visualizes aspects, crosscutting classes, and method structures, (2) a new aspect model that supports a sub-method level granularity where an aspect is defined as a set of classes, and (3) an aspect weaving process specified by an object-oriented meta-model transformation. Since our aspect-oriented programming framework improves the expressiveness of the crosscutting concerns of RTOSes and automates aspect weaver generation, it can enhance RTOS customization.

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.

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 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.

Modelling techniques are instruments for reality reflection. Precision of reality reflection demands coexistence of different abstraction types like objects and aspects in one model. Experiments with extension of modelling techniques aimed to accommodate combinations of objects and aspects in one specification have resulted in aspect-oriented extensions of many conventional modelling semantics. It was found that one of semantics called Protocol Modelling possess a very practical property of local reasoning on objects and aspects about behaviour of the whole model. In this paper the local reasoning property is defined in the reasoning logic and this property is demonstrated with a case study in the Protocol Modelling approach. Then the same case study is presented in aspect-oriented extensions of modelling approaches based on the semantics of contracts, sequence diagrams, workflows and state machines. The case study shows that the extensions of conventional semantics do not possess the local reasoning property. The semantic difference between Protocol Modelling and the listed modelling semantics is discussed and the useful semantic elements are recommended for new aspect-oriented languages and middleware.

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.

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.

Loosely coupled properties of SOA(Service Oriented Architecture) services do not guarantee that service applications always work properly. Service errors may also influence other services of SOA. These characteristics adversely affect software reliability. Therefore, it is a challenge to effectively manage system change and errors for operating services normally. In this study, we propose a SOA based framework using AOP(Aspect Oriented Programming) for reliable service applications. AOP provides a way to manipulate cross-cutting concerns such as logging, security and reliability and these concerns can be added to applications through weaving process. We define a service specification and an aspect specification for this framework. This framework also includes service provider, requester, repository, platform, manager, and aspect weaver to handle changes and exceptions of applications. Independent Exception Handler is stored to exhibited external Aspect Service Repository. When exception happened, Exception Handler is linked dynamically according to aspect rule that is defined in aspect specification and offer function that handle exception alternate suitable service in systematic error situation. By separating cross-cutting concerns independently, we expect that developer can concentrate on core service implementation and reusability, understanding, maintainability increase. Finally, we have implemented a prototype system to demonstrate the feasibility of our framework in case study.

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.