Aspect-Oriented Programming for Dynamic Web Service Monitoring and Selection

Abstract. In Service-Oriented Application Development, applications are composed by selecting and integrating third-party web services. To avoid hardwiring concrete services in client applications we introduced in previous work the Web Services Management Layer (WSML) and suggested a redirection mechanism based on Aspect Oriented Programming (AOP). Even though this mechanism enables hot swapping between semantically equivalent services based on their availability, this is not enough to create applications that are driven by business requirements. In this paper we introduce a more advanced selection mechanism that allows dynamic switching between services based on business driven requirements that can change over time. Choosing a service may be done based on cost, presence on approved partners list, as well as binding support, quality of service classifications, historical performance and proximity. We introduce a modular monitoring mechanism that is able to observe these criteria and trigger a more advanced service selection procedure. We show how the AOP language JAsCo with its dynamically pluggable aspects is well suited to achieve this. 1

Aspect-oriented programming beyond dependency injection

Abstract. Dependency injection is a hot topic among industrial developers using component frameworks. This paper first mentions that dependency injection and aspect-oriented programming share the same goal, which is to reduce dependency among components for better reusability. However, existing aspect-oriented programming languages/ frameworks, in particular, AspectJ, are not perfectly suitable for expressing inter-component dependency with a simple and straightforward representation. Their limited kinds of implicit construction of aspect instances (or implementations) cannot fully express inter-component dependency. This paper points out this fact and proposes our aspectoriented programming system named GluonJ to address this problem. GluonJ allows developers to explicitly construct and associate an aspect implementation with aspect targets.

Isolating process-level concerns using Padus

Abstract. Current workflow languages for web services suffer from poor support for separation of concerns. Aspect-oriented software development is a well-known approach to improve this. In this paper, we present an aspect-oriented extension for the WS-BPEL language that improves on current state-of-the-art by introducing an explicit deployment construct, a richer joinpoint model, and a higher-level pointcut language. In addition, the supporting technology is compatible with existing WS-BPEL engines. Classification. Business process modeling and analysis, processes and service composition

An Advice for Advice Composition in AspectJ

Abstract. Aspect composition often involves advice interference and this is a crucial problem in aspect oriented programming. When multiple advices are woven at the same join point, the advices often interfere with each other. Giving appropriate precedence order is a typical solution of this problem but it cannot resolve all kinds of advice interference. To address this problem, we propose a novel language extension named Airia, which provides a new kind of around advice for resolving advice interference. This kind of advice named a resolver is invoked only at the join points when given advices conflict with each other. The resolvers can call an extended version of proceed, which takes as an argument precedence order among remaining advices. Furthermore, the resolvers are composable. They can be used to resolve interference among other resolvers and advices.

A Model for Developing Component-Based and Aspect-Oriented Systems

Abstract. Aspect-Oriented Programming (AOP) and Component-Based Software Engineering (CBSE) offer solutions to improve the separation of concerns and to enhance a program structure. If the integration of AOP into CBSE has already been proposed, none of these solutions focus on the application of CBSE principles to AOP. In this paper we propose a twofold integration of AOP and CBSE. We introduce a general model for components and aspects, named Fractal Aspect Component (FAC). FAC decomposes a software system into regular components and aspect components (ACs), where an AC is a regular component that embodies a crosscutting concern. We reify the aspect domain of an AC and the relationship between an AC and a component, called an aspect binding, as first-class runtime entities. This clarifies the architecture of a system where components and aspects coexist. The system can evolve from the design to the execution by adding or removing components, aspects or bindings.

A Component Model Engineered with Components and Aspects

Abstract. This paper presents AOKell, a framework for engineering component-based systems. This framework implements the Fractal model, a hierarchical and dynamic component model. The novelty of this paper lies in the presentation of AOKell, an implementation of the Fractal model with aspects. Two dimensions can be isolated with Fractal: the functional dimension, which is concerned with the definition of application components, and the control dimension, which is concerned with the technical services (e.g. lifecycle, binding, persistence, etc.) that manage components. The originality of AOKell is, first, to provide an aspect-oriented approach to integrate these two dimensions, and second, to apply a component-based approach for engineering the control dimension. Hence, AOKell is a reflective component framework where application components are managed by other, so-called, control components and where aspects glue together application components and control components.

Property-preserving evolution of components using VPA-based aspects

Abstract. Protocols that govern the interactions between software components are a popular means to support the construction of correct component-based systems. Previous studies have, however, almost exclusively focused on static component systems that are not subject to evolution. Evolution of component-based systems with explicit interaction protocols can be defined quite naturally using aspects (in the sense of AOP) that modify component protocols. A major question then is whether aspect-based evolutions preserve fundamental correctness properties, such as compatibility and substitutability relations between software components. In this paper we discuss how such correctness properties can be proven in the presence of aspect languages that allow to match traces satisfying interaction protocols and enable limited modifications to protocols. We show how common evolutions of distributed components can be modeled using VPA-based aspects [14] and be proven correct directly in terms of properties of operators of the aspect language. We first present several extensions to an existing language for VPA-based aspects that facilitate the evolution of component systems. We then discuss different proof techniques for the preservation of composition properties of componentbased systems that are subject to evolution using protocol-modifying aspects.