We address the problem of synthesizing specifications for composite
Web services, starting from those of their component services.
Unlike related work in programming languages, we assume the
definition of the component services (i.e. their code) to be
unavailable --- at best, they are known by a specification which
(safely) approximates their functional behavior. Within this
scenario, we deduce general formula schemes to derive specifications
for basic constructs such as sequential, parallel compositions and
conditionals and provide details on how to handle the special cases of
loops and asynchronous execution. The resulting specifications facilitate
service verification and service evolution as well as auditing processes,
promoting trust between the involved partners.
Towards Realizing Dynamic QoS-aware Web Service CompositionGeorge Baryannis
In this presentation, we identify two major issues related to Web service composition: the lack of formal specifications for services and service compositions and the inability of current service composition approaches to support dynamicity and QoS-awareness in an effective and scalable way. We analyze the underlying research challenges for each of these issues and propose a tentative research plan to address them.
Fluent Calculus-based Semantic Web Service Composition and Verification using...George Baryannis
We propose a composition and verification framework for Semantic Web Services specified using WSSL, a novel service specification language based on the fluent calculus, that addresses issues related to the frame, ramification and qualification problems. These deal with the succinct and flexible representation of non-effects, indirect effects and preconditions, respectively. The framework exploits the unique features of WSSL, allowing, among others, for: compositions that take into account ramifications of services; determining the feasibility of a composition a priori; and considering exogenous qualifications during the verification process. The framework is implemented using FLUX-based planning, supporting compositions with fundamental control constructs, including nondeterministic ones such as conditionals and loops. Performance is evaluated with regard to termination and execution time for increasingly complex synthetic compositions.
A quick overview of a large application integration project I just wrapped up where we use a service approach to integrate 50 interfaces from 23 applications.
At least check out the diagrams and lessons learned at the end.
Web Service Composition as a Planning Task: Experiments using Knowledge-Based...Erick Ornio
Motivated by the problem of automated Web service composition (WSC), we present some empirical evidence to validate the effectiveness of using knowledge-based planning techniques for solving WSC problems. In our experiments we utilize the PKS (Planning with Knowledge and Sensing) planning system which is derived from a generalization of STRIPS. In PKS, the agent’s (incomplete) knowledge is represented by a set of databases and actions are modelled as revisions to the agent’s knowledge state rather than the state of the world. We argue that, despite the intrinsic limited expressiveness of this approach, typical WSC problems can be specified and solved at the knowledge level. We show that this approach scales relatively well under changing conditions (e.g. user constraints). Finally, we discuss implementation issues and propose some architectural guidelines within the context of an agent-oriented framework for inter-operable, intelligent, multi-agent systems for WSC and provisioning.
Towards Realizing Dynamic QoS-aware Web Service CompositionGeorge Baryannis
In this presentation, we identify two major issues related to Web service composition: the lack of formal specifications for services and service compositions and the inability of current service composition approaches to support dynamicity and QoS-awareness in an effective and scalable way. We analyze the underlying research challenges for each of these issues and propose a tentative research plan to address them.
Fluent Calculus-based Semantic Web Service Composition and Verification using...George Baryannis
We propose a composition and verification framework for Semantic Web Services specified using WSSL, a novel service specification language based on the fluent calculus, that addresses issues related to the frame, ramification and qualification problems. These deal with the succinct and flexible representation of non-effects, indirect effects and preconditions, respectively. The framework exploits the unique features of WSSL, allowing, among others, for: compositions that take into account ramifications of services; determining the feasibility of a composition a priori; and considering exogenous qualifications during the verification process. The framework is implemented using FLUX-based planning, supporting compositions with fundamental control constructs, including nondeterministic ones such as conditionals and loops. Performance is evaluated with regard to termination and execution time for increasingly complex synthetic compositions.
A quick overview of a large application integration project I just wrapped up where we use a service approach to integrate 50 interfaces from 23 applications.
At least check out the diagrams and lessons learned at the end.
Web Service Composition as a Planning Task: Experiments using Knowledge-Based...Erick Ornio
Motivated by the problem of automated Web service composition (WSC), we present some empirical evidence to validate the effectiveness of using knowledge-based planning techniques for solving WSC problems. In our experiments we utilize the PKS (Planning with Knowledge and Sensing) planning system which is derived from a generalization of STRIPS. In PKS, the agent’s (incomplete) knowledge is represented by a set of databases and actions are modelled as revisions to the agent’s knowledge state rather than the state of the world. We argue that, despite the intrinsic limited expressiveness of this approach, typical WSC problems can be specified and solved at the knowledge level. We show that this approach scales relatively well under changing conditions (e.g. user constraints). Finally, we discuss implementation issues and propose some architectural guidelines within the context of an agent-oriented framework for inter-operable, intelligent, multi-agent systems for WSC and provisioning.
Abstract—Composing a scientific workflow from scratch may be time-consuming, even if the scientist is fully aware of the semantics, the inputs, and the outputs of the expected workflow.
Reusing existing services and parts from already composed workflows can aid in reducing the total workflow composition time. However, matching the semantics and the inputs and outputs of these reusable components manually is not an easy task, especially when there are hundreds of such components available. Even components are annotated with information on the semantics of their inputs and outputs, the complex nature of the semantic languages may make manual component selection even harder. In this paper, we propose a Case-Based Reasoning (CBR) approach to assist composition of workflows based on the characteristics of the inputs and the outputs of the reusable workflow components, facilitating user exploitation of existing services and workflows during workflow composition. The architecture can also be extended to utilize the semantics of the various components improving the precision of the identified reusable components.
An overview of standards and related technology in web servicesPapa Cheikh Cisse
Ce document présente brièvement des standards et autre normes des Services Web. Pour cela, il expose d'abord le concept de Service Web en parlant de son modèle et des avantages. Ensuite, il énonce des technologies telles que le triplet WSDL/UDDI/SOAP et ebXML. Enfin, une conclusion est faite après avoir fait ressortir les défis techniques rencontrés dans l'implémentation des Services Web.
Towards Logic Programming as a Service: Experiments in tuPrologAndrea Omicini
In this talk we explore the perspective of Logic Programming as a Service (LPaaS), with a broad notion of “service” going beyond the mere handling of the logic engine lifecycle, knowledge base management, reasoning queries execution, etc. In particular, we present tuProlog as-a-service, a Prolog engine based on the tuProlog core made available as an encapsulated service to effectively support the spreading of intelligence in pervasive systems—mainly, Internet-of-Things (IoT) applications scenarios. So, after recalling the main features of tuProlog technology, we discuss the design and implementation of tuProlog as-a-service, focussing in particular on the iOS platform because of the many supported smart devices (phones, watches, etc.), the URL-based communication support among apps, and the multi-language resulting scenarios.
WUD2010 Sophia 05 - B. Caramel (UNICE/CNRS) : Composition d'applications inte...Use Age
WUD (World Usability Day 2010 à Sophia Antipolis organisé par Use Age)
Partie 05 - B. Caramel (UNICE/CNRS) : "Composition d'applications interactives : et l’utilisateur dans tout ça?"
Plus d'infos en: http://www.use-age.org/journee-mondiale-de-l-utilisabilite/wud-2010
Case-based reasoning (CBR) classifiers use a database of problem solutions to solve
new problems. Unlike nearest-neighbor classifiers, which store training tuples as points
in Euclidean space, CBR stores the tuples or “cases” for problem solving as complex
symbolic descriptions.
Présentation sur les ontologie :
le concept de base, les langages, et les applications dans les différents domaines.
Exposé présenté par Benouini Rachid dans FST Fès 2014-2015.
Abstract—Composing a scientific workflow from scratch may be time-consuming, even if the scientist is fully aware of the semantics, the inputs, and the outputs of the expected workflow.
Reusing existing services and parts from already composed workflows can aid in reducing the total workflow composition time. However, matching the semantics and the inputs and outputs of these reusable components manually is not an easy task, especially when there are hundreds of such components available. Even components are annotated with information on the semantics of their inputs and outputs, the complex nature of the semantic languages may make manual component selection even harder. In this paper, we propose a Case-Based Reasoning (CBR) approach to assist composition of workflows based on the characteristics of the inputs and the outputs of the reusable workflow components, facilitating user exploitation of existing services and workflows during workflow composition. The architecture can also be extended to utilize the semantics of the various components improving the precision of the identified reusable components.
An overview of standards and related technology in web servicesPapa Cheikh Cisse
Ce document présente brièvement des standards et autre normes des Services Web. Pour cela, il expose d'abord le concept de Service Web en parlant de son modèle et des avantages. Ensuite, il énonce des technologies telles que le triplet WSDL/UDDI/SOAP et ebXML. Enfin, une conclusion est faite après avoir fait ressortir les défis techniques rencontrés dans l'implémentation des Services Web.
Towards Logic Programming as a Service: Experiments in tuPrologAndrea Omicini
In this talk we explore the perspective of Logic Programming as a Service (LPaaS), with a broad notion of “service” going beyond the mere handling of the logic engine lifecycle, knowledge base management, reasoning queries execution, etc. In particular, we present tuProlog as-a-service, a Prolog engine based on the tuProlog core made available as an encapsulated service to effectively support the spreading of intelligence in pervasive systems—mainly, Internet-of-Things (IoT) applications scenarios. So, after recalling the main features of tuProlog technology, we discuss the design and implementation of tuProlog as-a-service, focussing in particular on the iOS platform because of the many supported smart devices (phones, watches, etc.), the URL-based communication support among apps, and the multi-language resulting scenarios.
WUD2010 Sophia 05 - B. Caramel (UNICE/CNRS) : Composition d'applications inte...Use Age
WUD (World Usability Day 2010 à Sophia Antipolis organisé par Use Age)
Partie 05 - B. Caramel (UNICE/CNRS) : "Composition d'applications interactives : et l’utilisateur dans tout ça?"
Plus d'infos en: http://www.use-age.org/journee-mondiale-de-l-utilisabilite/wud-2010
Case-based reasoning (CBR) classifiers use a database of problem solutions to solve
new problems. Unlike nearest-neighbor classifiers, which store training tuples as points
in Euclidean space, CBR stores the tuples or “cases” for problem solving as complex
symbolic descriptions.
Présentation sur les ontologie :
le concept de base, les langages, et les applications dans les différents domaines.
Exposé présenté par Benouini Rachid dans FST Fès 2014-2015.
Continuous Integration and Continuous Delivery to Facilitate Web Service TestingCognizant
Quality assurance (QA) organizations can dramatically upgrade web services testing by applying continuous integration and continuous delivery/deployment (CI/CD) techniques derived from DevOps and by deploying software such as Jenkins, LISA, Maven, Cucumber and Gherkin.
GASCO required a middleware solution to integrate its various IT applications across the board in real-time, having over 10,000+ users geo dispersed across KSA.
Addvantum suggested and implemented a host of Oracle middleware applications including Weblogic Suite, SOA Suite, Oracle Applications Adapter, SOA Management Pack, Web Logic Management Pack, Enterprise Service Bus and Oracle Enterprise Gateway.
Creating a Centralized Consumer Profile Management Service with WebSphere Dat...Prolifics
In this presentation will talk about how one of the world's leading Financial Institutions, leveraged WebSphere DataPower to provide a set of centralized consumer profile management services. This central service would be leveraged by internal and external applications, and would align with enterprise marketing capabilities. The solution included a complex security model which included the following products: Tivoli Directory Server, Tivoli Access Manager and Tivoli Federated Identity Manager. We will describe how to build complex orchestrations in WebSphere DataPower, and also go through some of the performance tuning options we implemented to achieve a high degree of efficiency.
What Is Angular 2 | Angular 2 Tutorial For Beginners | Angular Training | Edu...Edureka!
This Edureka "What is Angular 2" tutorial will help you understand all the basics of Angular 2. Learn Angular 2 and Typescript to develop highly scalable, fast, and testable web client-side applications. Below are the topics covered in this tutorial:
1) Evolution of Web Development
2) What is AngularJS?
3) Angular 2 Features
4) Components of Angular 2
5) Angular 2 Architecture
6) Angular 2 Program Components
7) Your First Angular 2 program
8) Angular 2 Applications
Subscribe to our channel to get updates. Check our complete Angular playlist here: https://goo.gl/09KsDC
PREDICTING PERFORMANCE OF WEB SERVICES USING SMTQA cscpconf
Web Service is an interface which implements business logic. Performance is an important quality aspect of Web services because of their distributed nature. Predicting the performance of web services during early stages of software development is significant. In this paper we model web service using Unified Modeling Language, Use Case Diagram, Sequence Diagram. We obtain the Performance metrics by simulating the web services model using a simulation tool Simulation of Multi-Tier Queuing Architecture. We have identified the bottle neck resources
Impact 2008 1994A - Exposing services people want to consume: a model-driven ...Brian Petrini
Where did my SOA budget go? I just spent 80% of it on integration and I still haven't got an SOA! We used to call it Enterprise Application Integration (EAI), now we call it service exposition. EAI is still there, it's still hard, and it still takes the vast majority of implementation time on SOA projects. Most companies hadn't finished their EAI when SOA came along. This session discusses how to capture and model the true complexity of an integration interface, and how to relate that to product capabilities. We'll show new techniques for how models can be used to improve estimating, aid product selection, assist designers with common integration patterns, and ultimately generate artifacts. We will discuss common integration patterns such as re-tries, healthcheck, flow control, store-forward, event sequencing and note how these are typically achieved using the current product suite, with particular reference to products such as WebSphere Process Server and WebSphere ESB.
A Trajectory Calculus for Qualitative Spatial Reasoning Using Answer Set Prog...George Baryannis
Spatial information is often expressed using qualitative terms such as natural language expressions instead of coordinates; reasoning over such terms has several practical applications, such as bus routes planning. Representing and reasoning on trajectories is a specific case of qualitative spatial reasoning that focuses on moving objects and their paths. In this work, we propose two versions of a trajectory calculus based on the allowed properties over trajectories, where trajectories are defined as a sequence of non-overlapping regions of a partitioned map. More specifically, if a given trajectory is allowed to start and finish at the same region, 6 base relations are defined (TC-6). If a given trajectory should have different start and finish regions but cycles are allowed within, 10 base relations are defined (TC-10). Both versions of the calculus are implemented as ASP programs; we propose several different encodings, including a generalised program capable of encoding any qualitative calculus in ASP. All proposed encodings are experimentally evaluated using a real-world dataset. Experiment results show that the best performing implementation can scale up to an input of 250 trajectories for TC-6 and 150 trajectories for TC-10 for the problem of discovering a consistent configuration, a significant improvement compared to previous ASP implementations for similar qualitative spatial and temporal calculi.
Rule-based Real-Time Activity Recognition in a Smart Home EnvironmentGeorge Baryannis
This presentation outlines a rule-based approach for both offline and real-time recognition of Activities of Daily Living (ADL), leveraging events produced by a non-intrusive multi-modal sensor infrastructure deployed in a residential environment. Novel aspects of the approach include: the ability to recognise arbitrary scenarios of complex activities
using bottom-up multi-level reasoning, starting from sensor events at the lowest level; an effective heuristics-based method for distinguishing between actual and ghost images in video data; and a highly accurate indoor localisation approach that fuses different sources of location information. The proposed approach is implemented as a rule-based system
using Jess and is evaluated using data collected in a smart home environment. Experimental results show high levels of accuracy and performance,proving the effectiveness of the approach in real world setups.
A Novel Specification and Composition Language for ServicesGeorge Baryannis
Service-Oriented Architecture (SOA) has emerged as a prominent design style that enables an IT infrastructure to allow different applications to participate in business processes, regardless of their underlying features. In order to effectively discover and use the most suitable services, service description should provide a complete behavior model, describing the inputs and preconditions that are required before execution, as well as the outputs and effects of a successful execution. Such specifications are prone to a family of problems, known in the AI literature as the frame, ramification and qualification problems. These problems deal with the succinct and flexible representation of non-effects, indirect effects and preconditions, respectively. Research in services has largely ignored these problems, at the same time ignoring their effects, such as compromising the integrity and correctness of services and service compositions and the inability to provide justification for unexpected execution results.
To address these issues, this thesis proposes the Web Service Specification Language (WSSL), a novel, semantics-aware language for the specification and composition of services, independent of service design models. WSSL's foundation is the fluent calculus, a specification language for robots that offers solutions to the frame, ramification and qualification problems. Further language extensions achieve three major goals: realize service composition via planning, supporting non-deterministic constructs, such as conditionals and loops; include specification of QoS profiles; and support partially observable service states. Moreover, an innovative service composition and verification framework is implemented, that advances state-of-the-art by satisfying several desirable requirements simultaneously: ramifications and partial observability in service and goal modeling; non-determinism in composition schemas; dynamic binding of tasks to concrete services; explanations for unexpected behavior; QoS-awareness through pruning and ranking techniques based on heuristics and task-specific goals and an all-encompassing QoS aggregation method for global goals.
Experimental evaluation is performed using synthetically generated specifications and composition goals, investigating performance scalability in terms of execution time, as well as optimality with regard to the produced composite process. The results show that, even in the presence of ramifications in some specifications, functional planning is efficient for repositories up to 500 specifications. Also, the cost of functional discovery per single service is insignificant, hence achieving good performance even when executed for multiple candidate plans. Finally, optimality relies mainly on defining suitable problem-specific heuristics; thus, its success depends mostly on the expertise of the composition designer.
WSSL: A Fluent Calculus-based Language for Web Service SpecificationsGeorge Baryannis
In order to effectively discover and invoke a Web service, the provider must supply a complete specification of its behavior, with regard to its inputs and outputs, preconditions and effects. Devising such complete specifications comes with many issues that have not been adequately addressed by current service description efforts, such as WSDL, SAWSDL, OWL-S and WSMO. These issues involve the frame, ramification and qualification problems, which deal with the succinct and flexible representation of non-effects, indirect effects and preconditions, respectively. We propose WSSL, a novel specification language for services based on the fluent calculus, that is expressly designed to address the aforementioned issues. Also, a tool is implemented that translates WSSL specifications to FLUX programs and allows for service validation based on user-defined goals.
Lifecycle Management of Service-based Applications on Multi-Clouds: A Resear...George Baryannis
We identify current challenges in the deployment
of complex distributed applications on multiple Cloud
providers and review the state of the art in model-driven
Cloud software engineering. Challenges include lack of support
for heterogeneous Cloud providers; limited matchmaking
between application requirements and Cloud capabilities;
lack of meaningful cross-platform Cloud resource descriptions;
lack of lifecycle management of Cloud applications;
inadequate cross-layer monitoring and adaptation based
on event correlation; and others. In this paper we propose
solutions to these challenges and highlight the expected benefits
in the context of a complex distributed application.
We address the problem of synthesizing specifications for composite
Web services, starting from those of their component services.
Unlike related work in programming languages, we assume the
definition of the component services (i.e. their code) to be
unavailable --- at best, they are known by a specification which
(safely) approximates their functional behavior. Within this
scenario, we deduce general formula schemes to derive specifications
for basic constructs such as sequential, parallel compositions and
conditionals and provide details on how to handle the special cases of
loops and asynchronous execution. The resulting specifications facilitate
service verification and service evolution as well as auditing processes,
promoting trust between the involved partners.
Deriving Specifications for Composite Web Services
1. Deriving Specifications for
Composite Web Services
George Baryannis1, Manuel Carro2 and Dimitris Plexousakis1
gmparg@csd.uoc.gr manuel.carro@imdea.org dp@csd.uoc.gr
1Department of Computer Science, University of Crete, and
Institute of Computer Science, FORTH, Greece
2School of Computer Science, Universidad Politécnica de Madrid, and
IMDEA Software Institute, Madrid, Spain
Izmir, Turkey
2. Outline
Introduction
• Web Services and Formal Specification
• The Need for Service Specifications
• The Special Case of Services
Deriving Composite Service Specifications
• Motivating Example
• Specification Semantics
• Calculating Pre- and Post- Conditions
Handling Special Cases
• Loops
• Asynchronous Execution
Conclusions & Future Work
2
3. Web Services and Formal Specification (1)
• In recent years a multitude of ways of delivering
applications via the Web have been proposed
– Traditional SOAP-based Web Services
• Semantic Web Services
– RESTful Web Services
• Web APIs
• Linked Data Services (LIDS)
• Regardless of their characteristics, all Web
services need to be described, in order to be
discovered and, possibly, composed.
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 3
4. Web Services and Formal Specification (2)
• Web Service Description deals with specifying all
the information needed to access and use a
service
– Should contain both functional and non-functional
aspects
– May contain information on the internal processes of
the service (especially if it is a composite service)
– Should be written in a formal, well-defined
specification language to allow for automated
processing and verification
– Should facilitate the discovery and composition of
services
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 4
5. The Need for Service Specifications (1)
• Service specifications can be employed for
– Constructing a service based on a set of
requirements, provided as a specification
– Checking conformance of an existing service to a
specification agreed upon by the parties involved,
promoting trust between digital society partners
– Auditing processes that check third party or
legacy code conformance
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 5
6. The Need for Service Specifications (2)
• Service specifications can be employed for
– Verification techniques: checking whether a
service satisfies a property (e.g. termination or
temporal ordering of actions)
– Evaluation of the results of service adaptation or
service evolution
– Detecting inconsistencies in a composite service
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 6
7. The Special Case of Services
• The case of services introduces special characteristics
– We cannot rely on the implementation, as is common in
e.g. programming specifications
– Any service is only known through its specification
– A composite service is characterized by its composition
schema
• Existing service description and composition
frameworks don’t address the problem of
automatically producing specifications for a composite
service
– At best, they support some kind of description of atomic
services, as well as a description of the composition
schema
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 7
8. Outline
Introduction
• Web Services and Formal Specification
• The Need for Service Specifications
• The Special Case of Services
Deriving Composite Service Specifications
• Motivating Example
• Specification Semantics
• Calculating Pre- and Post- Conditions
Handling Special Cases
• Loops
• Asynchronous Execution
Conclusions & Future Work
8
9. Motivating Example (1)
• Employing services in order to facilitate the
process of obtaining government-issued
documents
– Users login to the system and fill in a request form
– Some documents require a fee, so a payment
form may need to be filled in too
– The payment process is executed only after both
forms are complete and valid
– In some cases, the resulting documents need to
be digitally certified
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 9
10. Motivating Example (2)
• Initially, we have composite service S1, implemented
according to specification T1.
• T1 is augmented to T2 in order to include the capability of
document certification
• S1 evolves to S2 in order to meet the new requirements
• We need to derive the specification for S2 in order to check
if it conforms to T2
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 10
12. Specification Semantics
• A service specification with preconditions P and
postconditions Q, can be expressed in first-order logic
as:
– si and so denote the states before and after execution of
the particular service respectively
– x and y are vector variables representing the input fed to
the service and the returned output
– P and Q can be expected to be safe approximations of the
actual code specifications
• Given similar specifications for the services
participating in a composition, we want to construct an
equivalent specification for the composite service as a
whole
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 12
13. Proposed Method
• Our approach involves characterizing the meaning of all
fundamental control constructs used in a composition
– by means of the preconditions and postconditions of the
composed services
• Using this characterization we propose a derivation process
based on structural induction
– The composite specification is constructed using a bottoms-up
approach
– Produces specifications syntactically similar to those of the
constituent services, to facilitate recursive reasoning
– Relies on the availability of the composition schema (e.g. from
the BPEL document of the composite service)
– Applicable to any block-structured process, or graph-based ones
that can be transformed to block-structured equivalents
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 13
14. Calculating Pre- And Post-Conditions (1)
Sequence
• a, b and c denote the states before the execution of
A, after A and before B and after the execution of B.
• z contains all input variables for B, including any
ones that are not produced as an output of A (they are
routed through A)
• Based on the individual specifications, we deduce
the following:
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 14
15. Calculating Pre- And Post-Conditions (2)
AND-Split/AND-Join
• The diverging branches execute concurrently and both
activities need to complete
• The derived specification is:
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 15
16. Calculating Pre- And Post-Conditions (3)
OR-Split/OR-Join
• Not all of the branches are necessarily activated and there is
no need for synchronization at the merging stage
• The derived specification is:
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 16
17. Calculating Pre- And Post-Conditions (4)
XOR-Split/XOR-Join
• Only one of the diverging branches is to be executed each
time and is the only one to provide results
• The derived specification is:
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 17
18. Calculating Pre- And Post-Conditions (5)
Conditional Constructs
• The truth value of condition C determines which of A and B is
going to be executed The derived specification is:
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 18
19. Calculating Pre- And Post-Conditions (6)
Conditional Constructs
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 19
20. Back to the Motivating Example
• Using the specifications calculated previously, we gradually derive
the following specification for this example composite process :
20
21. Outline
Introduction
• Web Services and Formal Specification
• The Need for Service Specifications
• The Special Case of Services
Deriving Composite Service Specifications
• Motivating Example
• Specification Semantics
• Calculating Pre- and Post- Conditions
Handling Special Cases
• Loops
• Asynchronous Execution
Conclusions & Future Work
21
22. Current Results
The Case of Loops (1)
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 22
23. Current Results
The Case of Loops (2)
• Generating loop invariants is once again affected by the
special characteristics of services
– Any generated invariant can only be an approximation of
the invariant that would be produced based on the actual
loop code
– Stronger approximations are required to derive a useful
precondition (one that disallows invalid executions)
– Weaker approximations are required to derive a useful
postcondition (one that doesn’t leave out any execution
results)
– Existing loop invariant generation methods can be
employed (provided they are static, i.e. they don’t depend
on information gathered by executing the service) but
need to be adapted to take into account the above points.
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 23
24. Current Results
The Case of Asynchronous Execution
• The client invokes a service, but does not wait for the
response
– Precondition evaluation is not affected
– Postconditions must be expressed and evaluated in the
same context as the corresponding preconditions
• To deal with asynchronous execution, we employ the
Static Single Assignment (SSA) form
– There is exactly one assignment for each distinct variable
name
– For any further assignment, variable renaming is
employed, so that a history of all previous values is kept
• e.g. if we want to modify the value of variable y, a new variable, y1,
is created to represent the new value.
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 24
25. Outline
Introduction
• Web Services and Formal Specification
• The Need for Service Specifications
• The Special Case of Services
Deriving Composite Service Specifications
• Motivating Example
• Specification Semantics
• Calculating Pre- and Post- Conditions
Handling Special Cases
• Loops
• Asynchronous Execution
Conclusions & Future Work
25
26. Conclusions
• This work offers a method to derive composite
specifications given a composition schema
and the specifications of the participating
services
• The derivation is based on structural induction
and a set of rules defined for fundamental
control constructs
• Guidelines to handle the cases of loops and
asynchronous execution are also provided
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 26
27. Future Work
• An implementation of the proposed approach is
currently underway
• Further issues involve exploring loop invariant
generation techniques and applying simplification
techniques to the derived specifications
• The work is planned to be integrated in a novel
specification language for Web services and
service compositions, focusing on eliminating the
well-known frame, ramification and qualification
problems
Deriving Specifications for Composite Web Services George Baryannis, Manuel Carro and Dimitris Plexousakis 27
28. Questions
A Novel Language for the Specification of Web Services and Service Compositions George Baryannis 28