Show last authors
1 #includeMacros("Main.MacroSheet")#includeMacros("ReSpecT.MacroSheet")
2
3 1 #respect() Overview
4
5 #respect() (*Re*action *Spec*ification *T*uples) is a logic-based language for the coordination of complex software systems.
6 ##
7 #respect() promotes a coordination model providing tuple centres as programmable, general-purpose coordination media.
8 ##
9 The behaviour of #respect() tuple centres is programmed through the #respect() first-order logic language.
10
11 1.1 The #respect() Tuple Centre Coordination Model
12
13 A tuple centre is a tuple space enhanced with the possibility to program its behaviour in response to interactions.
14 ##
15 First of all, coordinated entities (~~#respect() agents~~, henceforth, or simply ~~agents~~) can operate on a #respect() tuple centre in the same way as on a standard Linda tuple space: by exchanging ~~tuples~~ — which are ordered collection of knowledge chunks — through a simple set of coordination primitive.
16 ##
17 So, an agent can write a tuple in a tuple centre with an #code("out") primitive; or read a tuple from a tuple centre with primitives such as #code("in"), #code("rd"), #code("inp"), #code("rdp") specifying a tuple template - that is, an identifier for a set of tuples, according to some tuple matching mechanism.
18 ##
19 Reading tuples can be
20 * ~~destructive~~ — #code("in"), #code("inp") remove the matching tuple — or ~~non-destructive~~ — #code("rd"), #code("rdp") simply read the matching tuple
21 * ~~suspensive~~ — #code("in"), #code("rd") wait until a matching tuple is found — or ~~non-suspensive~~ — #code("inp"), #code("rdp") immediately return either the matching tuple or a failure result
22 but is anyway always ~~non-deterministic~~: when more than one tuple in a tuple centre are found that match a tuple template, one is non-deterministically chosen among them and returned.
23
24 Accordingly, a tuple centre enjoys all the many features of a tuple space, which can be classified along three different dimensions:
25 * generative communication
26 * associative access
27 * suspensive semantics
28
29 The main features of ~~generative communication~~ (where information generated has an independent life with respect to the generator) are the forms of uncoupling (space, time, name) based on mediated interaction: sender and receiver do not need to know each other, to coexist in the same space or at the same time in order to communicate (to exchange a tuple, in particular), and more generally, to interact.
30 ##
31 ~~Associative access~~ (access based on structure and content of information exchanged, rather than on location, or on name) based on tuple matching promotes synchronisation based on tuple structure and content: thus, coordination is data-driven, and allows for knowledge-based coordination patterns.
32 ##
33 Finally, ~~suspensive semantics~~ promotes coordination patterns based on knowledge availability, and couples well with incomplete, partial knowledge.
34
35 Even more, while the basic tuple centre model is independent of the type of tuple, #respect() tuple centres adopt logic tuples — both tuples and tuple templates are essentially Prolog ~~facts~~ — and logic ~~unification~~ is used as the tuple-matching mechanism.
36 ##
37 So, for instance, an agent #code("ag1") performing operation #code("we ? in(activity(ag1,CaseID))") on tuple centre #code("we") containing tuples #code("activity(ag1,c16)") and #code("activity(ag2,c22)") will be returned tuple #code("activity(ag1,c16)") — the one unifying with the template — removed from #code("we").
38 ##
39 Since the overall content of a tuple centre is a multiset of logic facts, it has a twofold interpretation as either a collection of messages, or a (logic) ~~theory of communication~~ among agents — thus promoting in principle forms of ~~reasoning about communication~~.
40
41 Finally, a tuple centre is a programmable tuple space, so as to add ~~programmability~~ of the coordination medium as a new dimension of coordination.
42 ##
43 While the behaviour of a tuple space in response to interaction events is fixed — so, the effects of coordination primitives is fixed —, the behaviour of a tuple centre can be tailored to the system needs by defining a set of specification tuples, or reactions, which determine how a tuple centre should react to incoming / outgoing events.
44 ##
45 While the basic tuple centre model is not bound to any specific language to define reactions, #respect() tuple centres are obviously programmed through the #respect() logic-based specification language.
46
47 1.1 #respect() as a Core Coordination Language
48
49 The original #respect() is a logic-based language for the specification of the behaviour of tuple centre.
50 ##
51 As a behaviour specification language, #respect():
52
53 * enables the definition of computations within a tuple centre, called reactions, and
54 * makes it possible to associate reactions to events occurring in a tuple centre.
55
56 So, #respect() has both a declarative and a procedural part.
57 ##
58 As a specification language, it allows events to be declaratively associated to reactions by means of specific logic tuples, called specification tuples, whose form is #code("reaction(E,R)").
59 ##
60 In short, given a event #code("Ev"), a specification tuple #code("reaction(E,R)") associates a reaction #code("Rtheta") to #code("Ev") if #code("theta") = mgu(#code("E,Ev")).
61 ##
62 As a reaction language, #respect() enables reactions to be procedurally defined in terms of sequences of logic reaction goals, each one either succeeding or failing.
63 ##
64 A reaction as a whole succeeds if all its reaction goals succeed, and fails otherwise.
65 ##
66 Each reaction is executed sequentially with a transactional semantics: so, a failed reaction has no effect on the state of a logic tuple centre.
67
68 All the reactions triggered by an event are executed before serving any other event: so, agents perceive the result of serving the event and executing all the associated reactions altogether as a single transition of the tuple centre state.
69 ##
70 As a result, the effect of a coordination primitive on a logic tuple centre can be made as complex as needed by the coordination requirements of a system.
71 ##
72 Generally speaking, since #respect() has been shown to be Turing-equivalent, any computable coordination law could be in principle encapsulated into a #respect() tuple centre.
73 ##
74 This is why #respect() can be assumed as a general-purpose core language for coordination: a language that could then be used to represent and enact policies and rules for coordination systems of any sort.
75
76 Adopting the declarative interpretation of logic tuples, a #respect() tuple centre has then a twofold nature a ~~theory of communication~~ (the set of the ordinary tuples) and a ~~theory of coordination~~ (the set of the specification tuples).
77 ##
78 In principle, this allows intelligent agents to reason about the state of collaboration activities, and to possibly affect their dynamics.
79 ##
80 Furthermore, the twofold interpretation (either declarative or procedural) of #respect() specification tuples allows knowledge and control to be represented uniformly (as Prolog-like facts) and encapsulated within the same coordination artefact.
2008 © aliCE Research Group @ DEIS, Alma Mater Studiorum-Università di Bologna
0.7