Daniel Cabeza

Distributed WWW programming using (Ciao-)Prolog and the PiLLoW library

We discuss from a practical point of view a number of issues involved in writing distributed Internet and WWW applications using LP/CLP systems. We describe PiLLoW, a public-domain Internet and WWW programming library for LP/CLP systems that we have designed to simplify the process of writing such applications. PiLLoW provides facilities for accessing documents and code on the WWW; parsing, manipulating and generating HTML and XML structured documents and data; producing HTML forms; writing form handlers and CGI-scripts; and processing HTML/XML templates. An important contribution of PiLLoW is to model HTML/XML code (and, thus, the content of WWW pages) as terms. The PiLLoW library has been developed in the context of the Ciao Prolog system, but it has been adapted to a number of popular LP/CLP systems, supporting most of its functionality. We also describe the use of concurrency and a high-level model of client-server interaction, Ciao Prologs active modules, in the context of WWW programming. We propose a solution for client-side downloading and execution of Prolog code, using generic browsers. Finally, we also provide an overview of related work on the topic.

A syntactic approach to combining functional notation, lazy evaluation, and higher-order in LP systems

Nondeterminism and partially instantiated data structures give logic programming expressive power beyond that of functional programming. However, functional programming often provides convenient syntactic features, such as having a designated implicit output argument, which allow function call nesting and sometimes results in more compact code. Functional programming also sometimes allows a more direct encoding of lazy evaluation, with its ability to deal with infinite data structures. We present a syntactic functional extension, used in the Ciao system, which can be implemented in ISO-standard Prolog systems and covers function application, predefined evaluable functors, functional definitions, quoting, and lazy evaluation. The extension is also composable with higher-order features and can be combined with other extensions to ISO-Prolog such as constraints. We also highlight the features of the Ciao system which help implementation and present some data on the overhead of using lazy evaluation with respect to eager evaluation.

Hiord: a type-free higher-order logic programming language with predicate abstraction

A new formalism, called Hiord, for defining type-free higherorder logic programming languages with predicate abstraction is introduced. A model theory, based on partial combinatory algebras, is presented, with respect to which the formalism is shown sound. A programming language built on a subset of Hiord, and its implementation are discussed. A new proposal for defining modules in this framework is considered, along with several examples.

The Ciao Modular, Standalone Compiler and Its Generic Program Processing Library

This invention relates to the strengthening of glass articles through an ion exchange process wherein alkali metal ions in a surface of a glass article are replaced by larger monovalent metal ions. In carrying out the process, a surface of the glass article is contacted with a source of the larger monovalent ions at an elevated temperature below the strain point of the glass for a sufficient length of time to cause the replacement of small alkali metal ions in the glass surface with the larger monovalent metal ions to a depth of at least five microns, thereby inducing a surface compression layer of this depth on the article. This invention is specifically directed to alkali aluminosilicate glasses.

The Ciao Module System: A New Module System for Prolog

Abstract It is now widely accepted that separating programs into modules has proven very useful in program development and maintenance. While many Prolog implementations include useful module systems, we feel that these systems can be improved in a number of ways, such as, for example, being more amenable to effective global analysis and transformation and allowing separate compilation or sensible creation of standalone executables. We discuss a number of issues related to the design of such an improved module system for Prolog. Based on this, we present the choices made in the Ciao module system, which has been designed to meet a number of objectives: allowing separate compilation, extensibility in features and in syntax, amenability to modular global analysis and transformation, etc.

Practical Aspects of Declarative Languages

Invited Talks.- Building the World from First Principles: Declarative Machine Descriptions and Compiler Construction.- Code Compression.- Papers.- Functional Framework for Sound Synthesis.- Specializing Narrowing for Timetable Generation: A Case Study.- Character-Based Cladistics and Answer Set Programming.- Role-Based Declarative Synchronization for Reconfigurable Systems.- Towards a More Practical Hybrid Probabilistic Logic Programming Framework.- Safe Programming with Pointers Through Stateful Views.- Towards Provably Correct Code Generation via Horn Logical Continuation Semantics.- A Provably Correct Compiler for Efficient Model Checking of Mobile Processes.- An Ordered Logic Program Solver.- Improving Memory Usage in the BEAM.- Solving Constraints on Sets of Spatial Objects.- Discovery of Minimal Unsatisfiable Subsets of Constraints Using Hitting Set Dualization.- Solving Collaborative Fuzzy Agents Problems with CLP( ).- Improved Fusion for Optimizing Generics.- The Program Inverter LRinv and Its Structure.- A Full Pattern-Based Paradigm for XML Query Processing.- Type Class Directives.

A Generic Persistence Model for (C)LP Systems

This paper describes a model of persistence in (C)LP languages and two different and practically very useful ways to implement this model in current systems. The fundamental idea is that persistence is a characteristic of certain dynamic predicates (i.e., those which encapsulate state). The main effect of declaring a predicate persistent is that the dynamic changes made to such predicates persist from one execution to the next one. After proposing a syntax for declaring persistent predicates, a simple, file-based implementation of the concept is presented and some examples shown. An additional implementation is presented which stores persistent predicates in an external database. The abstraction of the concept of persistence from its implementation allows developing applications which can store their persistent predicates alternatively in files or databases with only a few simple changes to a declaration stating the location and modality used for persistent storage. The paper presents the model, the implementation approach in both the cases of using files and relational databases, a number of optimizations of the process (using information obtained from static global analysis and goal clustering), and performance results from an implementation of these ideas.