In service-oriented computing, applications are often created by integrating third-party Web Services. Current integration approaches, however, require client applications to hardcode references to specific Web Servic...
详细信息
In service-oriented computing, applications are often created by integrating third-party Web Services. Current integration approaches, however, require client applications to hardcode references to specific Web Services, thereby affecting adaptability and robustness. Moreover, support for client-side management is rarely provided. To enable the development of more flexible and robust applications, we propose to insert a new layer between the client applications and the Web Services: the Web Services Management Layer (WSML). This layer decouples Web Services from client applications and enables hot-swapping between semantically equivalent Web Services based on availability. This mechanism allows for dynamic switching between Web Services based on selection policies that encapsulate changing business requirements. In addition, with WSML, client-side management concerns (e.g., caching, billing and logging) can be decoupled from the applications. In this paper, we identify a list of requirements for WSML to realize dynamic integration and client-side service management, and provide support for service criteria to govern the selection, integration and composition of Web Services. We also show that dynamic aspect-oriented programming (AOP) is well suited to implement the core functionality of WSML.
aspect-oriented programming (AOP) has emerged recently as a language concept for expressing cross-cutting concerns, mainly in object-oriented software. Since then, the concept has been applied to a wide variety of oth...
详细信息
aspect-oriented programming (AOP) has emerged recently as a language concept for expressing cross-cutting concerns, mainly in object-oriented software. Since then, the concept has been applied to a wide variety of other contexts. In this paper, we explore some cross-cutting concerns for parallel programs of reactive systems: we propose an aspect language, Larissa, and a weaving mechanism, in a core language based on parallel communicating Mealy machines. (c) 2006 Elsevier B.V. All rights reserved.
The world of HPC systems is changing to a more complicated system because the performance improvement of processors has been slowed down. One of the promising approaches is Domain-Specific Language (DSL), which provid...
详细信息
ISBN:
(纸本)9781665497473
The world of HPC systems is changing to a more complicated system because the performance improvement of processors has been slowed down. One of the promising approaches is Domain-Specific Language (DSL), which provides a productive environment to create a high-efficient program without pain. However, existing DSL platforms themselves often lack portability and cost DSL developers great effort. To solve this issue, we propose an aspect-oriented programming (AOP) based DSL constructing platform, enabling developers to build a DSL platform by combining aspect modules. aspect modules manage abstracted application flow, data structure, and memory access on our platform. Therefore, developers can create any DSL platform whose target application has the attributes which HPC applications usually have, the abstraction assumes. This study implemented a prototype platform that can handle MPI and OpenMP layers. The prototype supports three types of applications (Structured-Grid, Unstructured-Grid, and Particle Simulation). Then, we evaluated the overheads caused by achieving flexibility and productivity of the platform.
aspects cut new interfaces through the primary decomposition of a system. This implies that in the presence of aspects, the complete interface of a module can only be determined once the complete configuration of modu...
详细信息
ISBN:
(纸本)9781581139631
aspects cut new interfaces through the primary decomposition of a system. This implies that in the presence of aspects, the complete interface of a module can only be determined once the complete configuration of modules in the system is known. While this may seem anti-modular, it is an inherent property of crosscutting concerns, and using aspect-oriented programming enables modular reasoning in the presence of such concerns.
When developing video-based surveillance systems the developer faces a highly complex task due to the wide range of application domains where video-based surveillance systems are applied. As the number of domains of a...
详细信息
ISBN:
(纸本)9781457704345
When developing video-based surveillance systems the developer faces a highly complex task due to the wide range of application domains where video-based surveillance systems are applied. As the number of domains of application increases, so does the level of variability of non-functional and functional properties that needs to be managed by video-based surveillance systems. The traditional response to make the process of managing all system variations more flexible is to use modular architectures based on filters for video applications. These filters are implemented using dynamic programming techniques (i.e. inheritance and virtual functions) that induce an overhead on the system performance. As each filter is implemented as a plugin, the non-linearity produced by the use of plug-ins penalize the overall system performance due to a increase in the number of cache misses and page faults. In this paper, a novel approach is proposed. The use of aspect-oriented programming (AOP) is proposed to modularize system variability without compromising system performance. All the system variation points are implemented in aspects that are injected for a specific configuration on the common base code related to all configurations. The experimental results show that AOP improves the management of system heterogeneity without sacrificing system performance.
The article examines whether problems that occur specifically during unit testing of object-oriented programs can be solved using the aspect-oriented programming paradigm. It presents the various subproblems step by s...
详细信息
The article examines whether problems that occur specifically during unit testing of object-oriented programs can be solved using the aspect-oriented programming paradigm. It presents the various subproblems step by step, shows conventional solutions, describes aspect-oriented solutions to the problems in a general and language-independent manner, and concludes by looking at the aspect-oriented implementation in the language aspectJ. Parallel to this, we present the test framework FlexTest, which demonstrates the practical implementability of our ideas.
Service levels of a cloud application are application-specific. Mechanisms for delivering and controlling service levels should hence be defined at the same abstraction level as the application itself. In an implement...
详细信息
ISBN:
(纸本)9781467329040;9781467329033
Service levels of a cloud application are application-specific. Mechanisms for delivering and controlling service levels should hence be defined at the same abstraction level as the application itself. In an implementation, this results in an interweaving combination of application logic and service-levels control mechanisms. The application is thus difficult to understand and maintain, i.e., has a low quality. In this paper, we argue that delivering service levels of a cloud application needs a feedback control system. This control system measures system outputs and adjust the system control inputs accordingly, in order to achieve the agreed service levels. Three models of control systems for service levels are identified, i.e., dedicated controller, shared controller, and shared application and controller. This paper investigates an approach to the use of aspect-oriented programming (AOP) in the development of service-levels controllers of cloud applications. In this approach, service-level mechanisms are considered as an aspect of cloud applications that are implemented separately from the application's functional logic. As a result, the application can be expected to have a higher quality.
Many programs have crosscutting concerns for which neither procedural nor object-orientedprogramming adequately modularize, which has led to the idea of aspect-oriented programming (AOP). However, AOP has not found f...
详细信息
ISBN:
(纸本)9781450353892
Many programs have crosscutting concerns for which neither procedural nor object-orientedprogramming adequately modularize, which has led to the idea of aspect-oriented programming (AOP). However, AOP has not found favor with the programming languages community due to a belief that AOP breaks classical modularity and modular reasoning. We propose a new AOP programming model that enables both crosscutting modularity and modular reasoning. This model is implemented by aspectJML, a general-purpose aspect-oriented extension to Java. It supports modular crosscutting concerns using key object-oriented mechanisms, such as hierarchical structure, and allows reasoning that scales to ever-larger programs.
aspect-oriented-programming is a relatively new technique that has evolved on top of the already well-established approach of object-orientedprogramming. When it is used correctly, it promises to remove many redundan...
详细信息
ISBN:
(数字)9783954895397
ISBN:
(纸本)9783954890392
aspect-oriented-programming is a relatively new technique that has evolved on top of the already well-established approach of object-orientedprogramming. When it is used correctly, it promises to remove many redundant parts of a code that appear repeatedly in an application, essentially untangling the original code. Thus, it can lead to a cleaner, more separated software design, to greater modularity and maintainability. Time-savings in software engineering can also be huge cost-savings, and anything that increases software quality is a welcome sight in an industry that in parts, still suffers from a bad reputation concerning the quality of its products. But, used in the wrong way or with insufficient knowledge, aspect-oriented programming can result in the opposite. Unintended side effects may introduce new bugs into an application, and therefore, it may be just one of the many negative consequences. In any case, there is a huge lack of empirical research on the subject, and in software engineering in general. Due to that fact, the question arises in how far hard facts can be drawn. This book deals with part of that problem by evaluating the aspect-oriented approach in a carefully designed and controlled experiment. On the basis of different tasks that were solved by participants of this study, the aspect-oriented approach (represented by aspectJ) is compared with a plain object-oriented approach (represented by Java). The book starts with an introduction to the topic, and further, it provides on the one hand, the survey's motivation and on the other hand, some background information. A short chapter on aspect-oriented programming and empirical research may help readers who are unfamiliar with any of the subjects. Then, the survey itself is described in detail, i.e. its design, its implementation, and its evaluation, followed by a thorough discussion of the results. And the answer to the question 'Can aspect-orientated programming keep its promise in productivity?
暂无评论