Results 1 - 10
of
59
A calculus for orchestration of web services.
- In Proc. of ESOP’07,
, 2007
"... Abstract Service-oriented computing, an emerging paradigm for distributed computing based on the use of services, is calling for the development of tools and techniques to build safe and trustworthy systems, and to analyse their behaviour. Therefore, many researchers have proposed to use process ca ..."
Abstract
-
Cited by 75 (19 self)
- Add to MetaCart
(Show Context)
Abstract Service-oriented computing, an emerging paradigm for distributed computing based on the use of services, is calling for the development of tools and techniques to build safe and trustworthy systems, and to analyse their behaviour. Therefore, many researchers have proposed to use process calculi, a cornerstone of current foundational research on specification and analysis of concurrent, reactive, and distributed systems. In this paper, we follow this approach and introduce C WS, a process calculus expressly designed for specifying and combining service-oriented applications, while modelling their dynamic behaviour. We show that C WS can model all the phases of the life cycle of service-oriented applications, such as publication, discovery, negotiation, orchestration, deployment, reconfiguration and execution. We illustrate the specification style that C WS supports by means of a large case study from the automotive domain and a number of more specific examples drawn from it.
Cc-pi: A constraint-based language for specifying service level agreements
- In ESOP, volume 4421 of LNCS
, 2007
"... Abstract. Service Level Agreements are a key issue in Service Oriented Computing. SLA contracts specify client requirements and service guarantees, with emphasis on Quality of Service (cost, performance, availability, etc.). In this work we propose a simple model of contracts for QoS and SLAs that a ..."
Abstract
-
Cited by 71 (6 self)
- Add to MetaCart
(Show Context)
Abstract. Service Level Agreements are a key issue in Service Oriented Computing. SLA contracts specify client requirements and service guarantees, with emphasis on Quality of Service (cost, performance, availability, etc.). In this work we propose a simple model of contracts for QoS and SLAs that also allows to study mechanisms for resource allocation and for joining different SLA requirements. Our language combines two basic programming paradigms: name-passing calculi and concurrent constraint programming (cc programming). Specifically, we extend cc programming by adding synchronous communication and by providing a treatment of names in terms of restriction and structural axioms closer to nominal calculi than to variables with existential quantification. In the resulting framework, SLA requirements are constraints that can be generated either by a single party or by the synchronisation of two agents. Moreover, restricting the scope of names allows for local stores of constraints, which may become global as a consequence of synchronisations. Our approach relies on a system of named constraints that equip classical constraints with a suitable algebraic structure providing a richer mechanism of constraint combination. We give reductionpreserving translations of both cc programming and the calculus of explicit fusions. 1
Contextual Nets
- Acta Informatica
"... We propose a new kind of nets, called contextual nets, where events may have both preconditions and postconditions, as in the classical case, and also positive or negative context conditions. Positive context conditions are to be interpreted as elements which are needed for the event to occur, but w ..."
Abstract
-
Cited by 61 (25 self)
- Add to MetaCart
(Show Context)
We propose a new kind of nets, called contextual nets, where events may have both preconditions and postconditions, as in the classical case, and also positive or negative context conditions. Positive context conditions are to be interpreted as elements which are needed for the event to occur, but which are not affected by the occurring of the event. Instead, negative context conditions are elements which must not be present for the event to take place. The importance of an explicit representation of positive context elements is twofold. Firstly, it allows a faithful representation of systems where the notion of "reading without consuming" is commonly used, like database systems, concurrent constraint programming, or any computation framework based on shared memory. Secondly, it allows to specify directly and naturally a level of concurrency greater than in classical nets. In fact, two events with different preconditions but with the same positive context may occur both in any order an...
A Concurrent Semantics for Concurrent Constraint Programs via Contextual Nets
- Constraint Programming: Proceedings 1993 NATO ASI Parnu, Estonia, NATO Advanced Science Institute Series
, 1994
"... We propose a concurrent semantics for concurrent constraint (cc) programs. A contextual net, that is a net with context conditions, besides pre- and post-conditions, is associated to each cc program. Context conditions are items which have to be present in order for an event to take place, but which ..."
Abstract
-
Cited by 27 (1 self)
- Add to MetaCart
(Show Context)
We propose a concurrent semantics for concurrent constraint (cc) programs. A contextual net, that is a net with context conditions, besides pre- and post-conditions, is associated to each cc program. Context conditions are items which have to be present in order for an event to take place, but which are not affected by the event. They are very useful for describing situations where different events share a common resource and want to read it simultaneously. The reason we use contextual nets for cc programs is that 1) nets allow a direct representation of concurrent information and 2) cc programs are naturally context-dependent (since the ask operation is a generalized read). While the causal dependency relation of the net induces a partial order among events in the same computation, its mutual exclusion relation provides a way of expressing nondeterministic information (and thus different computations). The information contained in the net, possibly abstracted to have a finite semantic...
Soft Constraint Programming to Analysing Security Protocols
- THEORY AND PRACTICE OF LOGIC PROGRAMMING
, 2004
"... Security protocols stipulate how the remote principals of a computer network should interact in order to obtain specific security goals. The crucial goals of confidentiality and authentication may be achieved in various forms, each of different strength. Using soft (rather than crisp) constraints, w ..."
Abstract
-
Cited by 18 (10 self)
- Add to MetaCart
(Show Context)
Security protocols stipulate how the remote principals of a computer network should interact in order to obtain specific security goals. The crucial goals of confidentiality and authentication may be achieved in various forms, each of different strength. Using soft (rather than crisp) constraints, we develop a uniform formal notion for the two goals. They are no longer formalised as mere yes/no properties as in the existing literature, but gain an extra parameter, the security level. For example, different messages can enjoy different levels of confidentiality, or a principal can achieve different levels of authentication with different principals. The goals are formalised within a general framework for protocol analysis that is amenable to mechanisation by model checking. Following the application of the framework to analysing the asymmetric Needham-Schroeder protocol (Bella and Bistarelli 2001; Bella and Bistarelli 2002), we have recently discovered a new attack on that protocol as a form of retaliation by principals who have been attacked previously. Having commented on that attack, we then demonstrate the framework on a bigger, largely deployed protocol consisting of three phases, Kerberos.
Decision diagrams for the computation of semiring valuations
- in: Proceedings of the Nineteenth International Joint Conference on Artificial Intelligence (IJCAI’05
, 2005
"... Abstract. This paper describes an approach to computation in a semiringbased system, which includes semiring-based CSPs (in particular weighted CSPs, fuzzy CSPs and standard CSPs) as well as Bayesian networks. The approach to computation is based on what we call semiring-labelled decision diagrams ( ..."
Abstract
-
Cited by 18 (2 self)
- Add to MetaCart
Abstract. This paper describes an approach to computation in a semiringbased system, which includes semiring-based CSPs (in particular weighted CSPs, fuzzy CSPs and standard CSPs) as well as Bayesian networks. The approach to computation is based on what we call semiring-labelled decision diagrams (SLDDs), which are strongly related to binary decision diagrams and finite-state automata. SLDDs can be generated in a similar way to a standard search tree (decision tree) for solving a CSP, but some nodes are merged, creating a more compact representation; for certain classes of CSPs, the number of nodes in the resulting network will be a tiny fraction of the number of nodes in the corresponding search tree. A method is given for generating an SLDD that represents e.g., a particular instance of a semiring-based CSP; it is shown how this can be used to perform various computations of interest, such as computing solutions, determining the possible values of each variable, finding optimal solutions, counting solutions and random generation of solutions of a CSP. 1
Partial Order and SOS Semantics for Linear Constraint Programs
- In Proc. of Coordination’97, volume 1282 of LNCS
, 1997
"... ..."
Partial Order and Contextual Net Semantics for Atomic and Locally Atomic CC Programs
, 1996
"... We present two concurrent semantics (i.e. semantics where concurrency is explicitely represented) for CC programs with atomic tells. One is based on simple partial orders of computation steps, while the other one is based on contextual nets and it is an extension of a previous one for eventual CC ..."
Abstract
-
Cited by 12 (7 self)
- Add to MetaCart
We present two concurrent semantics (i.e. semantics where concurrency is explicitely represented) for CC programs with atomic tells. One is based on simple partial orders of computation steps, while the other one is based on contextual nets and it is an extension of a previous one for eventual CC programs. Both such semantics allow us to derive concurrency, dependency, and nondeterminism information for the considered languages. We prove some properties about the relation between the two semantics, and also about the relation between them and the operational semantics. Moreover, we discuss how to use the contextual net semantics in the context of CLP programs. More precisely, by interpreting concurrency as possible parallelism, our semantics can be useful for a safe parallelization of some CLP computation steps. Dually, the dependency information may also be interpreted as necessary sequentialization, thus possibly exploiting it for the task of scheduling CC programs. Moreover, our s...
A Rewriting Logic Framework for Soft Constraints
- In WRLA 2006, 6th International Workshop on Rewriting Logic and its Applications
, 2006
"... ..."
(Show Context)
Analysis of Integrity Policies Using Soft Constraints
- In Proc. of IEEE Workshop Policies for Distributed Systems and Networks
, 2003
"... An integrity policy denes the situations when modi- cation of information is authorized and is enforced by the security mechanisms of the system. However, in a complex application system it is possible that an integrity policy may have been incorrectly specied and, as a result, a user may be authori ..."
Abstract
-
Cited by 10 (9 self)
- Add to MetaCart
An integrity policy denes the situations when modi- cation of information is authorized and is enforced by the security mechanisms of the system. However, in a complex application system it is possible that an integrity policy may have been incorrectly specied and, as a result, a user may be authorized to modify information that can lead to an unexpected system compromise. In this paper we outline a scalable and quantitative technique that uses constraint solving to model and analyze the effectiveness of application system integrity policies.