Designing a BPEL Orchestration Engine Based on ReSpecT Tuple Centres

We present the design of a BPEL orchestration engine based on ReSpecT tuple centres, a coordination model extending Linda with the ability of declaratively programming the reactive behaviour of tuple spaces. Architectural and linguistic aspects of our solution are discussed, focussing on how the syntax and semantics of BPEL have been mapped to tuple centres. This is achieved by a translation of BPEL specifications to set of logic tuples, and conceiving the execution cycle of the orchestration engine in terms of ReSpecT reactions.     

Coordinating Java agents over the WWW

We introduce Jada, a programming toolkit for coordinating agents written in Java. Coordination among either concurrent threads or distributed Java objects is achieved via shared object spaces. By exchanging objects through object spaces, Java agents or applets can exchange data or synchronize their actions over the Internet, a LAN, a single host, or even inside a Javaenabled browser. The access to an object space is performed using a set of methods of an ObjectSpace object. Such operations inspired by the Linda language are powerful enough to solve several coordination problems. Moreover, we show how Jada can be used as a coordination kernel for more complex coordination architectures.     

A quantitative solution to Constraint Satisfaction Problem (CSP)

Constraint Satisfaction Problem (CSP) is an important problem in artificial intelligence and operations research. Many practical problems can be formulated as CSP, i.e., finding a consistent value assignment to variables subject to a set of constraints. In this paper, we give a quantitative approach to solve the CSPs which deals uniformly with binary constraints as well as high order,k-ary (k ≥ 2) constraints. In this quantitative approach, using variable transformation and constraint transformation, a CSP is transformed into a satisfiability (SAT) problem. The SAT problem is then solved within a continuous search space. We will evaluate the performance of this method based on randomly generated SAT problem instances and regularly generatedk-ary (k ≥ 2) CSP problem instances.     

Formal ReSpecT in the A&A Perspective

Coordination models and languages have found a new course in the context of MAS (multiagent systems). By re-interpreting results in terms of agent-oriented abstractions, new conceptual spaces are found, which extend the reach of coordination techniques far beyond their original scope. This is for instance the case of coordination media, when recasted in terms of coordination artifacts in the MAS context.In this paper, we take the well-established ReSpecT language for programming tuple centre behaviour, and adopt the A&A (agents and artifacts) meta-model as a perspective to reinterpret, revise, extend and complete it. A formal model of the so-called A&A ReSpecT language is presented, along with an example illustrating its use for MAS coordination.     

Supporting fault-tolerant parallel programming in Linda

Linda is a language for programming parallel applications whose most notable feature is a distributed shared memory called tuple space. While suitable for a wide variety of programs, one shortcoming of the language as commonly defined and implemented is a lack of support for writing programs that can tolerate failures in the underlying computing platform. This paper describes FT-Linda, a version of Linda that addresses this problem by providing two major enhancements that facilitate the writing of fault-tolerant applications: stable tuple spaces and atomic execution of tuple space operations. The former is a type of stable storage in which tuple values are guaranteed to persist across failures, while the latter allows collections of tuple operations to be executed in an all-or-nothing fashion despite failures and concurrency. The design of these enhancements is presented in detail and illustrated by examples drawn from both the Linda and fault-tolerance domains. An implementation of FT-Linda for a network of workstations is also described. The design is based on replicating the contents of stable tuple spaces to provide failure resilience and then updating the copies using atomic multicast. This strategy allows an efficient implementation in which only a single multicast message is needed for each atomic collection of tuple space operations     

Extension of scala language by distributed and parallel computing tools with Linda coordination system

The paper describes a new library developed for Linda language implementation for Scala programming language (language support of the component programming software). The library uses client-server architecture and a database for the tuple space representation. It implements the search for similarities and “primitive” and additional operations. The library can be used for distributed and parallel application development.     

An artificial brain ATR's CAM-Brain Project aims to build/evolve an artificial brain with a million neural net modules inside a trillion cell Cellular Automata Machine

ATR's Evolutionary Systems Department aims to build (i.e. grow/evolve) an artificial brain by the year 2001. This artificial brain should initially contain thousands of interconnected artificial neural network modules, and be capable of controlling approximately 1000 “behaviors” in a “robot kitten”. The name given to this research project is “CAM-Brain”, because the neural networks (based on cellular automata) will be grown inside special hardware called Cellular Automata Machines (CAMs). Using a family of CAMs, each with its own processor to measure the performance quality or fitness of the evolved neural circuits, will allow the neural modules and their interconnections to be grown/evolved at electronic speeds. State of the art in CAM design is about 10 to the power 9 or 10 cells. Since a neural module of about 15 connected neurons can fit inside a cube of 100 cells on a side (1 million cells), a CAM which is specially adapted for CAM-Brain could contain thousands of interconnected modules, i.e. an artificial brain.     

Implementing specifications by dynamic inheritance

An extended form of logic programming is presented which combines SLD-resolution with a dynamic form of inheritance between modules. The resulting inference system supports the notion of ‘implementation’ as a process of computing mappings between specifications and technologies—both formulated as sets of clausal-form theories—in order to satisfy requirements posed as queries. Besides detailing the operational features of the formalism, the paper also explores its semantics and its practical value in two case studies.     

Granularity analysis for exploiting adaptive parallelism of declarative programs on multiprocessors

Declarative Programming Languages (DPLs) apply a grocess model of Horn clauses such as PARLOG^[8] or a reduction model of λ-calculus such as SML^[7] and are,in principle,well suited to multiprocessor implementation.However,the performance of a paralled declarative program can be impaired by a mismatch between the parallelism available in an application and the parallelism available in the architecture.A particularly attractive solution is to automatically match the parallelism of the program to the parallelism of the target hardware as a compilation step.In this paper,we present an optimizing compilation technique called granularity analysis which identifies and removes excess parallelism that would degrade performance.The main steps are:an analysis of the flow of data to form an attributed call graph between function (or predicate) arguments;and an asymptotic estimation of granularity of a function (or predicate) to generate approximate grain size.Compiled procedure calls can be annotated with grain size and a task scheduler can make scheduling decisions with the classification scheme of grains to control parallelism at run-time.The resulting granularity analysis scheme is suitable for exploiting adaptive parallelism of declarative programming languages on multiprocessors.     

Software composition with Linda

Nowadays, tuple spaces have turned out to be one of the most fundamental abstractions for coordinating communicating agents. Some models, as Linda, were presented as a set of inter-agent communication primitives which can virtually be added to any programming language. These models have the advantage of capturing both communication and synchronization in a natural and simple way. In this paper, we analyze the use of Linda to specify the interactive behavior of software components. We first introduce a process algebra for Linda and we define a notion of process compatibility that ensures the safe composition of components. This definition of compatibility takes into account the state of a global store (tuple space), which gives relevant information about the current execution of the system. Indeed, a Linda-based computation is characterized by the store's evolution, so that the set of tuples included into the store governs each computation step. In particular, we prove that compatibility implies successful computation (i.e. without deadlock). We also argue that Linda features some advantages with respect to similar proposals in the context of dynamic compatibility checking. In this context, the success of the composition of a pair of agents in presence of a suitable store can be useful to condition the acceptance of a given component into an open running system. In order to extend our approach to complex systems, where constructing a system involves more than two components, we propose the use of distributed tuple spaces as the glue to join components.     

WCL: A co-ordination language for geographically distributed agents

In this paper a tuple space based co-ordination language, and a run-time system which supports it, is described. The co-ordination language is called WCL, and it is designed to support agent co-ordination over the Internet between agents which are geographically distributed. WCL uses tuple spaces as used in Linda. WCL provides a richer set of primitives than traditional tuple space based systems, and provides asynchronous and synchronous tuple space access, bulk tuple primitives, and streaming primitives which, as a whole, provide a complete framework more suited to co-ordination over the Internet compared with the Linda primitives. The primitives emphasise efficiency and location transparency (of data and agents) and this is exploited in the current run-time system used to support WCL. The run-time system described in this paper is distributed and uses location transparency and dynamic analysis of tuple space usage to migrate tuple spaces around the distributed system. Some initial experimental results are given which demonstrate the performance gains of using the tuple space migration. The paper motivates the inclusion of many of the primitives, and demonstrates how a well designed set of primitives provides performance and efficiency. The JavaSpace primitives are used as an example of how the choice of primitives can detrimentally affect the efficiency of the language, and exclude required co-ordination constructs.     

BaLinda Lisp: Design and implementation

BaLinda Lisp is a parallel Lisp dialect employing a shared memory model of parallel processing together with a subset of the Linda tuple space operators. Also included in the design is speculative processing. The aim is to have shared memory multiprocessing with the tuple space acting as the main data structure through which synchronization is done. The result is a flexible programming language. In this paper, we shall describe the design philosophy of BaLinda Lisp, discuss its implementation on three multiprocessing platforms, give examples of programs written in BaLinda Lisp and discuss future work on the language.     

KLAIM: a kernel language for agents interaction and mobility

We investigate the issue of designing a kernel programming language for mobile computing and describe KLAIM, a language that supports a programming paradigm where processes, like data, can be moved from one computing environment to another. The language consists of a core Linda with multiple tuple spaces and of a set of operators for building processes. KLAIM naturally supports programming with explicit localities. Localities are first-class data (they can be manipulated like any other data), but the language provides coordination mechanisms to control the interaction protocols among located processes. The formal operational semantics is useful for discussing the design of the language and provides guidelines for implementations. KLAIM is equipped with a type system that statically checks access right violations of mobile agents. Types are used to describe the intentions (read, write, execute, etc.) of processes in relation to the various localities. The type system is used to determine the operations that processes want to perform at each locality, and to check whether they comply with the declared intentions and whether they have the necessary rights to perform the intended operations at the specific localities. Via a series of examples, we show that many mobile code programming paradigms can be naturally implemented in our kernel language. We also present a prototype implementation of KLAIM in Java     

Data Privacy in Tuple Space Based Mobile Agent Systems

More recently, distributed variants of tuple spaces have been proposed to exploit the Linda model for programming distributed applications over wide area networks, possibly exploiting code mobility. However, the flexibility of the shared tuple space model opens possible security holes; it basically provides no access protection to the shared data. In this paper we investigate some possible scenarios where mobile agents can benefit from our cryptographic tuple space based framework, CryptoKlava, and sketch how to possibly implement such agents in order to keep the privacy of items collected by the mobile agent during its itinerary. The functionalities of the framework are general enough to be applied to other Java frameworks using multiple distributed tuples spaces possibly dealing with code mobility.     

Resource management in open Linda systems

Coordination systems, in particular Linda, have established themselves as important tools for the development of applications to open systems such as the Internet. This paper shows how to tackle a forgotten, but crucial problem in open coordination systems: memory management. As with any system which intends to be of wide use and because memory is a finite resource, coordination systems must address the problems of memory exhaustion. This paper first explores the orthogonality between coordination and computation in order to make it clear that the problem of memory exhaustion in coordination systems cannot be solved using garbage collection schemes implemented at the computation language—a garbage collection scheme must exist in the coordination environment as well. Following the explanation on orthogonality, the paper will focus on describing a garbage collection scheme for the Linda family of coordination systems. It is expected that the solution in Linda can be adapted to other coordination systems as long as they are based on tuple space communication. Copyright © 2003 John Wiley & Sons, Ltd.     

Undecidable goals for completed acyclic programs

We prove for a well-known acyclic logic programP that it is undecidable whether or not a given goal is a logical consequence of the completion ofP. This complements recent decidability results for acyclic programs and bounded goals.     

The learning convergence of CMAC in cyclic learning

In this paper we discuss the learning convergence of the cerebellar model articulation controller (CMAC) in cyclic learning.We prove the following results.First,if the training samples are noiseless,the training algorithm converges if and only if the learning rate is chosen from (0,2).Second,when the training samples have noises,the learning algorithm will converge with a probability of one if the learning rate is dynamically decreased.Third,in the case with noises,with a small but fixed learning rate ε the mean square error of the weight sequences generated by the CMAC learning algorithm will be bounded by O(ε).Some simulation experiments are carried out to test these results.     

ReSpecT Nets: Towards an Analysis Methodology for ReSpecT Specifications

A key feature for infrastructures providing coordination services is the ability to define the behaviour of coordination abstractions according to the requirements identified at design-time. We take as a representative for this scenario the logic-based language ReSpecT (Reaction Specification Tuples), used to program the reactive behaviour of tuple centres. ReSpecT specifications are at the core of the engineering methodology underlying the TuCSoN infrastructure, and are therefore the “conceptual place” where formal methods can be fruitfully applied to guarantee relevant system properties.In this paper we introduce ReSpecT nets, a formalism that can be used to describe reactive behaviours that can succeed and fail, and that allows for an encoding to Petri nets with inhibitor arcs. ReSpecT nets are introduced to give a core model to a fragment of the ReSpecT language, and to pave the way for devising an analysis methodology including formal verification of safety and liveness properties. In particular, we provide a semantics to ReSpecT specifications through a mapping to ReSpecT nets. The potential of this approach for the analysis of ReSpecT specifications is discussed, presenting initial results for the analysis of safety properties.     

Compatibility of Linda-based Component Interfaces

Linda is a coordination language, originally presented as a set of inter-agent communication primitives which can virtually be added to any programming language. In this paper, we analyse the use of Linda to specify the interactive behaviour of software components. We first introduce a process algebra for Linda and we define a notion of process compatibility that ensures the safe composition of components. In particular, we prove that compatibility implies successful computation. We also argue that Linda features some advantages with respect to similar proposals in the context of dynamic compatibility checking. In this perspective, we propose an alternative definition of compatibility that takes into account the state of a global store, which gives some relevant information about the current execution of the system.     

An architecture for tuple‐based coordination of multi‐agent systems

Multi‐agent system development calls for powerful and expressive coordination models and languages, as well as for an effective coordination technology. A good deal of the current research effort focuses on tuple‐based coordination, exploiting its well‐known advantages, such as agent uncoupling and associative access to information, and addressing its limitations in terms of flexibility and control capabilities. In particular, the behaviour of a Linda‐like tuple space is fixed once and for all by the coordination model, and cannot be tailored to the specific application needs. Tuple centres are tuple spaces whose behaviour can be programmed by defining transactional reactions to the basic communication events, allowing coordination laws to be explicitly defined and embedded into the coordination medium. This paper presents the architecture of a run‐time system for tuple‐based coordination, where tuple centres work as an extensible kernel, around which multi‐agent systems can be designed and deployed. After sketching the implementation, the paper shows the advantages that can be achieved from both the design and the performance viewpoints. Copyright © 1999 John Wiley & Sons, Ltd.