The aim of this work is to measure the impact of aspect-oriented programming on software performance. Thus, we hypothesized as follow: adding aspects to a base program will affect its performance because of the overhe...
详细信息
The aim of this work is to measure the impact of aspect-oriented programming on software performance. Thus, we hypothesized as follow: adding aspects to a base program will affect its performance because of the overhead caused by the control flow switching, and that incremental effect on performance is more obvious as the number of join points increases. To test our hypotheses we carried out a case study of two concurrent architectures: Half-Sync/Half-Async and Leader/Followers. aspects are extracted and encapsulated and the base program performance was compared to the aspect program. Our results show that the aspect-oriented approach does not have significant effect on the performance and that in some cases an aspect-oriented program even outperforms the non-aspect program. We also investigated the effect of cache fault rate on performance for both aspect and non-aspect programs. Based on our experiments, the results demonstrate that there is a close correlation between the cache fault rate and performance, which may be in favor of aspect code if some aspects are frequently accessed. Additionally, the introduction of a large number of join points does not have significant effect on performance.
BPEL or Business Process Execution Language is so far the most important standard language for effective composition of Web services. However, like most available process orchestration engines, BPEL does not provide a...
详细信息
BPEL or Business Process Execution Language is so far the most important standard language for effective composition of Web services. However, like most available process orchestration engines, BPEL does not provide automated support for reacting according to many changes that are likely to arise in any Web services composition, like downtime services, modifications in the business logic or even new policies to govern the composition. Also low-level specification of these new changes, which would be integrated at runtime in the BPEL process, will be far from being used conveniently. Moreover, the complexity of interaction in composite Web services and the diversity of rules and policies can lead to critical behavioral conflicts. We propose in this paper AOMD, a novel aspect-oriented and model driven approach that defines new grammar to address both adaptability and behavioral conflicts problems, and offers extension for WS-BPEL meta-model for high level specification of aspects. Further, we formally verify our proposition and we present real life case study, examples and experimental results that demonstrate the feasibility and effectiveness of our work. (C) 2015 Elsevier Ltd. All rights reserved.
We study the incorporation of generic types in aspect languages. Since advice acts like method update, such a study has to accommodate the subtleties of the interaction of classes, polymorphism and aspects. Indeed, si...
详细信息
We study the incorporation of generic types in aspect languages. Since advice acts like method update, such a study has to accommodate the subtleties of the interaction of classes, polymorphism and aspects. Indeed, simple examples demonstrate that current aspect compiling techniques do not avoid runtime type errors. We explore type systems with polymorphism for two models of parametric polymorphism: the type erasure semantics of Generic Java, and the type carrying semantics of designs such as genetic C#. Our main contribution is the design and exploration of a source-level type system for a parametric OO language with aspects. We prove progress and preservation properties. We believe our work is the first source-level typing scheme for an aspect-based extension of a parametric object-oriented language. (c) 2006 Elsevier B.V. All rights reserved.
Separation of concerns and loose coupling of concerns are important issues in software engineering. In this paper we show how to separate traversal-related concerns from other concerns, how to loosely couple traversal...
详细信息
Separation of concerns and loose coupling of concerns are important issues in software engineering. In this paper we show how to separate traversal-related concerns from other concerns, how to loosely couple traversal-related concerns to the structural concern, and how to efficiently implement traversal-related concerns. The stress is on the detailed description of our algorithms and the traversal specifications they operate on. Traversal of object structures is a ubiquitous routine in most types of information processing. Ad hoc implementations of traversals lead to scattered and tangled code and in this paper we present a new approach, called traversal strategies, to succinctly modularize traversals. In our approach traversals are defined using a high-level directed graph description, which is compiled into a dynamic road map to assist run-time traversals. The complexity of the compilation algorithm is polynomial in the size of the traversal strategy graph and the class graph of the given application. Prototypes of the system have been developed and are being successfully used to implement traversals for Java and aspectJ [Kiczales et al. 2001] and for generating adapters for software components. Our previous approach, called traversal specifications [Lieberherr 1992;Palsberg et al. 1995], was less general and less succinct, and its compilation algorithm was of exponential complexity in some cases. In an additional result we show that this bad behavior is inherent to the static traversal code generated by previous implementations, where traversals are carried out by invoking methods without parameters.
aspect-oriented programming (AOP), now practically a consolidated academic discipline, has yet to build more solid industrial foundations, especially in the realms of the .NET platform. It's believed that this sit...
详细信息
aspect-oriented programming (AOP), now practically a consolidated academic discipline, has yet to build more solid industrial foundations, especially in the realms of the .NET platform. It's believed that this situation is caused by the lack of a robust and user-friendly AOP tool for .NET comparable with the Java-based aspectJ. This work investigates the basic infrastructure required for building such a tool: aspect-oriented weaving with the common language runtime (CLR) environment. In this regard, a classification schema is built, analysing the attributes a hypothetical aspect weaver for .NET might have. It assesses the different classes of weavers that can be built on top of the CLR today and investigates what extensions to the platform would be needed in order to enable more sophisticated weaving technologies. Some typical use cases for the resulting AOP tools, and classify what attributes a corresponding weaver would need to have in order to fulfil these requirements. Finally, two existing aspect weaver implementations in terms of these very same attributes are analysed.
A conflict among aspects happens when two or more aspects compete for its activation. The treatment of conflicts should provide mechanisms for the detection and resolution of the same ones, with the objective of avoid...
详细信息
A conflict among aspects happens when two or more aspects compete for its activation. The treatment of conflicts should provide mechanisms for the detection and resolution of the same ones, with the objective of avoiding that the software execution will be uncertain and unstable. However, the mechanisms provided by the programmingaspect-oriented tools can be really limited, being this the case of aspectJ. In consequence, the resolution of certain conflicts becomes a critical problem since it drives to the restructuring of the code of the aspects. In this work the conflicting situations are identified that they are critical in aspectJ and particular and general solutions are delineated to the problem.
Many of today's distributed computing systems in the field do not Support the migration of execution entities among computing nodes (luring runtime. The relatively static association between units of processing an...
详细信息
Many of today's distributed computing systems in the field do not Support the migration of execution entities among computing nodes (luring runtime. The relatively static association between units of processing and computing nodes makes it difficult to implement fault-tolerant behavior or load-balancing schemes. The concept of code migration may provide a solution to the above-mentioned problems. it can be defined as the movement of processes, objects, or components from one computing node to another during system runtime in a distributed environment. With the advent of the virtual machine-based NET framework, many of the cross-language heterogeneity issues have been resolved. With the commercial implementation, the shared source "Rotor", and the open-source "Mono" implementation on hand, we have focused on cross-operating system heterogeneity issues and present interoperability and migration schemes for applications distributed over different operating systems (namely Linux and Windows 2000) as well as various NET implementations. Within this paper, we describe the integration of a migration facility with the hell) of aspect-oriented programming (AOP) into the NET framework. AOP is interesting as it addresses non-functional system properties on the middleware level, without the need to manipulate lower system layers like the operating system itself. Most features required to implement object or process migration (such as reflection mechanisms or a machine-independent executable format) are already present in the NET frameworks, so the integration of such a concept is a natural extension of the system capabilities. We have implemented several proof-of-concept applications for different use case scenarios. The paper contains an experimental evaluation of the performance impact of object migration in context of those applications.
Two programming paradigms are gaining attention in the overlapping fields of software product lines (SPLs) and incremental software development (ISD). Feature-orientedprogramming (FOP) aims at large-scale composition...
详细信息
Two programming paradigms are gaining attention in the overlapping fields of software product lines (SPLs) and incremental software development (ISD). Feature-orientedprogramming (FOP) aims at large-scale compositional programming and feature modularity in SPLs using ISD. aspect-oriented programming (AOP) focuses on the modularization of crosscutting concerns in complex software. Although feature modules, the main abstraction mechanisms of FOP, perform well in implementing large-scale software building blocks, they are incapable of modularizing certain kinds of crosscutting concerns. This weakness is exactly the strength of aspects, the main abstraction mechanisms of AOP. We contribute a systematic evaluation and comparison of FOP and AOP. It reveals that aspects and feature modules are complementary techniques. Consequently, we propose the symbiosis of FOP and AOP and aspectual feature modules (AFMs), a programming technique that integrates feature modules and aspects. We provide a set of tools that support implementing AFMs on top of Java and C++. We apply AFMs to a nontrivial case study demonstrating their practical applicability and to justify our design choices.
Standardization in Web services simplifies integration. However, it does not remove the need for adapters due to possible heterogeneity among service interfaces and protocols. In this paper, we characterize the proble...
详细信息
Standardization in Web services simplifies integration. However, it does not remove the need for adapters due to possible heterogeneity among service interfaces and protocols. In this paper, we characterize the problem of Web services adaptation focusing on business interfaces and protocols adapters. Our study shows that many of the differences between business interfaces and protocols are recurring. We introduce mismatch patterns to capture these recurring differences and to provide solutions to resolve them. We leverage mismatch patterns for service adaptation with two approaches: by developing stand-alone adapters and via service modification. We then dig into the notion of adaptation aspects that, following aspect-oriented programming paradigm and service modification approach, allow for rapid development of adapters. We present a study showing that it is a preferable approach in many cases. The proposed approach is implemented in a proof-of-concept prototype tool, and evaluated using both qualitative and quantitative methods.
Legacy systems often contain several crosscutting concerns that could potentially benefit from an aspect-oriented programming implementation. In this paper, we focus on the problem of aspect identification in existing...
详细信息
Legacy systems often contain several crosscutting concerns that could potentially benefit from an aspect-oriented programming implementation. In this paper, we focus on the problem of aspect identification in existing code. The main idea is that use-cases can be defined in order to separate the base logics from the crosscutting concerns to be aspectised. The relationship between the execution traces associated with the use-cases and the executed computational units (class methods) is analysed through concept analysis. The results obtained on some case studies are discussed in the paper.
暂无评论