2,836 research outputs found
Issues about the Adoption of Formal Methods for Dependable Composition of Web Services
Web Services provide interoperable mechanisms for describing, locating and
invoking services over the Internet; composition further enables to build
complex services out of simpler ones for complex B2B applications. While
current studies on these topics are mostly focused - from the technical
viewpoint - on standards and protocols, this paper investigates the adoption of
formal methods, especially for composition. We logically classify and analyze
three different (but interconnected) kinds of important issues towards this
goal, namely foundations, verification and extensions. The aim of this work is
to individuate the proper questions on the adoption of formal methods for
dependable composition of Web Services, not necessarily to find the optimal
answers. Nevertheless, we still try to propose some tentative answers based on
our proposal for a composition calculus, which we hope can animate a proper
discussion
Comprehensive Monitor-Oriented Compensation Programming
Compensation programming is typically used in the programming of web service
compositions whose correct implementation is crucial due to their handling of
security-critical activities such as financial transactions. While traditional
exception handling depends on the state of the system at the moment of failure,
compensation programming is significantly more challenging and dynamic because
it is dependent on the runtime execution flow - with the history of behaviour
of the system at the moment of failure affecting how to apply compensation. To
address this dynamic element, we propose the use of runtime monitors to
facilitate compensation programming, with monitors enabling the modeller to be
able to implicitly reason in terms of the runtime control flow, thus separating
the concerns of system building and compensation modelling. Our approach is
instantiated into an architecture and shown to be applicable to a case study.Comment: In Proceedings FESCA 2014, arXiv:1404.043
Recovery within long running transactions
As computer systems continue to grow in complexity, the possibilities of failure increase. At the
same time, the increase in computer system pervasiveness in day-to-day activities brought along
increased expectations on their reliability. This has led to the need for effective and automatic error
recovery techniques to resolve failures. Transactions enable the handling of failure propagation
over concurrent systems due to dependencies, restoring the system to the point before the failure
occurred. However, in various settings, especially when interacting with the real world, reversal
is not possible. The notion of compensations has been long advocated as a way of addressing this
issue, through the specification of activities which can be executed to undo partial transactions.
Still, there is no accepted standard theory; the literature offers a plethora of distinct formalisms
and approaches.
In this survey, we review the compensations from a theoretical point of view by: (i) giving a
historic account of the evolution of compensating transactions; (ii) delineating and describing a
number of design options involved; (iii) presenting a number of formalisms found in the literature,
exposing similarities and differences; (iv) comparing formal notions of compensation correctness;
(v) giving insights regarding the application of compensations in practice; and (vi) discussing
current and future research trends in the area.peer-reviewe
Reasoning About a Service-oriented Programming Paradigm
This paper is about a new way for programming distributed applications: the
service-oriented one. It is a concept paper based upon our experience in
developing a theory and a language for programming services. Both the
theoretical formalization and the language interpreter showed us the evidence
that a new programming paradigm exists. In this paper we illustrate the basic
features it is characterized by
Static vs Dynamic SAGAs
SAGAs calculi (or simply SAGAs) have been proposed by Bruni et al. as a model for long-running transactions. The approach therein can be considered static, while a dynamic approach has been proposed by Lanese and Zavattaro. In this paper we first extend both static SAGAs (in the centralized interruption policy) and dynamic SAGAs to deal with nesting, then we compare the two approaches
Using formal methods to develop WS-BPEL applications
In recent years, WS-BPEL has become a de facto standard language for orchestration of Web Services. However, there are still some well-known difficulties that make programming
in WS-BPEL a tricky task. In this paper, we firstly point out major loose points of the WS-BPEL specification by means of many examples, some of which are also exploited
to test and compare the behaviour of three of the most known freely available WS-BPEL engines. We show that, as a matter of fact, these engines implement different
semantics, which undermines portability of WS-BPEL programs over different platforms. Then we introduce Blite, a prototypical orchestration language equipped with a formal
operational semantics, which is closely inspired by, but simpler than, WS-BPEL. Indeed, Blite is designed around some of WS-BPEL distinctive features like partner links, process termination, message correlation, long-running business transactions and compensation handlers. Finally, we present BliteC, a software tool supporting a rapid and easy development of WS-BPEL applications via translation of service orchestrations written in Blite into executable WS-BPEL programs. We illustrate our approach by means of a running example borrowed from the official specification of WS-BPEL
A compensating transaction example in twelve notations
The scenario of business computer systems changed with the advent of cross-entity computer interactions: computer systems no longer had the limited role of storing and processing data, but became themselves the players which actuated real-life actions. These advancements rendered the traditional transaction mechanism insufficient to deal with these new complexities of longer multi-party transactions. The concept of compensations has long been suggested as a solution, providing the possibility of executing ācounterā-actions which semantically undo previously completed actions in case a transaction fails. There are numerous design options related to compensations particularly when deciding the strategy of ordering compensating actions. Along the years, various models which include compensations have emerged, each tackling in its own way these options. In this work, we review a number of notations which handle compensations by going through their syntax and semantics ā highlighting the distinguishing features ā and encoding a typical compensating transaction example in terms of each of these notations.peer-reviewe
Precise Modelling of Compensating Business Transactions and its Application to BPEL
We describe the StAC language which can be used to specify the orchestration of activities in long running business transactions. Long running business transactions use compensation to cope with exceptions. StAC supports sequential and parallel behaviour as well as exception and compensation handling. We also show how the B notation may be combined with StAC to specify the data aspects of transactions. The combination of StAC and B provides a rich formal notation which allows for succinct and precise specification of business transactions. BPEL is an industry standard language for specifying business transactions and includes compensation constructs. We show how a substantial subset of BPEL can be mapped to StAC thus demonstrating the expressiveness of StAC and providing a formal semantics for BPEL
- ā¦