4 research outputs found
Towards More Data-Aware Application Integration (extended version)
Although most business application data is stored in relational databases,
programming languages and wire formats in integration middleware systems are
not table-centric. Due to costly format conversions, data-shipments and faster
computation, the trend is to "push-down" the integration operations closer to
the storage representation.
We address the alternative case of defining declarative, table-centric
integration semantics within standard integration systems. For that, we replace
the current operator implementations for the well-known Enterprise Integration
Patterns by equivalent "in-memory" table processing, and show a practical
realization in a conventional integration system for a non-reliable,
"data-intensive" messaging example. The results of the runtime analysis show
that table-centric processing is promising already in standard, "single-record"
message routing and transformations, and can potentially excel the message
throughput for "multi-record" table messages.Comment: 18 Pages, extended version of the contribution to British
International Conference on Databases (BICOD), 2015, Edinburgh, Scotlan
Tabled CLP for Reasoning Over Stream Data
The interest in reasoning over stream data is growing as quickly as the amount of data generated. Our intention is to change the way stream data is analyzed. This is an important problem because we constantly have new sensors collecting information, new events from electronic devices and/or from customers and we want to reason about this information. For example, information about traffic jams and costumer order could be used to define a deliverer route. When there is a new order or a new traffic jam, we usually restart from scratch in order to recompute the route. However, if we have several deliveries and we analyze the information from thousands of sensors, we would like to reduce the computation requirements, e.g. reusing results from the previous computation. Nowadays, most of the applications that analyze stream data are specialized for specific problems (using complex algorithms and heuristics) and combine a computation language with a query language. As a result, when the problems become more complex (in e.g. reasoning requirements), in order to modify the application complex and error prone coding is required.
We propose a framework based on a high-level language rooted in logic and constraints that will be able to provide customized services to different problems. The framework will discard wrong solutions in early stages and will reuse previous results that are still consistent with the current data set. The use of a constraint logic programming language will make it easier to translate the problem requirements into the code and will minimize the amount of re-engineering needed to comply with the requirements when they change
Design and implementation of a modular interface to integrate CLP and tabled execution
Logic programming (LP) is a family of high-level programming languages which provides high
expressive power. With LP, the programmer writes the properties of the result and / or executable
specifications instead of detailed computation steps.
Logic programming systems which feature tabled execution and constraint logic programming
have been shown to increase the declarativeness and efficiency of Prolog, while at the same time
making it possible to write very expressive programs. Tabled execution avoids infinite failure in
some cases, while improving efficiency in programs which repeat computations. CLP reduces the
search tree and brings the power of solving (in)equations over arbitrary domains.
Similarly to the LP case, CLP systems can also benefit from the power of tabling. Previous implementations
which take ful advantage of the ideas behind tabling (e.g., forcing suspension, answer
subsumption, etc. wherever it is necessary to avoid recomputation and terminate whenever possible)
did not offer a simple, well-documented, easy-to-understand interface. This would be necessary
to make the integratation of arbitrary CLP solvers into existing tabling systems possible. This
clearly hinders a more widespread usage of the combination of both facilities.
In this thesis we examine the requirements that a constraint solver must fulfill in order to be interfaced
with a tabling system. We propose and implement a framework, which we have called
Mod TCLP, with a minimal set of operations (e.g., entailment checking and projection) which the
constraint solver has to provide to the tabling engine.
We validate the design of Mod TCLP by a series of use cases: we re-engineer a previously existing
tabled constrain domain (difference constraints) which was connected in an ad-hoc manner
with the tabling engine in Ciao Prolog; we integrateHolzbauer’s CLP(Q) implementationwith Ciao
Prolog’s tabling engine; and we implement a constraint solver over (finite) lattices. We evaluate its
performance with several benchmarks that implement a simple abstract interpreter whose fixpoint
is reached by means of tabled execution, and whose domain operations are handled by the
constraint over (finite) lattices, where TCLP avoids recomputing subsumed abstractions.---ABSTRACT---La programación lógica con restricciones (CLP) y la tabulación son extensiones de la programación
lógica que incrementan la declaratividad y eficiencia de Prolog, al mismo tiempo que
hacen posible escribir programasmás expresivos.
Las implementaciones anteriores que integran completamente ambas extensiones, incluyendo
la suspensión de la ejecución de objetivos siempre que sea necesario, la implementación de inclusión
(subsumption) de respuestas, etc., en todos los puntos en los que sea necesario para evitar
recomputaciones y garantizar la terminación cuando sea posible, no han proporcionan una interfaz
simple, bien documentada y fácil de entender. Esta interfaz es necesaria para permitir integrar
resolutores de CLP arbitrarios en el sistema de tabulación. Esto claramente dificulta un uso más
generalizado de la integración de ambas extensiones.
En esta tesis examinamos los requisitos que un resolutor de restricciones debe cumplir para ser
integrado con un sistema de tabulación. Proponemos un esquema (y su implementación), que
hemos llamadoMod TCLP, que requiere un reducido conjunto de operaciones (en particular, y entre
otras, entailment y proyección de almacenes de restricciones) que el resolutor de restricciones
debe ofrecer al sistema de tabulación.
Hemos validado el diseño de Mod TCLP con una serie de casos de uso: la refactorización de un
sistema de restricciones (difference constraints) previamente conectado de un modo ad-hoc con
la tabulación de Ciao Prolog; la integración del sistema de restricciones CLP(Q) de Holzbauer; y
la implementación de un resolutor de restricciones sobre retículos finitos. Hemos evaluado su
rendimiento con varios programas de prueba, incluyendo la implementación de un intérprete
abstracto que alcanza su punto fijo mediante el sistema de tabulación y en el que las operaciones
en el dominio son realizadas por el resolutor de restricciones sobre retículos (finitos) donde TCLP
evita la recomputación de valores abstractos de las variables ya contenidos en llamadas anteriores