ReSpecT
| infoinfo | peoplepeople | tagstags |
ReSpecT promotes on a tuple-based coordination model, where
- communication is based on logic tuples;
- coordination occur through logic tuple spaces;
- the behaviour of each tuple space is programmable so to embed any computable coordination policy.
In this conceptual framework, ReSpecT has a twofold role:
- as a specification language, ReSpecT makes it possible to catch interaction events and associate them to reactions by means of first-order logic tuples;
- as a reaction language, ReSpecT supports the notion of reaction as a computational activity to be executed locally to a tuple centre in response to interaction events, by providing for both a logic-based syntax for the definition of reactions, and a model for their execution.
What is ReSpecT for?
ReSpecT can be used as a simple yet highly expressive event-driven programming language to program complex process / agent coordination laws outside processes / agents. The more complex is the management of the interaction within a software system the more useful is ReSpecT.
Where is ReSpecT?
Currently, ReSpecT is distributed as a part of the TuCSoN middleware.
TuCSoN is a middleware for the coordination of distributed processes, as well as autonomous, intelligent & mobile agents, providing #respect() tuple centres as its main coordination abstractions.
Correspondingly, the ReSpecT technology is currently made available as an essential part of the TuCSoN distribution.
ReSpecT Foundations
Before ReSpecT: the ACLT coordination model
The ReSpecT language derives from the work on the ACLT coordination model, where the notion of reaction was first defined, and the notion of programmability of tuple spaces was proposed for the first time.
- An Extensible Framework for the Development of Coordinated Applications (paper in proceedings, 1996) — Enrico Denti, Antonio Natali, Andrea Omicini, Marco Venuti
- Logic Tuple Spaces for the Coordination of Heterogeneous Agents (paper in proceedings, 1996) — Enrico Denti, Antonio Natali, Andrea Omicini, Marco Venuti
- Programmable Coordination Media (paper in proceedings, 1997) — Enrico Denti, Antonio Natali, Andrea Omicini
The definition of ReSpecT
- On the Expressive Power of a Language for Programming Coordination Media (paper in proceedings, 1998) — Enrico Denti, Antonio Natali, Andrea Omicini
- Formal ReSpecT (paper in proceedings, 2001) — Andrea Omicini, Enrico Denti
- From Tuple Spaces to Tuple Centres (article in journal, 2001) — Andrea Omicini, Enrico Denti
Extending ReSpecT
- Linkability
- Extending ReSpecT for Multiple Coordination Flows (paper in proceedings, 2002) — Alessandro Ricci, Andrea Omicini, Mirko Viroli
- Distributed Workflow upon Linkable Coordination Artifacts (paper in proceedings, 2006) — Andrea Omicini, Alessandro Ricci, Nicola Zaghini
- Linkable Coordination Artifacts for Inter-Organisational Workflow (paper in proceedings, 2006) — Andrea Omicini, Alessandro Ricci, Nicola Zaghini
- A&A meta-model
- Formal ReSpecT in the A&A Perspective (paper in proceedings, 2007) — Andrea Omicini
- Prototyping A&A ReSpecT in Maude (paper in proceedings, 2007) — Matteo Casadei, Andrea Omicini, Mirko Viroli
- Time
- Time-Aware Coordination in ReSpecT (paper in proceedings, 2005) — Andrea Omicini, Alessandro Ricci, Mirko Viroli
- Timed Environment for Web Agents (article in journal, 2007) — Andrea Omicini, Alessandro Ricci, Mirko Viroli
- Situatedness
- Situating A&A ReSpecT for Pervasive Environment Applications (paper in proceedings, 2008) — Matteo Casadei, Andrea Omicini
- Situated Tuple Centres in ReSpecT (paper in proceedings, 2009) — Matteo Casadei, Andrea Omicini
ReSpecT Manual
- ReSpecT Guide (manual, 2008) — Matteo Casadei, Andrea Omicini
Overview
- ReSpecT (Reaction Specification Tuples) is a logic-based language for the coordination of complex software systems
- ReSpecT promotes a coordination model providing tuple centres as programmable, general-purpose coordination media
- the behaviour of ReSpecT tuple centres is programmed through the ReSpecT first-order logic language
The ReSpecT Tuple Centre Coordination Model
A tuple centre is a tuple space enhanced with the possibility to program its behaviour in response to interactions.
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.
So, an agent can write a tuple in a tuple centre with an out primitive; or read a tuple from a tuple centre with primitives such as in, rd, inp, rdp specifying a tuple template - that is, an identifier for a set of tuples, according to some tuple matching mechanism
Reading tuples can be
- destructive — in, inp remove the matching tuple – or non-destructive– rd, rdp simply read the matching tuple
- suspensive — in, rd wait until a matching tuple is found – or non-suspensive– inp, rdp immediately return either the matching tuple or a failure result
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.
Accordingly, a tuple centre enjoys all the many features of a tuple space, which can be classified along three different dimensions:
- generative communication
- associative access
- suspensive semantics
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.
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. Finally, suspensive semantics promotes coordination patterns based on knowledge availability, and couples well with incomplete, partial knowledge.
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.
So, for instance, an agent ag1 performing operation we ? in(activity(ag1,CaseID)) on tuple centre we containing tuples activity(ag1,c16) and activity(ag2,c22) will be returned tuple activity(ag1,c16)—the one unifying with the template—removed from we. 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.
Finally, a tuple centre is a programmable tuple space, so as to add programmability of the coordination medium as a new dimension of coordination. 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. 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.
ReSpecT as a Core Coordination Language
The original ReSpecT is a logic-based language for the specification of the behaviour of tuple centre. As a behaviour specification language, #respect():
- enables the definition of computations within a tuple centre, called reactions, and
- makes it possible to associate reactions to events occurring in a tuple centre.
So, ReSpecT has both a declarative and a procedural part. 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 reaction(E,R). In short, given a event Ev, a specification tuple reaction(E,R) associates a reaction Rtheta to Ev if theta = mgu(E,Ev). 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. A reaction as a whole succeeds if all its reaction goals succeed, and fails otherwise. Each reaction is executed sequentially with a transactional semantics: so, a failed reaction has no effect on the state of a logic tuple centre.
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. 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. Generally speaking, sinceReSpecT has been shown to be Turing-equivalent, any computable coordination law could be in principle encapsulated into a ReSpecT tuple centre. 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.
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). In principle, this allows intelligent agents to reason about the state of collaboration activities, and to possibly affect their dynamics. 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.
Development
If you wanted to get involved in ReSpecT development, you could contact us (see people page) or take a look at ReSpecT sources so as to know all the details of the various ReSpecT versions.
<p/>
source versioning system
ReSpecT Roadmap
Features Overview
| Feature | Description | Version | Status |
|---|---|---|---|
| <a href='#3levelrespect'>3-level ReSpecT</a> | ReSpecT re-engineering to make it usable seamlessly at three different levels: <ul> <li>language</li><li>application</li><li>infrastructure</li></ul> | 2.2.0 | {style:background-color=yellow}STARTED{style} |
| <a href='#tools'>ReSpecT tools</a> | ReSpecT) GUI re-design to include tools providing easy inspection, modification, access to syntax, history, status, and the like | 2.2.0-2.2.X | {style:background-color= yellow}STARTED{style} |
| <a href='#spec'>ReSpecT specification primitives</a> | Implementation and testing of _s primitives | 2.2.0 | {style:background-color= yellow}STARTED{style} |
| <a href='#interfaces'>ReSpecT interfaces</a> | Re-organisation of ReSpecT interfaces for tuple centre's usage according to coherent orthogonal dimensions | 2.2.0 | {style:background-color=yellow}STARTED{style} |
| <a href='#2p2'>ReSpecT upon #tuprolog() 2.0</a> | Moving ReSpecT from #tuprolog() 1.4 to #tuprolog() 2.X (current version) | 2.2.1 | {style:background-color=red}NOT STARTED{style} |
Features Rationale
<a name
'3levelrespect'>3-Level ReSpecT</a> =====
ReSpecT should be re-engineered to be used seamlessly at three different levels: language, application, infrastructure.
- As the language level, #respect() should should be usable as a full-featured language, à la Prolog or Java, independently of any application or infrastructure. To do so, it should be equipped first of all with a CUI, allowing all #respect() primitives to be invoked from the CL, possibly including some ad hoc primitive for inspection, and some easy help à la Unix. This should make it possible to use #respect() so as to experiment with coordination in an interactive (REPL-like) environment: the user start #respect() shell, access a tuple-centre, edit tuple-centre specification, test (via coordination primitives) the newly specified behavior. Also, the shell should be seamlessly accessed from a GUI, including a console and an inspector, possibly launched from a web page (i.e. Java Web Start)
- At the application level, it should be possible to embed #respect() in applications and exploited as a coordination engine -- in the same way as #tuprolog() works for logic programming. Languages like Java or Prolog should be able to use #respect() tuple centres as coordinators of different language components with a single application
- at the infrastructure level, #respect() tuple centers should be usable as coordination abstractions provided either natively or as general services by some middleware / software infrastructure. So, for instance, they could work as #tucson() tuple centres in the #tucson() infrastructure for MAS coordination, or work as general-purpose coordination services in a pervasive computing scenario according to the "Coordination as a Service" perspective (see #pubTitleLink("CoordFundamentainformaticae73")).
<a name
'tools'>#respect() Tools</a> ====
ReSpecT GUI re-design to include tools providing easy inspection, modification, access to syntax, history, status, and the like.
- at the basic level, the GUI should include the #respect() console, representing the user agent interacting with tuple centres. Each console represents a single user agent, who should be able to perform the basic #respect() primitives, essentially including Linda-like coordination primitives (in, rd, out; rdp, inp; no; get & set) as well as the corresponding specification primitives (_s)
- at a higher level, the GUI should include the #respect() inspector, representing the tuple centre interface toward a user. Each inspector represents a single tuple centre, who should of course make available the basic #respect() primitives, including Linda-like coordination primitives and the corresponding specification primitives, but mostly provide a view over the tuple space state, the specification space state, and possibly over the interaction state and the computational state
- further tools, possibly separating the inspection from the control could be "extracted" from the inspector subsequently.
<a name
'spec'>#respect() Specification Primitives</a> ====
Specification ( _s) primitives should be actually added to the #respect() engine, and tested extensively.
<a name
'interfaces'>#respect() Interfaces</a> ====
#respect() interfaces for tuple centre's usage according to coherent orthogonal dimensions.
Currently, we envision two dimensions for re-organisation: (I) sorts of operations, (II) interactive behaviour.
<p/>
The operations are basically of the following sorts:
- basic #respect() coordination operations (in, rd, out; rdp, inp; no; get & set)
- #respect() specification operations (_s)
- management operations (start/stop/restart engine, dump/load memory images, handle system tuple centres like $DEFAULT, $SYS, $ORG)
- link operations, from other tuple centres
<p/>
The interaction behaviours are obviously
- blocking
- non-blocking
Correspondingly,
- IBlockingContext interface should include blocking basic coordination operations
- INonBlockingContext interface should include nonblocking basic coordination operations
- IBlockingSpecContext interface should include blocking specification operations
- INonBlockingSpecContext interface should include nonblocking specification operations
- IManagementContext interface should include management operations (which should be nonblocking)
- ILinkContext interface should include link operations (which should be nonblocking)
<a name
'2p2'>ReSpecT upon tuProlog 2.0</a> ====
ReSpecT implementation should be moved from #tuprolog() 1.4 to tuProlog 2.X (current version)
- finding and documenting all dependencies
- integrating tuProlog and #respect() development processes via dependencies
Downloads
ReSpecT Distributions
The first ReSpecT test distribution is now available here
Test Version
Installation Instructions
- download the beta version of the full distribution: respect-2.2-beta.zip
- unzip the file
- move to the unzipped directory
- double-click on the file respect-2.2-beta.jar
Situated ReSpecT
Main idea
The main idea behind Situated ReSpecT is that coordination artefacts should mediate any interaction inside a distributed / multi-agent systems, including process / agent interaction with the environment. A coordination language such as ReSpecT should then take care to handle any sort of situated interaction between computational systems and the surrounding physical environment.
Note: the notion of situated action dates back to the seminal paper Plans and Situated Actions: The Problem of Human-Machine Communication.
- Situated Tuple Centres in ReSpecT (paper in proceedings, 2009) — Matteo Casadei, Andrea Omicini — Matteo Casadei, Andrea Omicini
- Coordinazione situata: integrazione di Arduino in un middleware basato su tuple (25/07/2013) — Steven Maraldi
- Tecnologie per la collaborazione sociale tra robot Mindstorm: Lejos & ReSpecT (28/03/2012) — Cornel Moisuc
- Coordinazione sociale di robot Mindstorm in ReSpecT (23/06/2011) — Matteo Mosca
- Sviluppo di un framework concettuale e tecnologico per l'integrazione di LEGO Mindstorm e ReSpecT (23/03/2011) — Marco Alessi
- Esperienze in robotica con lego Mindstorm e ReSpecT (25/06/2009) — Matteo Amaducci
- Tecnologie di coordinazione per la situatedness in ambito robotico (25/06/2009) — Maicol Urbinati
- Coordinazione di sistemi multi-agente basati su piattaforma LEGO MINDSTORMS (18/12/2003) — Simone Pellegrini
Spatial ReSpecT
- Topologia nel modello di coordinazione TuCSoN (22/07/2010) — Enrico Zamagni
