Weaving aspects into web service orchestrations

Web Service orchestration engines need to be more open to enable the addition of new behaviours into service-based applications. In this paper, we illus- trate how, in a BPEL engine with aspect-weaving ca- pabilities, a process-driven application based on the Google Web Service can be dynamically adapted with new behaviours and hot-fixed to meet unforeseen post- deployment requirements. Business processes (the ap- plication skeletons) can be enriched with additional fea- tures such as debugging, execution monitoring, or an application-specific GUI. Dynamic aspects are also used on the processes themselves to tackle the problem of hot-fixes to long running processes. In this manner, composing a Web Service ’on-the-fly’ means weaving its choreography in- terface into the business process

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow

Financial Liberalisation and Stability of the Financial System in Emerging Markets: the institutional dimension of financial crises

Emerging economies, which have implemented since the end of the 80's a process of financial liberalisation, are confronted at the same time to banking crisis. The latter highlight the role played by the institutional framework in the process of financial liberalisation. The objective of this paper is to go through the usual alternative too much/ too little market in order to explain that the success of any liberalisation process relies on the complementarity between market and intermediation. The point is that the solution to financial instability is to be found within the institutional dynamics in which emerging economies may benefit from intermediation in order to enforce the market process.market and institutions, financial liberalisation, financial crisis, emerging markets

Rewriting Approximations For Properties Verification Over CCS Specifications

This paper presents a way to verify CCS (without renaming) specifications using tree regular model checking. From a term rewriting system and a tree automaton representing the semantics of CCS and equations of a CCS specification to analyse, an over-approximation of the set of reachable terms is computed from an initial configuration. This set, in the framework of CCS, represents an over-approximation of all states (modulo bisimulation) and action sequences the CCS specification can reach. The approach described in this paper can be fully automated. It is illustrated with the Alternating Bit Protocol and with hardware components specifications

Approximations par réécriture pour deux problèmes indécidables

National audiencePour vérifier des propriétés de sûreté ou de (non-)atteignabilité par model-checking régulier, on se concentre sur une modélisation des configurations accessibles du système par des langages réguliers et des relations d'évolution par des systèmes de réécriture. Le problème d'atteignabilité est indécidable dans de nombreux formalismes, et l'approche générale consiste à étudier et/ou à combiner des cas particuliers. Nous nous intéressons à l'approche par approximation pour semi-décider ce problème de vérification. Dans ce papier, nous exploitons l'analyse d'atteignabilité pour deux problèmes indécidables pour les machines de Turing : vacuité d'un langage et appartenance d'un mot à un langage. Nous proposons une modélisation et montrons comment les approximations par réécriture permettent de semi-décider ces problèmes. Cette approche a été implantée et expérimentée

A Model Driven Architecture Framework for Robot Design and Automatic Code Generation

International audienceThis work presents a research and development experiment in software engineering at the IMT Mines Ales, France. The goal is to define a framework allowing a system controller to be graphically designed and its java code to be automatically generated. This framework is expected to be a support for students following the system engineering curriculum, and who have to program LEGO Mindstorms EV3 robots although they have not already been trained to concurrent Java programming. The experimental methodology focuses on learning and implementing the following paradigms: model driven design, software architecture for event driven systems and reactive system programming using JAVA threads. We present the design framework defined during this experiment, and the feedback of students who have been involved in setting up the state of the art and developing the framework

Handling Non Left-Linear Rules When Completing Tree Automata

International audienceThis paper addresses the following general problem of tree regular model-checking: decide whether the intersection of R*(L) and Lp is empty, where R* is the reflexive and transitive closure of a successor relation induced by a term rewriting system R, and L and Lp are both regular tree languages. We develop an automatic approximation-based technique to handle this -- undecidable in general -- problem in the case when term rewriting system rules are non left-linear

Handling Left-Quadratic Rules When Completing Tree Automata

International audienceThis paper addresses the following general problem of tree regular model-checking: decide whether the intersection of R*(L) and Lp is empty, where R* is the reflexive and transitive closure of a successor relation induced by a term rewriting system R, and L and Lp are both regular tree languages. We develop an automatic approximation-based technique to handle this -- undecidable in general -- problem in the case when term rewriting system rules are left-quadratic. The most common practical case is handled this way

Finer is better: Abstraction Refinement for Rewriting Approximations

International audienceTerm rewriting systems are now commonly used as a modeling language for programs or systems. On those rewriting based models, reachability analysis, i.e. proving or disproving that a given term is reachable from a set of input terms, provides an efficient verification technique. For disproving reachability (i.e. proving non reachability of a term) on non terminating and non confluent rewriting models, Knuth-Bendix completion and other usual rewriting techniques do not apply. Using the tree automaton completion technique, it has been shown that the non reachability of a term t can be shown by computing an over-approximation of the set of reachable terms and prove that t is not in the over-approximation. However, when the term t is in the approximation, nothing can be said. In this paper, we improve this approach as follows: given a term t, we try to compute an over-approximation which does not contain t by using an approximation refinement that we propose. If the approximation refinement fails then t is a reachable term. This semi-algorithm has been prototyped in the Timbuk tool. We present some experiments with this prototype showing the interest of such an approach w.r.t. verification on rewriting models

Domain-Driven Development: the SmartTools Software Factory

With the increasing dependency on the Internet and the proliferation of new component and distributive technologies, the design and implementation of complex applications must take into account standards, code distribution, deployment of components and reuse of business logic. To cope with these changes, applications need to be more open, adaptable and capable of evolving. To accommodate to these new challenges, this paper presents a new development approach based on generators associated with domain-specific languages, each of the latter related to one possible concern useful when building an application. It relies on Generative Programming, Component Programming and Aspect-Oriented Programming. A software factory, called SmartTools , has been developed using this new approach. The main results are i) to build software of better quality and to enable rapid development due to Generative Programming and, ii) to facilitate insertion of new facets and the portability of applications to new technologies or platforms due to business logic and technology separation