Abstract
This paper identifies potential security loopholes in the implementation of support for meta-predicates Closing these loopholes depends on three conditions: a clear distinction between closures and goals, support for an extended meta-predicate directive that allows the specification of closures, and the availability of the call/2-N family of built-in meta-predicates. These conditions provide the basis for a set of simple safety rules that allows meta-predicates to be securely supported. These safety rules are currently implemented by Logtalk, all object-oriented logic programming language, and may also be applied in the context of Prolog predicate-based module systems. Experimental results illustrate how these rules can prevent several security problems, including accidental or malicious changes to the original meta-predicate arguments and bypassing of predicate scope rules and predicate scope directives.

Abstract
Logtalk, an object oriented logic programming language, provides experimental support for multi-threading programming with selected back-end Prolog compilers. By making use of core, low-level Prolog predicates that interface with operating-system native threads, Logtalk provides a high-level set of directives and predicates that allows programmers to easily take advantage of modern multi-processor and multi-core computers without worrying about the details of creating, synchronizing, or communicating with threads. Logtalk multi-threading programming features include support for concurrent calls akin to and-parallelism and or-parallelism, non- deterministic thread goals, asynchronous calls, and predicate synchronization. The integration with the Logtalk object-oriented features allows objects to send and receive both synchronous and asynchronous messages and to call local predicates concurrently. Logtalk multi-threading features are orthogonal to object-oriented concepts and can be useful even in the context of plain Prolog.

Abstract
We describe and compare design choices for meta-predicate semantics, as found in representative Prolog module systems and in Logtalk. We look at the consequences of these design choices from a pragmatic perspective, discussing explicit qualification semantics, com- putational reflection support, expressiveness of meta-predicate declara- tions, safety of meta-predicate definitions, portability of meta-predicate definitions, and meta-predicate performance. Our aim is to provide use- ful insight for debating meta-predicate semantics and portability issues based on actual implementations and common usage patterns.

Abstract
We introduce a simple agent construct associated to a named local database and a "Twitter-style"weak inheritance mechanism between local agents. On top of a remote predicate call layer, connecting distributed agent spaces, we build a replication mechanism allowing agents "visiting" remote spaces to expose their computational capabilities to non-local followers. The resulting protocol has the remarkable property that only updates to the state of the agents are sent over the network through transactional remote predicate calls guaranteed to always terminate, and therefore spawning of multiple threads can be avoided. At the same time, calls to a visiting agent's code by its followers are always locally executed, resulting in performance gains and reduced communication efforts. Copyright 2012 ACM.

Abstract
In this paper we describe how declarative process modeling together with ontologies can be used to build complex clinical process models. Our approach supports the definition of functional, behavioral, organizational, data and operational process perspectives, resulting in an expressive and flexible modeling language. We use constraints for representing inter-process dependencies and constraint propagation for finding which processes are executable in user selected or given scenarios. Knowledge about the organizational perspective of a clinical ontology can be represented and imported from RDF files for interfacing with other applications. We implemented our approach in ESProNa, a Logtalk application running on SWI-Prolog extended with the CLP(FD) constraint library and the N3 parser Henry.

Abstract
Logic programming is well suited for declaratively solving computational problems that require knowledge representation and reasoning. Object-oriented languages, on the other hand, are well suited for modeling real-world concepts and profit from rich ecosystems developed around them, which are often missing from logic languages. For applications that require both the declarative power of logic programming and the rich modeling expressiveness and development environments offered by object-oriented languages, there is a need for reconciling both worlds. LogicObjects is our linguistic symbiosis framework for integrating Prolog within the Java language. It extends Java with annotations that allow Java programs to interact transparently and automatically with Prolog programs. Copyright 2012 ACM.