Catálogo de publicaciones - libros

Recently, development of peer-to-peer (P2P) applications has been giving a paramount attention mostly due to their attractive features such as decentralization and self-organization. Providing the programmer with the “right” platform for developing such applications became a challenge. In this paper we describe the functionality of , a platform for developing P2P applications in Mozart. The platform provides the developer with a means for building and working with P2P overlay applications, offering different primitives and services such as group communication, efficient data location, and dealing with highly dynamic networks. implements Tango, an efficient algorithm for constructing structured P2P systems. It is delivered as a library and already made public, being used as underlying structure for different P2P applications.

Strong mobility enables migration of entire computations combining code, data, and execution state (such as stack and program counter) between sites of computation. This is in contrast to weak mobility where migration is confined to just code and data. Strong mobility is essential for many applications where reconstruction of execution states is either difficult or even impossible: load balancing, reduction of network latency and traffic, and resource-related migration, just to name a few. This paper presents a model, programming abstractions, implementation, and evaluation of thread-based strong mobility. The model extends and takes advantage of a distributed programming model based on automatic synchronization through dataflow variables. It comes as a natural extension of dataflow computing which carefully separates issues concerning distribution and mobility. The programming abstractions capture various migration scenarios which differ in how the source and destination site relate to the site initiating migration. The implementation is based on replicating concurrent lightweight threads between sites controlled by migration managers.

This paper introduces a network fault model for distributed applications developed with the Mozart programming platform. First, it describes the fault model currently offered by Mozart, and the issues that make this model inconvenient for building fault-tolerant applications. Second, it introduces a novel fault model that addresses these issues. This model is based on a localization operation for distributed entities, and on an event-based mechanism to manage network faults. We claim that this model 1) is much better than the current one in all aspects, and 2) simplifies the development of fault-tolerant distributed applications by making the fault-tolerant aspect (largely) separate from the application logic. A prototype of this model has been developed on the existing Mozart platform. This prototype has been used on real applications to validate the aforementioned claims.

At the GU Dialogue Systems Lab in Göteborg we are embedding a conversational agent platform – the platform – in the Oz programming language. is based on a simple and intuitive characterization of conversational agents as interactive transducers, and on the fact that this characterization has a very direct implementation in Oz. Concurrency as offered by Oz allows our agents to ‘perceive’, ‘think’ and ‘act’ at the same time. Concurrency in combination with streams allow our agents to process input in an incremental manner, even when the original underlying algorithms are batch-oriented. Concurrency and streams in combination with ports allow us to specify the ‘toplevel’ transducer as a network of components – an interesting and highly modular architecture. We believe that software tools for specifying networks should have a strong visual aspect, and we have developed a ‘visual programming language’ and an IDE to support it. Also, we have found that if we specify the non-visual aspects of transducers and other components as class definitions that inherit the methods responsible for the interpretation of condition-action rules, regular expressions, grammars, dialogue management scripts, etc. from (abstract) classes provided by separate modules, we are able to hide most of the gory details involving threads, streams and ports from the agent developer.

The concept of metagrammar has been introduced to factorize information contained in a grammar. A metagrammar compiler can then be used to compute an actual grammar from a metagrammar. In this paper, we present a new metagrammar compiler based on 2 important concepts from logic programming, namely (1) the Warren’s Abstract Machine and (2) constraints on finite set.

Extensible Dependency Grammar (XDG) is a graph description language whose formulas can be solved by constraint programming. XDG is designed so as to yield a declarative approach to natural language processing, in particular to parsing and generation. In this paper, we present the XDG Development Kit (XDK), the first XDG-based grammar development system, which we have implemented in Mozart/Oz, thereby making full use of its multi-paradigmatic nature. The XDK supports an expressive lexicon specification language which which has not been published previously.

This paper presents a method to solve constraint satisfaction problems including a universally quantified variable with finite domain. Similar problems appear in the field of bounded model checking. The presented method is built on top of the Mozart constraint programming platform. The main principle of the algorithm is to consider only representative values in the domain of the quantified variable. The presented algorithm is similar to a branch and bound search. Significant improvements have been achieved both in memory consumption and execution time compared to a naive approach.

Search is essential for constraint programming. Search engines typically combine several features like state restoration for backtracking, best solution search, parallelism, or visualization. In current implementations like Mozart, however, these search engines are monolithic and hard-wired to one exploration strategy, severely complicating the implementation of new exploration strategies and preventing their reuse.

This paper presents the design of a for Mozart, a program that enables the user to freely combine several orthogonal aspects of search, resulting in a search engine tailored to the user’s needs. The abstractions developed here support fully automatic recomputation with last alternative optimization. They present a clean interface, making the implementation of new exploration strategies simple. Conservative extensions of the abstractions are presented that support best solution search and parallel search as orthogonal modules. IOzSeF, the Interactive Oz Search Factory, implements these abstractions and is freely available for download.

Although Constraint Programming (CP) is considered a useful tool for tackling combinatorial problems, its lack of flexibility when dealing with uncertainties and preferences is still a matter for research. Several formal frameworks for soft constraints have been proposed within the CP community: all of them seem to be theoretically solid, but few practical implementations exist. In this paper we present an implementation for Mozart of one of these frameworks, which is based on a semiring structure. We explain how the soft constraints constructs were adapted to the propagation process that Mozart performs, and show how they can be transparently integrated with current Mozart hard propagators. Additionally, we show how over-constrained problems can be successfully relaxed and solved, and how preferences can be added to a problem, while keeping the formal model as a direct reference.

The analysis of biochemical networks consists in studying the interactions between biological entities cooperating in complex cellular processes. To facilitate the expression of analyses and their computation, we introduced CP(BioNet), a constraint programming framework for the analysis of biochemical networks. An Oz-Mozart prototype of CP(BioNet) is described. This prototype consists of the implementation of a new kind of domain variables, graph domain variables, and the implementation of constraint propagators for constraints over graph-domain variables. These new variables and constraints are implemented in Oz and they can then be used like other domain variables in the Oz-Mozart platform. An implementation of a path constraint propagator is described in depth and constrained path finding tests are analysed to assess the tractability of our approach. Finally, an alternative Oz-Mozart data-structure for the graph-domain variables is presented and compared to the first one.