María Agustina Cibrán

Stateful aspects in JAsCo

Aspects that trigger on a sequence of join points instead of on a single join point are not explicitly supported in current Aspect-Oriented approaches. Explicit protocols are however frequently employed in Component-Based Software Development and business processes and are as such valid targets for aspect application. In this paper, we propose an extension of the JAsCo aspect-oriented programming language for declaratively specifying a protocol fragment. The proposed pointcut language is equivalent to a finite state machine. Advices can be attached to every transition specified in the pointcut protocol. Furthermore, the complement of a protocol can also be used for triggering aspects. The JAsCo tools support the stateful aspects language and implement it very efficiently by employing the JAsCo run-time weaver. As a validation of the approach, we present a case study in the context of reaction business rules.

AOP for Dynamic Configuration and Management of Web Services

Web service technologies accelerate application development by allowing the selection and integration of third-party web services, achieving high modularity, flexibility and configurability. However, current approaches only allow this integration by hard wiring the references to concrete web services into the client applications. Moreover they do not provide any management support, which is fundamental for achieving robustness. We observe the need for the application to be independent of specific services and present the WSML, a management layer placed in between the application and the world of web services. In this paper we identify the requirements for this layer to realise the dynamic selection and integration of services, client-side management of services, and support for rules that govern the selection, integration and composition. We show how dynamic AOP is ideally suited to implement the core functionality of the WSML using the JAsCo dynamic aspect-oriented language to conduct the experiments.

Adaptive programming in JAsCo

In this paper we propose an extension to JAsCo for supporting Adaptive Programming in a Component-Based Software Development context. JAsCo is an aspect-oriented programming language targeted at Component-Based Software Development and allows encapsulating crosscutting concerns using highly reusable aspect beans. Adaptive Programming on the other hand, allows capturing crosscutting concerns by structure-shy adaptive visitors. We propose to implement an adaptive visitor as a regular JAsCo aspect bean. Hence, the reusability of an adaptive visitor is improved because the same visitor can be reused within different component contexts. We introduce JAsCo traversal connectors to deploy adaptive visitors, implemented as JAsCo aspect beans, upon a concrete component traversal. In addition, these traversal connectors allow to explicitly specify how the behavior of several adaptive visitors, instantiated onto the same component traversal, needs to be combined by making use of the JAsCo precedence and combination strategies. A prototype implementation of the JAsCo Adaptive Programming extension, which employs the DJ library, is available. As a proof of concept, we present an extended case study in the context of the Web Service Management Layer (WSML) project. In this case study, a set of visitors implemented in JAsCo is reused to accomplish multiple tasks.

Aspect-Oriented Programming for Dynamic Web Service Monitoring and Selection

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.

Aspect-oriented Programming for Dynamic Web Service Selection, Integration and Management

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.

A slice of MDE with AOP: transforming high-level business rules to aspects

We propose an approach that combines MDE and AOSD to automatically translate high-level business rules to aspects and integrate them with existing object-oriented applications. The separation of rule-based knowledge from the core application as explicit business rules has been the focus of existing approaches. However, they fail at supporting rules that are both high-level, i.e. defined in domain terms, and operational, i.e. automatically executable from the core application. In this paper we propose high-level languages for expressing business rules at the domain level as well as their connections to the core application. We provide support for automatically translating high-level rules to object-oriented programs and their connections to aspects, since these crosscut the core application. Separation of concerns is preserved at the domain and implementation levels, facilitating traceability, reusability and adaptability. A prototype implementation and a discussion on trade-offs are presented.