In this paper we describe an extension of the multiagent system programming language Jason with constructs for distribution and fault tolerance. The standard Java-based Jason implementation already does provide a distribution mechanism, which is implemented using the JADE library, but to use it effectively some Java programming is often required. Moreover, there is no support for fault tolerance. In contrast this paper develops constructs for distribution and fault tolerance wholly integrated in Jason, permitting the Jason programmer to implement complex distributed systems entirely in Jason itself. The fault tolerance techniques implemented allow the agents to detect, and hence react accordingly, when other agents have stopped working for some reason (e.g., due to a software or a hardware failure) or cannot anymore by reached due to a communication link failure. The introduction of distribution and fault tolerance in Jason represent a step forward towards the coherent integration of successful distributed software techniques, into the agent based software paradigm. The proposed extension to Jason has been implemented in eJason, an Erlang-based implementation of Jason. In fact, in this work we essentially import the distribution and fault tolerance mechanisms from the Erlang programming language into Jason, a task which requires adaptation of the basic primitives due to the difference between a process based functional programming language (Erlang) and a language for programming BDI (Belief-Desire-Intention) agent based systems (Jason).
Sound criteria for partial order reduction for probabilistic concurrent systems have been presented in the literature. Their realization relies on a depth-first search-based approach for generating the reduced model. The drawback of this dynamic approach is that it can hardly be combined with other techniques to tackle the state explosion problem, e.g., symbolic probabilistic model checking with multi-terminal variants of binary decision diagrams. Following the approach presented by Kurshan et al. for non-probabilistic systems, we study partial order reduction techniques for probabilistic concurrent systems that can be realized by a static analysis. The idea is to inject the reduction criteria into the control flow graphs of the processes of the system to be analyzed. We provide the theoretical foundations of static partial order reduction for probabilistic concurrent systems and present algorithms to realize them. Finally, we report on some experimental results.
In this paper we report on our experiences using Erlang to implement a subset of the agent-oriented programming language Jason. The principal existing implementation of Jason is written in Java, but suffers from a number of drawbacks, i.e., has severe limitations concerning the number of agents that can execute in parallel. Basing a Jason implementation on Erlang itself has the potential of improving such aspects of the resulting multi-agent platform. To evaluate Erlang as a programming language implementation platform the paper describes our experiences in mapping Jason to Erlang, highlighting the positive and negative aspects of Erlang for this task. Moreover, the paper contains a number of benchmarks to evaluate the quantitative aspects of the resulting Jason implementation, especially with respect to support large multi-agent systems.
El enfoque tradicional para la reducción en el cálculo lambda puro considera estrategias estándar, que nunca contraen un redex que esté a la izquierda del contracto de algún otro redex previamente contraído. La estrategia normal order representa dicho enfoque---al que nos referimos como enfoque normal---, contrayendo el redex situado más a la izquierda hasta que se alcanza una forma normal. Normal order elimina todos los redices presentes en el término, incluso aquellos que se encuentran en el cuerpo de una abstracción o a la derecha de una variable libre. Normal order es una estrategia completa, ya que encuentra la forma normal de un término si ésta existe, o diverge en caso contrario. Normal order es una estrategia híbrida, donde su definición big-step utiliza a la estrategia call-by-name de forma subsidiaria. A diferencia de normal order, call-by-name no contrae ningún redex que se encuentre bajo lambda ni a la derecha de una variable libre, produciendo formas normales weak-head. Normal order utiliza call-by-name para localizar el redex más exterior, contrayendo primero el redex (λx.B)N en vez de contraer prematuramente algún redex en B. Existe un enfoque alternativo que recorre la espina del término (penetrando en el cuerpo de las abstracciones) antes de contraer el redex más exterior. Denominamos a éste enfoque spine. Las estrategia spine order reduce bajo lambda y devuelve formas normales, utilizando head spine como estrategia subsidiaria. Head spine reduce los cuerpos de las abstracciones pero nunca a la derecha de una variable libre, produciendo formas normales head. Spine order utiliza un esquema de hibridación similar al de normal order, tomando head spine como subsidiaria. Spine order contraerá primero el redex (λx.B)N---donde B es una forma normal head---en vez de contraer prematuramente algún redex situado a la derecha de una variable libre dentro de B. ?`Cuáles son las estrategias normal y spine en el cálculo lambda value? Dichas estrategias deben ser análogas a normal order y spine order, es decir, deben ser completas y deben devolver formas normales, utilizando el enfoque normal o spine respectivamente. La respuesta es value normal order y value spine order respectivamente. En este trabajo damos una definición precisa de estrategias híbridas, construimos value normal order y value spine order a partir de consideraciones meta-teóricas y generalizamos el Teorema de Estandarización de Plotkin, demostrando un teorema análogo al Teorema de Reducción Quasi-Leftmost, sustentando así el enfoque spine en el cálculo lambda value.
El cálculo lambda es el núcleo de los lenguajes funcionales. El cálculo lambda puro es la versión clásica más basica. Menos conocidos son el cálculo lambda-value de Plotkin y la generalización de ambos, el cálculo lambda-paramétrico de Paolini y Ronchi della Rocca. En este seminario me gustaría dar a conocer dichos cálculos, los conceptos fundamentales (conversión, reducción, estrategias de reducción small-step y big-step, compleción, estandarización, solvability, etc.) y por qué son útiles para el estudio de los lenguajes de programación funcional.
In this paper we describe eJason, a prototype implementation of Jason, the well-known agent-oriented programming language, in Erlang, a concurrent functional programming language. The reason for choosing Erlang as the implementation vehicle is the surprising number of similarities between Jason and Erlang, e.g., both have their syntactical roots in logic programming, and share an actor-based process and communication model. Moreover, the Erlang runtime system implements lightweight processes and fast message passing between processes. Thus, by mapping Jason agents and agent-to-agent communication onto Erlang processes and Erlang process-to-process communication, we can create a very high-performing Jason implementation, potentially capable of supporting up to a hundred thousand concurrent actors. In this paper we describe in detail the implementation of Jason in Erlang, and provide early feedback on the performance of the implementation.
Spreadsheets have become widely used tools, but they are applied to increasingly complex problems, far beyond the kind of tasks for which they were originally conceived. This often results in large, hard to maintain sheets, with little guarantee about their correctness. Potential errors are due in part to unskilled users and also to the spreadsheet systems' own limitations. This contribution presents a tool that aims at improving the usual working flow when filling in a spreadsheet. The tool integrates a constraint solver based on transformations of the cell content into equality and inequality systems over rationals. The transformed systems are then solved using constraint logic programs and the obtained solutions are presented to the user in an understandable way. One of the practical benefits of this solution based on constraint logic programming is backwards execution: our tool is able to find out the required input values to reach the desired outputs depending on aggregation formulae written in the cells. Also, the constraint model offers a simple and sound solution to the problem of circular references in cell formulas.
This file was generated by bibtex2html 1.98.