Logic Programming as a Service

06/07/2018 ∙ by Roberta Calegari, et al. ∙ University of Bologna 0

New generations of distributed systems are opening novel perspectives for logic programming (LP): on the one hand, service-oriented architectures represent nowadays the standard approach for distributed systems engineering; on the other hand, pervasive systems mandate for situated intelligence. In this paper we introduce the notion of Logic Programming as a Service (LPaaS) as a means to address the needs of pervasive intelligent systems through logic engines exploited as a distributed service. First we define the abstract architectural model by re-interpreting classical LP notions in the new context; then we elaborate on the nature of LP interpreted as a service by describing the basic LPaaS interface. Finally, we show how LPaaS works in practice by discussing its implementation in terms of distributed tuProlog engines, accounting for basic issues such as interoperability and configurability. Under consideration in Theory and Practice of Logic Programming (TPLP).



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Intro Computation is moving towards pervasive, ubiquitous environments where devices, software agents, and services are expected to seamlessly integrate and cooperate in support of human users, anticipating their needs and more generally acting on their behalf, delivering services in an “anywhere, anytime” fashion [Finin et al. (2001), Zambonelli et al. (2015)]. Even more, software agents, robots, sensors, etc. could work together with people for a common goal, with the same level of efficiency and expertise as human-only teams. Such systems could face important challenges in several fields—from military network-centric operations, to gaming technologies, simulation, computer security, transportation and logistics, and others [Parker (2008)].

The above scenarios naturally fit a distributed approach: tasks are often distributed in space, time, or functionality, and their completion can clearly benefit from the chance of solving subproblems modularly and concurrently. At the same time, the same scenarios inherently call for intelligence – namely, distributed situated intelligence [Parker (2008)] – to exploit domain knowledge, understand the local context, and share information in support of intelligent applications and services [Chen et al. (2003), Smart (2017)].

Logic programming (LP henceforth) boasts a long-respected reputation in supporting intelligence: originally conceived for single solvers and later extended towards concurrency and parallelism, LP has the potential to fully support pervasive computing scenarios once it is suitably re-interpreted. Re-interpretation of LP should develop along three main lines: (i) architecture—that is, the need to go beyond the (originally monolithic) structure of LP systems, which is unsuitable for distributed contexts such as mobility/cloud ecosystems, typically grounded upon the service-oriented computing paradigm [Erl (2005)]; (ii) situatedness—that is, enabling logic theories, queries, and resolutions to be context-aware w.r.t. the (computational) environment, space, and time; (iii) interaction—that is, the opportunity to re-think the interaction patterns used by clients to query logic engines, which should lean towards on-demand computation.

At the same time, LP declarativeness and explicit knowledge representation enable knowledge sharing at the most adequate level of abstraction, while supporting modularity and separation of concerns [Oliya and Pung (2011)], which are specially valuable in open and dynamic distributed systems (serendipitous interoperability, serendipitousinteroperability-jaise5). As a further element, LP soundness and completeness straightforwardly enable agents’ intelligent reasoning. Finally, LP extensions or logic-based computational models – such as meta-reasoning about situations [Loke (2004)] or labelled variables systems [Calegari et al. (2018)] – could be incorporated so as to enable complex behaviours tailored to the situated components.

Although LP languages and technologies represent in principle a natural candidate for injecting intelligence within computational systems [Brownlee (2011)], and despite the many practical application developed over the years – see Palu:2010-LPapp, martelli1995 for a survey –, the adoption of LP in pervasive contexts has been historically hindered by technological obstacles – efficiency, integration issues – as well as by some cultural resistance towards LP-based approaches outside the academy. However, technology advancements, on the one hand, and the emergence of the context, on the other, are drastically changing such a scenario, possibly allowing LP to unleash its full potential in real-world applications.

Along this line, in this paper we present Logic Programming as a Service (), a novel approach intended as the natural evolution of distributed LP in pervasive systems, explicitly designed to exploit context-awareness so as to promote the distribution of situated intelligence within smart environments. As the name suggests, the basic idea is to deliver LP-based intelligence as a service, granting ubiquitous access to knowledge and on-demand reasoning via LP services, spread over the network and configured to respond to specific local needs. Accordingly, some classical LP notions need to be revised and extended: for instance, client/service interaction is no longer bound to the traditional console-based query/response loop, and is instead redesigned to provide the dynamism, flexibility, and expressiveness required by the targeted application scenarios—e.g., . Similarly, time and space situatedness promotes novel forms of client/service interaction, enabling clients to submit “situated” queries where the notions of time and locus explicitly affect the computation.

The remainder of the paper is organised as follows. After relatedEvolution reviews the main works about the evolution of distributed LP, vision introduces the vision behind , by discussing how the service perspective and the new situated dimension of computation mandate for a re-interpretation of some basic LP concepts. architecture shows how such a re-interpretation affects LP at the architectural level, by discussing more practically the logic-based service-oriented architecture supporting . service defines the service interface, and elaborates on the interaction patterns. casestudy presents a prototype implementation developed on the top of the system, while discussion discusses a case study in the Smart House field. Related works are reported in related.

2 Distributed LP: Evolution

relatedEvolution Research on distributed intelligence has gained increasing popularity over the years [Parker (2008)]

. Starting from the seminal work of parallellp-fpca1981, concurrency, parallelism, and several approaches for distributing intelligence have been explored—from LP languages specifically designed for distribution, to pure logic-based models, rule-based systems, probabilistic graphical models, and ontologies. In the following we organise and describe some of the most relevant contributions to the field and to our approach, motivating the need for further advancement.

Implicit Parallelism.

The first efforts to advance beyond sequential LP start from the programming schemes for the interpretation of logic programs—in particular, towards implicit parallel evaluation, leading to explore AND-parallelism, OR-parallelism, Search parallelism, and Stream-AND-parallelism.

naf-logicdbbook1978 introduces a scheme that allows negative literals in queries; some years later, the Naish scheme [Naish (1988)] introduces co-routing among procedure calls. Meanwhile, resolution-iclp1984 focus on AND-parallel evaluation: their asynchronous version corresponds to the execution models of parallel LP languages. These schemes perform and adapt well to different forms of parallelism: however, they are not meant to face distributed programming. Also, it is worth noting that implicit parallelism lacks two important control mechanisms: synchronisation of logic processes, and control over the non-determinism of schedulers.

Explicit Parallelism.

Later approaches focus on “extraction” of parallelism via explicit language constructs.

A first line of research moves from concurrent logic languages, rooted in the Relational Language [Clark and Gregory (1981)], generally acknowledged as the first concurrent LP language. In [Shapiro (1987)], Guarded Horn Clauses [Ueda (1986)], and Parlog [Clark (1987)], goal evaluation is carried out by a network of fine-grained logic processes (i.e., atomic goals) that are executed in parallel: processes communicate via shared streams, i.e., bi-directional channels on which data items flow.

An alternative research line follows the idea of extending with special features for distributed execution, like message passing. This approach preserves the operational semantics of sequential , augmenting the language with ad-hoc communication primitives. One of the major references in this field is [Brogi and Gorrieri (1989)], where is extended with constructs for sequential and parallel composition of goals, inter-process communication and synchronisation, and external non-determinism. programs [Cunha et al. (1989)] using concurrency mechanisms do not lend themselves to the usual declarative interpretation as Horn clauses, and are grounded instead on the theory of Distributed Logic [Monteiro (1984)]. This approach extends Horn clause logic with the notion of time-dependent events, on which process communication and synchronisation are based, making distributed logic a special kind of temporal logic.

Besides enabling inter-process communication for logic programs, orthogonal aspects such as their deployment are not considered, neither the issues brought along by distribution – such as validity in time of logic theories and their global consistency – are taken into account.

Agents, Communication, and Coordination for Distributed LP.

Further steps towards distributed LP come with [Brogi and Ciancarini (1991)], based on parallel agents that are programs extended with a guard mechanism. The programmer controls the granularity of parallelism, coordinating agents’ communication and synchronisation via a centralised data structure, the blackboard, inspired to the model defined in [Nii (1986)] as well as to the coordination model [Gelernter (1985)]. The main idea is to exploit the blackboard within the logic framework to coordinate logic processes. However, the inference engine is not situated in time and space, i.e. the query result is independent from the entities’ position, the time flow, and context/situation changes.

LP in Pervasive, Context-aware Systems.

More recently, LP has been explored as a promising solution to bring intelligence into pervasive context-aware systems.

folcontextaware-puc7 show that using first-order logic is a very effective and powerful way of dealing with context, promoting an approach to develop a flexible and expressive model supporting context-awareness, enabling deduction of higher-level situations from perceptions about basic contexts—via rule-based approaches. A key advantage of formally modelling the context is that the expressiveness of the model itself can be clearly specified and automatically verified. situatedlp-ker19 emphasises that LP is generally useful for context reasoning, as well as for supporting rule-based (meta)programming in context-aware applications, enabling, i.e. hierarchical description of complex situations in terms of other situations. This approach encourages a high level of abstraction for representing and reasoning about situations, and supports building context-aware systems incrementally through modularity and separation of concerns. The focus on context-awareness of both contributions is at the base of our choice of re-interpreting distributed LP by targeting especially context-aware systems, as pervasive ones usually are—being the a prominent example.

Other works take different approaches: from pure logic-based models, to rule-based systems and probabilistic graphical models, up to ontologies.

Rule-based systems [Salber et al. (1999), Dey (2001), Etter et al. (2006), Wang et al. (2011)] have been in use for decades for both model representation and reasoning in context-aware applications. More recently, Nalepa2014 have proposed a rule-based, learning middleware for storage and reasoning in a distributed scenario. The idea is to delegate context acquisition to middleware, that is, a rule-based context reasoning platform tailored to the needs of intelligent distributed mobile computing devices. The need for a dedicated middleware layer is apparent in the aforementioned works, further strengthening the idea that distributed LP is not confined to context manipulation, and deserves instead general attention.

In ranganathan:2004, fuzzy and probabilistic logic is exploited to handle the uncertainty of the environment and deal with the imperfections of data. Probabilistic graphical models [Bettini et al. (2010)] can be exploited to support the modelling of, and the reasoning about, uncertain information in pervasive systems, even if exact inference in complex probabilistic models can be a NP-hard task. Description logic, usually used in combination with ontologies, is another LP extension effective for modelling concepts, roles, individuals, and their relationships, as well as to provide simple reasoning capabilities [Hu et al. (2012)]. However, only simple classification tasks can be solved, and no mechanisms are provided to infer more complex information from existing data. Also, design and implementation are typically more difficult and time-consuming than with other approaches. Since uncertainty of information is the natural enemy of global consistency, our approach moves from the choice of abandoning the idea of globally-consistent (in terms of both time and space) logic theories (or, knowledge bases—KB) in favour of locally-consistent ones.

3 The Vision


The evolution of LP in parallel, concurrent, and distributed scenarios is the main motivation for re-interpreting the notion of distribution of LP in today’s context. Since Service-Oriented Architecture () is the de facto standard for distributed application development in both the academia and the industry [Erl (2005)], service focuses on how LP can be re-interpreted in the service perspective. This perspective further emphasises the role of situatedness, already brought along by distribution in itself: thus, situatedness discusses how being situated in space, time, and context affects LP computation. The two novel perspectives are merged together in towards-situated-service, which develops the idea of LP as a situated service.

3.1 The Service Perspective


The service-oriented perspective deeply affects the way in which LP engines are conceived, designed, and used—in particular, as far as the very nature of LP encapsulation is concerned, the way in which clients interact (requiring statelessness), and the assumptions about the surrounding context (locality) are concerned.


A service hides both data representation and the computational mechanisms behind a public interface exposed to its clients. In the context of LP engines, this means that both the logic theory (the data) and the resolution process (the computational mechanism) are inaccessible – and, in general, not observable – from outside the boundary of the service interface. As a consequence, theory manipulation mechanisms, such as assert/retract, are no longer directly applicable from the client perspective: since the logic theory is encapsulated by the service, dedicated mechanisms are required for its handling. For instance, in an scenario, this may happen via a separate “sensor API” through which sensor devices regularly update the KB of the LP service according to their perception of the surrounding environment.

Accordingly, the logic theory of a service can be either static or dynamic (which are mutually exclusive configurations). The way in which the LP service can be accessed obviously depends on that: time is an issue for dynamic KB, not for static ones.


Encapsulation makes it irrelevant how the encapsulated behaviour is implemented: what actually matters are the inputs triggering, and the outputs resulting from, that behaviour. Furthermore, in the perspective, services are usually redundantly distributed over a network of hosts for enhancing the service availability and reliability: thus, it does not really matter who actually carries out the encapsulated behaviour. In the context of LP, this means that interactions with clients should be also allowed to be stateless—that is, include all the information required by the resolution process, since a different component may serve a different request. Notably, statelessness is the default for RESTful web services, too.

It is worth emphasising here that statelessness does not contrast with the above encapsulation property, since the former regards the invocation of services – hence the interaction between clients and servers –, whereas the latter concerns services themselves—that is, their inner nature. In other words, statelessness implies that servers are not supposed to track the state of interactions, so that a service request should not assume or rely on previous interactions, whereas encapsulation means that only the selected properties of the service are visible and modifiable from the outside.

At the same time, in order to cope with data-intensive applications, where stateless interaction may become cumbersome, also supports stateful interaction—yet, at the clients’ convenience and will. This is particularly handy for scenarios where reasoning and inference should be based on continuous and possibly unbounded streams of data, such as those coming from sensors in deployments.


The distributed nature of the system drastically changes the perspective over consistency: maintaining globally-consistent information is typically unfeasible in such systems. Furthermore, when pervasive systems enter the picture, even globally-available information is usually not a realistic assumption: for instance, in scenarios, heterogeneous data streams are continuously made available by sensor devices scattered in specific portions of the physical environment. As a consequence, encapsulation is inevitably bound to a specific, (local) portion of the system—with a notion of locality extending up to when/where availability and/or consistency are inevitably lost.

In the context of LP, this means first of all resorting to a multi-theory logical framework, exploiting the typical approach to modularity adopted in traditional LP in order to allow for parallel and concurrent computation [Bugliesi et al. (1994)]. Also, locality implies that each logic theory describes just what is locally true —which basically means leaving aside in principle the global acceptation of the closed world assumption [Reiter (1978)] in favour of a more realistic locally-closed world assumption. Accordingly, every LP service is to be queried about what is locally known to be true, with no need to resort to global knowledge of any sort—and with no need to distribute the resolution process in any way.

3.2 The Situatedness Perspective


The distribution of LP service instances directly calls for situatedness, intended as the property of the LP service to be immersed in the surrounding computational/physical environment, whose changes may affect its computations [Mariani and Omicini (2015)]. As an example, new sensor data may change the replies of an LP service to queries. Situatedness adds three new dimensions to LP computations: space, time, and context.


To be situated in space means that the spatial context where the LP service is executing may affect its properties, computations, and the way it interacts with clients.

Distribution per se constitutes a premise to spatial situatedness: each LP instance runs on a different device, thus on a different network host, therefore accessing the different computational and network resources that are locally available. Moreover, since LP services encapsulate the logic theory for their resolution process, the locally-gathered knowledge affects the result, once it is represented in terms of logic axions.

Also, more articulated forms of spatial situatedness may be envisioned: for instance, mobile clients may request LP services from different locations at each request, possibly even while moving, which means that the LP service must be able to coherently identify and track clients so as to reply to the correct network address. Finally, it is possible in principle to conceive logic theories – or even individual axioms therein – with spatially-bound validity, that is, that are true only in specific points or regions in space—analogously to spatial tuples in spatialtuples-idc2016.


Complementarily, being situated in time means that the temporal context when the LP service is executed may affect its properties, computations, and interactions with clients. Yet again, distribution alone already brings about temporal issues: moving information in a network takes time, thus aspects such as expiration of requests, obsolescence of logic theories, and timeliness of replies should be taken into account when designing the LP service.

Furthermore, since reconstructing a global notion of time in pervasive systems is either unfeasible or non-trivial, each LP service should operate on its own local time—that is, computing deadlines, leasing times, and the like according to its local perception of time. Also, in the same way as for spatial situatedness, temporal situatedness may also imply that logic theories or individual axioms may have their time-bounded validity—e.g., holding true up to a certain instant in time, and no longer since then.


Besides the space/time fabric, situatedness also regards the generic environment within which LP services execute—that is, the computational and physical context which may affect their working cycle: for instance, it may depend on the available CPUs and RAM, whether an accelerometer is available on the current hosting device, etc.

A basic level of contextual situatedness is already embedded in the very nature of the LP service: in fact, locality of the resolution process implies that the logic theory for goal resolution belongs to the context of the LP service, thus straightforwardly affecting its behaviour. However, especially in the scenarios envisioned for , the computational and physical contexts may both impact the LP service: e.g., sensor devices may continuously update the service KB with their latest perceptions, while actuators may promptly provide feedback on success/failure of physical actions.

3.3 Towards LP as a Situated Service


The above perspectives promote a radical re-interpretation of a few facets of LP, moving LP itself towards the notion of envisioned in this paper—that is, in terms of a situated service. Such a notion articulates along four major lines:

  • the preservation (with re-contextualisation) of the SLD resolution process;

  • stateless interactions;

  • time-sensitive computations;

  • space-sensitive computations.

The re-contextualisation of the SLD resolution process.

The SLD resolution process [Robinson (1965)] remains a staple in : yet, it is re-contextualised in the situated nature of the specific LP service. This means that, given the precise spatial, temporal, and general contexts within which the service is operating when the resolution process starts, the process follows the usual rules of SLD resolution: situatedness is accounted for through the service abstraction with respect to such three contexts.

With respect to the spatial context, the resolution process obviously takes place in the hosting device where the LP service is running, thus taking into account the specific properties of the computational and physical environment therein available – CPU, RAM, network facilities, GPS positioning, etc. – there included the specific logic theory the LP service relies on. As mentioned in situatedness, more articulated forms of spatial situatedness – e.g., involving mobility of clients (and LP services, in principle), or, virtual/physical regions of validity for logic axioms – could be envisioned.

The temporal context refers to the resolution process taking place on a frozen snapshot of the LP service state – there including its KB –, which stays unaffected to external stimuli (possibly affecting the resolution process) until the process itself terminates. This way, despite the dynamic nature of the KB – encapsulated by the service abstraction – which could change e.g. due to sensors’ perceptions, the resolution process is guaranteed to operate on a consistent stable state of the logic theory.

Finally, the resolution process depends on the general context of the specific device hosting the LP service instance—thus considering the state of the KB therein available, as assembled by e.g., the set of sensors devices therein available, the service agents gathering new local information, and so on.

Stateless interactions.

A first change brought by concerns interaction with clients of the LP service.

In classical LP, interactions are necessarily stateful: the user first sets the logic theory, then defines the goal, and then asks for one or more solutions, iteratively. This implies that the LP engine is expected to store the logic theory to exploit as its KB, to memorise the goal under demonstration, and to track how many solutions have been already provided to the user—and all these items become part of the state of the LP engine.

Instead, in interactions are first of all (even though not exclusively) stateless: coherently with , the LP service instance that actually serves each request may be different at each time, e.g. due to redundancy of distributed software components aimed at improving availability and reliability of the LP service. In such a perspective, each client query (interaction) should be possibly self-contained, so that it does not matter which specific service instance responds—because there is no need for it to track the state of the interaction session.

It is worth emphasising that in the case of stateful interaction, adequate measures need be taken to prevent possible problems related to different service instances serving repeated requests, requests from mobile clients, and similar situations. Two possible solutions could be considered for this concern: (i) the middleware could simply lock a service in case of stateful interaction, ensuring that the client always interacts with the same service instance (this is essentially the problem of conversational continuity, well documented in the literature [Gelernter (1985)]); (ii) alternatively, the middleware could take care of the hand-off of the interaction from instance to instance, ensuring proper sharing of the information needed to preserve statefulness across service instances.

Time-local computation.

Another change stemming from the situated nature of is concerned with the relationship between the resolution process and the flow of time.

In pure LP, the logic theory is simply assumed to be always valid, and time-related aspects do not affect the resolution process; for instance, assertion / retraction mechanisms are most typically regarded as extra-logic ones. As discussed above, in the consistency of the resolution process is guaranteed by the fact that the possibly ever-changing KB encapsulated by the service is frozen in time when the resolution process itself begins: nevertheless, time situatedness requires by definition that time affects the LP service computation in some way.

Accordingly, in each axiom in the KB is decorated with a time interval, indicating the time validity of each clause. Every time a new resolution process starts in order to serve a request, the logic theory used is the one containing all and only the axioms holding true at the timestamp associated with the resolution process itself. In the simplest case, such a timestamp is implicitly assigned by the LP server as the current local time when the request for goal demonstration is first served. Otherwise, it could also be explicitly assigned by clients along with the request—e.g., defining a specific time when asking for a goal demonstration.

Space-local computation.

Analogously, classical LP has no notion of space situatedness: be it a virtual or a physical space, the LP engine is a monolithic component providing its “services” only locally, to its co-located “clients” working on the same machine.

The interpretation stems again from the very nature of service in modern -based applications—a computational unit providing its functionalities through a network-reachable endpoint. Therefore, the resolution process in is naturally and inherently affected by the specific computational locus

where a given LP service instance is executing at a given moment—there including the locally-available resources.

4 The Architecture


is a logic-based, service-oriented approach for distributed situated intelligence, conceived and designed as the natural evolution of LP in nowadays pervasive computing systems. Its purpose is to enable situated reasoning via explicit definition of the spatio-temporal structure of the environment where situated entities act and interact.

Along the lines traced in towards-situated-service, we now elaborate more practically on how encapsulation, statelessness, and locality – that is, the service perspective (service) – are exploited in according to the three dimensions of situatedness described in situatedness—that is, time, space, and context. Then, we briefly describe microservices [Familiar (2015)] as a key enabler architecture for .

4.1 Service Architecture



As it straightforwardly stems from principles, encapsulation is exploited in so as to define a standard API that shields clients from the inner details of the service while providing suitable means of interaction.

Figure 1: Configurator Service Architecture (left) and Client Service Architecture (right)

Accordingly, each LP server node exposes its LP service to clients via two interfaces, depicted in service:

Client Interface

exposes methods for observation and usage. Client refers to any kind of users, either individuals (humans, software agents) or groups entitled to exploit the services.

Configurator Interface

enables service configuration and requires proper access credentials. Configurator refers to service managers—privileged agents with the right of enforcing control and policies for that local portion of the system.

Applications can access the service as either Clients or Configurators, via the corresponding interfaces. The service is initialised at deployment-time on the server machine: once started, it can be dynamically re-configured at run-time by any configurator.


Situatedness is exploited as a means to consistently handle locality w.r.t. context, time, and space.

In fact, dealing with situated logic theories means to give up with the idea of global consistency in a closed world: in multiple KB are spread throughout a network infrastructure, likely geographically distributed, executing within different computational contexts, and possibly either fed by sensors or manipulated by service agents perceiving the physical context. By allowing distributed access and reasoning over its own locally-situated knowledge base, each node actively contributes to the overall availability of the global knowledge.

Accordingly, pervasive application scenarios where logic theories represent local knowledge inherently call for dynamic KB, autonomously evolving during the service lifetime111Here,“autonomously” means that in the perspective the logic KB may evolve over time with no need for a client to invoke assert/retract, or equivalent methods – which, in fact, are not included in the standard API detailed in api – but, e.g., due to sensor devices’ perceptions transparently feeding the LP service KB.. As such, each situated KB of a service can be seen as representing what is known to be true and relevant in a given location in space at a given time, thus possibly changing over time – e.g., due to data streams coming from sensor devices –, and potentially different from any other KB located elsewhere—as depicted in sit-arch.

Figure 2: Situatedness of : the same query () by the same client may be resolved differently () by distinct services () based on their local computational, physical, and spatio-temporal context ()



  • each clause has a lifetime, expressed as a time interval of validity—as in the case of the current temperature in a room;

  • as a result, at any point in time a service has precisely one logic theory made of all and only the clauses that hold true at time ;

  • each resolution process is either implicitly (by the server) or explicitly (by the client) labelled with a timestamp, used to determine the KB to be used for the resolution itself—which then works as the standard LP resolution.


Uncoupling is one of the main requirements for interaction in distributed systems: that is why provides stateless client-server interaction as one of its main features. The same holds true in particular for pervasive systems, where instability is one of the main issues, as well as for mobile systems, with any sort of mobility: physical mobility of users and devices; users who change their computing device while using applications; service instances migrating from machine to machine—as in a cloud-based environment.

The need for uncoupling promotes stateless interaction in . Thus, for instance, both clients and service instances can freely move with no concerns for requests tracking and identity/location bookeeping.

In order to balance the effect of statelessness on data-intensive interactions between LP service and users, also provides clients with the ability to ask for more than one solution at a time, and even all of them, with a single request. Nevertheless, also makes it possible to obtain a stream of solutions from the resolution process, rather than a single solution at a time in an individual interaction session, to better meet the needs of fast-paced dynamic scenarios in which clients want to be constantly updated by the LP service about some situation.

Accordingly, provides clients with the means to obtain both stateless and stateful client-server interaction:


once the logic theory to consider is settled, and the goal stated, the client should be able to ask for any amount of solutions – possibly iteratively, possibly at different times and from different places – with the service being responsible to guarantee consistency and validity of solutions by keeping track of the related interaction sessions with the same client;


in this case, no session state is tracked by the server, so each client request should contain all the information required to serve the request itself.

It is worth highlighting that nothing prevents the service from being stateful and stateless simultaneously, because the LP server can manage multiple kinds of requests concurrently; instead, of course, each client request in is either stateful or stateless.

4.2 Microservices as Technology Enablers

microservices Service-oriented architectures represent nowadays the standard approach for distributed system engineering [Erl (2005)]: so, adopts the Software as a Service () architecture as its reference [Cusumano (2010)].

Accordingly, information technology resources are conceived as continuously-provided services: applications are supposed to be available 24/7, scale up & down elastically, support resiliency to changes (i.e., in the form of suitable fault-tolerance mechanisms), provide a responsive user experience on all popular devices, and require neither user installation nor application updates.

In particular, LP services in can be fruitfully interpreted as microservices [Familiar (2015)]. Microservices are a recent architectural style for applications promoting usage of self-contained units of functionally with loosely-coupled dependencies on other services: as such, they can be designed, developed, tested, and released independently. Thanks to their features, microservices are deserving increasing attention also in the industry – pretty much like in the mid 2000s – where fast and easy deployment, fine-grained scalability, modularity, and overall agility are particularly appreciated [Richards (2016)].

Technically speaking, microservices are designed to expose their functionality through standardised network-addressable APIs and data contracts, making it possible to choose the programming language, operating system, and data store that best fit the service needs and the developers’ skills set, without worrying about interoperability. Microservices should also be dynamically configurable, possibly in different forms and with different configuration levels. Obviously, actual support to interoperability requires multiple levels of standardisation: to this end, defines its own interfaces for both configuration and exploitation, while relying on widely adopted standards as far as the representation formats (i.e., JSON-home) and interaction protocols (i.e. REST over HTTP, or MQTT-home) are concerned.

5 The Service


Following the reference architecture above, designing amounts first of all at defining the Configurator Interface and the Client Interface—as in service.

Generally speaking, the LP service should support (i) observational methods to provide configuration and contextual information about the service, (ii) usage methods to trigger computations and reasoning, as well as to ask for solutions, and (iii) configuration methods to allow the configurator to set the LP service configuration.

Observational methods make it possible to query the service about its configuration (stateful/stateless, static/dynamic), the state of the knowledge base, and the admissible goals: as such, they belong to the Client Interface, but can be made available also in the Configurator Interface for convenience. Usage methods, instead, belong uniquely to the Client Interface: they allow clients to ask for one or more solutions—one solution, solutions, or all solutions available, for stateful or stateless requests as well. Configurator methods belong uniquely to the Configurator Interface, and are intended to set the service configuration, KB nature, and admissible goals.

5.1 Service Interfaces


Table 1: Configurator Interface

Adopting the notation for input/output [Deransart et al. (1996)], the actual Configurator methods are detailed in Table 1, while the Client Interface is detailed in Table 2. Since the first is rather self-explanatory, we focus on the Client Interface.

The first thing worth noting is that usage predicates for stateless and stateful requests are slightly different from each other. In the case of stateless requests, the solve operation is conceptually atomic and self-contained—so, e.g., the Goal to solve is always one of its arguments; instead, in the case of stateful requests it is up to the server to keep track of the request state, so the goal is to be set only once by the client before the first solve request is issued.

The second key aspect is the threefold impact of time awareness: regardless of whether the server is either computing or idle, time flows anyway, so predicates have to be time-sensitive. Accordingly,

  • solve predicates can also contain a Timeout parameter (server time) for the resolution, so as to avoid blocking the server indefinitely: if the resolution process does not complete within the given time, the request is cancelled, and a negative response is returned;

  • for stateful requests, the client could also ask for a stream of solutions, which is particularly useful in scenarios exploiting sensor devices, or monitoring processes: to this end, solve takes a time argument (server time), meaning that each new solution should be returned not faster than every time milliseconds;

  • when the KB is dynamic, all predicates take an additional Timestamp argument, meaning that each theory has a time-bounded validity: this feature can be used during the proof of a goal to ensure that only the clauses valid at the given Timestamp are taken into account in that resolution process.

For the sake of convenience, solveAfter methods are provided for mimicking the LP stateful interaction on a stateless request channel, fast-forwarding to the N+1 solution AfterN.

Finally, the reset primitive resets the resolution process, with no need to reconfigure the service (i.e., re-select the goal); in contrast, the close primitive actually closes the communication with the server, so the goal must be re-set before re-querying the server.

STATIC KNOWLEDGE BASE Stateless Stateful getServiceConfiguration(-ConfigList) getTheory(-Theory) getGoals(-GoalList) isGoal(+Goal) setGoal(template(+Template)) setGoal(index(+Index)) solve(+Goal, -Solution) solve(-Solution) solveN(+Goal, +NSol, -SolutionList) solveN(+N, -SolutionList) solveAll(+Goal, -SolutionList) solveAll(-SolutionList) solve(+Goal, -Solution, within(+Time)) solve(-Solution, within(+Time)) solveN(+Goal, +NSol, -SolutionList, within(+Time)) solveN(+NSol, -SolutionList, within(+Time)) solveAll(+Goal, -SolutionList, within(+Time)) solveAll(-SolutionList, within(+Time)) solveAfter(+Goal, +AfterN, -Solution) solveNAfter(+Goal, +AfterN, +NSol, -SolutionList) solveAllAfter(+Goal, +AfterN, -SolutionList) solve(-Solution, every(@Time)) solveN(+N, -SolutionList, every(@Time)) solveAll(-SolutionList, every(@Time)) pause() resume() reset() close() DYNAMIC KNOWLEDGE BASE Stateless Stateful getServiceConfiguration(-ConfigList) getTheory(-Theory, ?Timestamp) getGoals(-GoalList) isGoal(+Goal) setGoal(template(+Template)) setGoal(index(+Index)) solve(+Goal, -Solution, ?Timestamp) solve(-Solution, ?Timestamp) solveN(+Goal, +NSol, -SList, ?TimeStamp) solveN(+N, -SolutionList, ?TimeStamp) solveAll(+Goal, -SList, ?TimeStamp) solveAll(-SolutionList, ?TimeStamp) solve(+Goal, -Solution, within(+Time), ?TimeStamp) solve(-Solution, within(+Time), ?TimeStamp) solveN(+Goal, +NSol, -SList, within(+Time), ?TimeStamp) solveN(+NSol, -SList, within(+Time), ?TimeStamp) solveAll(+Goal, -SList, within(+Time), ?TimeStamp) solveAll(-SList, within(+Time), ?TimeStamp) solveAfter(+Goal, +AfterN, -Solution, ?TimeStamp) solveNAfter(+Goal, +AfterN, +NSol, -SList, ?TimeStamp) solveAllAfter(+Goal, +AfterN, -SList, ?TimeStamp) solve(-Solution, every(@Time), ?TimeStamp) solveN(+N, -SList, every(@Time), ?TimeStamp) solveAll(-SList, every(@Time), ?TimeStamp) pause() resume() reset() close()
Table 2: Client Interface

5.2 Computational Model


Figure 3: The Finite State Machine


The computational model of the service is depicted by the Finite State Machine (FSM) in stateMachine, made of four states:

  • ready (initial state) — where the service is started and the engine is configured;

  • run — where the service is undergoing some resolution process triggered by queries;

  • pause — representing the temporary suspension of computations;

  • no goal selected (final state) — when the client connection is closed.

In the ready state, the service can be queried about its properties and a new goal can be set, thus defining a new resolution process. When a new query is submitted, the service moves to the run state, indicating that a resolution process is taking place. Computation may then be paused several times, causing the service to move back and forth from the pause state: from there, resolution can also be reset (coming back to the initial state), or closed (moving to state no goal selected).

6 in

casestudy To test the effectiveness of the proposed model and architecture, we implement a first prototype of as a RESTful Web Service (WS) [Fielding and Taylor (2002)], embracing the Web of Things () vision [Heuer et al. (2015)]. Accordingly, our approach follows the perspective in re-interpreting the “things” (as well as their functionalities and data streams) as RESTful resources accessible through WS protocols, addressing the need to harmonically exploit all the components of the system by virtualising individual things in some sort of software abstraction. There, each interaction session starts with a client request conveying the so-called “method” information (i.e. how the receiver has to process the request) and the “scope” information (i.e. which is the target data). Then, computations occur on the receiving side, where the target resource applies the method to the scope. The result is a response conveying an optional representation of the requested resource (functionality or data).

The computational model of the prototype reflects the state machine described in stateMachine. We reuse and adapt patterns commonly used for the REST architectural style, and introduce a novel architecture which supports the embedding of engines into WS. WSarch (left) shows the general architecture of the server side and its components (access interfaces, engine, and data store), as well as some exemplary client applications interacting via HTTP requests and JSON objects.

Figure 4: The RESTful Web Service (left) and Server architecture (right)

WSarch (right) shows the server inner architecture, composed of three logical layers: the interface, the business logic, and the data layer. The interface layer encapsulates the Configurator and Client interfaces. The business logic layer wraps the engine with the aim of managing incoming requests consistently. The data layer is responsible for managing the data store tracking, i.e., all the configuration options necessary to restore the service in case of unpredictable shutdown (i.e., operating parameters and security metadata such as clients’ role, username, password).

Since those data are expected to be rather limited in size for most scenarios, we choose to keep them in the server application so as to offer a light-weight, self-contained service: however, they could be easily moved to a separate persistence layer on, i.e., an external DB application, if necessary.

The server implementation is realised by exploiting a plurality of technologies that are commonly found in the field: the business logic is realised on the J2EE framework [J2EE (2017)], exploiting EJB [EJB (2017)], while the database interaction is implemented on top of JPA [Java Persistence API (2017)].

Figure 5: Client Server Interaction – Inner calls


The engine is implemented on top of the system [Denti et al. (2001)], which provides not only a light-weight engine, particularly well-suited for the envisioned pervasive computing scenarios, but also a multi-paradigm and multi-language working environment, paving the way towards further forms of interaction and expressiveness. Also, 3.2 supports JSON serialisation natively, ensuring the interoperability required by a WS. The engine, distributed as a Java JAR or Microsoft .NET DLL, is easily deployable and exploitable by applications as a library service—that is, from a software engineering standpoint, a suitably encapsulated set of related functionalities.

ClientServerInteraction shows a client-server interaction in case of a stateless request. The StatelessEngine component, realised exploiting a Stateless Bean, wraps the engine object to manage the concurrent requests transparently.

The service interfaces exploit the EJB architecture, but can also be accessed as RESTful Web Services, realised using JAX-RS Java Standard implemented in the Jersey library [Jersey (2017)]. Security is based on JOSE [jose.4.j (2017)], an open source (Apache 2.0) implementation of JWT and the JOSE specification suite. The application is deployed using the Payara Application Server [Payara (2017)], a Glassfish open-source fork.

6.1 -as-a-Service in action

2P-aaS The -as-a-Service prototype is freely available on Bitbucket [ (2018)] with the corresponding installation guide.

Two different prototype implementations are provided: as a RESTful Web Service, and as an agent in an agent society

(MAS), both built on top of the system which provides the required interoperability and customisation. The first aims to emphasise how can effectively support REST, probably the most typical paradigm, while the second means to highlight the effectiveness in supporting and promoting distributed situated intelligence.

The concrete implementations are discussed in detail in lpaas-icnsc2017, lpaas-ijgug2018. In lpaas-icnsc2017, a Smart Bathroom is supposed to monitor physiological functions to deduce symptoms and diseases, alerting the user via an Android app as appropriate: local sensors could perform situated reasoning, applying their local knowledge to aggregate the raw data and produce higher level synthesised information. lpaas-ijgug2018, instead, discusses a Smart Kitchen where devices provide information about food supply and users’ preferences, generating high-level knowledge used to coordinate and collaborate with other entities in the system.

7 Case Study and Discussion


The following section is meant to illustrate the approach and its benefits by means of a running example in the Smart House field: then, we compare the result with a more traditional LP approach.

The case study concerns the automatic assembly of home furniture by a domestic robot. The robot is in charge of the assembly operation, and the furniture pieces are supposed to be augmented with some form of computational capability—from simple RFID tags for being discoverable, up to embedded chips to store data and perform simple inference tasks. The key aspect is that the installation instruction, the location, and the assembly constraints (such as avoid putting heavy things on fragile walls) are not known in advance by the robot itself, and have to be derived by suitably exploiting situated knowledge.

Figure 6: home: case study


As shown in plant, the envisioned system features the following actors:

  • the Designer agent, hosted in the Cloud, owner of and responsible for the house design project;

  • the Assembler robotic agent, responsible for assembling the furniture;

  • SmartFurniture agents, owners of and responsible for storing and making available their own assembly instructions (i.e. the “Billy” bookshelf provides installation instructions for itself only);

  • SmartWall agents, each responsible for knowing the structural properties of a given wall (i.e. materials of constructions, maximum allowable weight, etc.).

The Assembler acts like a human with the goal of assembling all the furniture in the house according to the envisioned design, but conscious of the unexpected contingencies that may arise (fragile walls, wrong measures, etc.). Moreover, exactly like a human, it does not know how to assemble a given piece of furniture in advance—it needs the installation instructions. Accordingly, the Assembler first acquires the procedural knowledge it needs – essentially, the set of plans for assembling the furniture of interest – by exploiting the intelligence embedded in the surrounding environmental structures (the walls, the ceiling, the floor) and furniture. To this end, the Assembler needs not to be a full-fledged agent, but can be a much simpler client, with just the capability of requesting the service. Its (normal) workflow is thus as follows:

  • once in a room, it selects a wall and asks the Designer which pieces of furniture are to be positioned against that wall;

  • then, it starts discovering the agents representing such pieces, and asks them the pre-conditions they need for a successful assembly—i.e., about the structural properties the wall should have, or any other relevant property;

  • then, the Assembler interacts with the targeted SmartWall agent to check if such pre-conditions are satisfied—notice that this check is delegated to the wall itself, which is the only one bearing the situated knowledge needed to effectively evaluate the feasibility of the design project.

In case of unforeseen situations, the SmartWall agent proposes an alternative disposition of the furniture, that would be possibly implemented by the Assembler if the Planner agrees. Yet again, the Assembler simply exploits the situated intelligence of the services in its surroundings. We would like to emphasise that this is the only way in which the same simple robot may be able to assemble (in principle) an unbounded number of heterogeneous pieces of furniture in all sorts of different walls, ceilings, floors, without hard-coding the instructions in its knowledge base, design update/patch mechanisms, or resort to code-on-demand features.

This is the kind of situated scenarios that is most suited for, especially if compared with traditional LP approaches. There, in fact, the robot would be in need of storing its own knowledge base – the logic theory – describing how to build the furniture, how to match the single pieces of furniture against walls, ceilings, etc., and overall the whole home project. Besides leading to undesired centralisation and to a monolithic design, the most negative effect of such an approach is that the robot would be unable to work with new, unknown kinds of furniture—ultimately hindering flexibility, extensibility, and maintainability over time.

Figure 7: Example of agents interaction


An example run is shown in agentInteraction:

  • fixing the library to the wall requires two deep holes, but one of them cannot be done due to a chimney (detected by the SmartWall agent)

  • the SmartWall then, undertaking an inference step on its own knowledge base, proposes an alternative solution (i.e. to move the position of the hole of 30cm), which is then implemented by the Assembler after the Designer’s approval.

It is worth noting that all the SmartFurniture and SmartWall agents implement, respectively, the same service – that is, all SmartFurniture agents answer the same queries, and all SmartWall agents do the same for their own set of queries –; however, the answer, unlike traditional LP, could be different because of the surrounding situation. For instance, given the query wallMaterialSpecification(M, position(X,Y)), agent SmartWall001, responsible for wall #1, based on its wall material could reply M/‘drywall with available wood stud’, while agent SmartWall002, responsible for a different wall with different characteristics, could reply M/‘masonry’.

Despite its simplicity, the case study above highlights the effectiveness of the approach in spreading intelligence in pervasive systems enabling ubiquitous intelligence. The approach turns out to be particularly interesting when dealing with different contexts, because taking into account local knowledge, situated in time and space, enables the system to take autonomous real time decisions based on the specific situation. Moreover, relying mostly on locally available information reduces both the bandwidth consumption and the need for reliable communications between the distributed components, which are highly-desirable features in scenarios.

Also, modularity and encapsulation of improve scalability of the deployment: in traditional LP, there would be a single LP engine to scale up/down depending on the demand coming from clients, which translates to scaling a singleton monolithic entity as a whole, even if the actual need for scaling only concerns a portion of its functionality—i.e. only queries regarding a given portion of its knowledge base. In instead – provided that the overall LP system functionality has been appropriately designed by distributing sub-functionalities to a set of distributed situated services – whenever any given portion of the LP inference service suffers from excessive demand, only that portion of the system needs to be scaled up—namely, only that service instance.

Another benefit related to modularity and encapsulation is that lends itself to application in real-time scenarios. First of all, splitting out the LP service in multiple, smaller instances, responsible for a well-defined portion of the knowledge needed by the application at hand, helps achieving greater performance while doing inference, compared to traditional LP. Second, time-awareness of helps dealing with time-related aspects, such as discarding obsolete knowledge, ignore old requests, setting temporal bounds on the resolution process, etc. Third, the -oriented perspective according to which clients do not need assert/retract mechanisms for manipulating the LP service knowledge base, because that functionality is envisioned for situated sensors and actuators directly interacting with the service through a dedicated API, helps ensuring that each LP service instance is always up-to-date with the state of the local world as per sensors’ perceptions.

Nevertheless, we would like to point out that a real-time deployment of the currently available prototypes – the RESTful and MAS-oriented implementations – has not yet been experimented, thus the above discussion is mostly based on speculation.

8 Related Work


The SOA paradigm is widely used in scenarios [Messina et al. (2017), Karnouskos et al. (2012), Cannata et al. (2010), Guinard et al. (2010), Guinard et al. (2010), Pontelli et al. (2008)]. Moreover, communication via REST enables the direct integration of SOA-ready devices (i.e. devices hosting native web services).

MobIoT [Hachem et al. (2014)] provides efficient service discovery, composition, and access in heterogeneous, dynamic, mobile contexts, revisiting the standard SOA approach by providing probabilistic registration, look-up and thing-based composition based on comprehensive ontologies. However, it does not support runtime interaction with users to let them specify their goals, and still needs proper validation from the scalability viewpoint when the number of registered services is very large.

pontelli2008 present a comprehensive LP framework designed to support intelligent composition of Web services. The work proposes a theoretical framework for reasoning with heterogeneous knowledge bases, which can be combined with logic programming-based planners for Web service composition. The framework makes a step towards the interoperation between knowledge bases encoded using different rule markup languages and the integration of different components that reason about knowledge bases. Unlike our framework, the system is not focused on situated reasoning: rather, it is mainly concerned about dealing with heterogeneous Web services in the context of the WS composition problems.

A novel approach for engineering systems is proposed by Alkhabbas2017, where a set of things with their functionalities and services is connected and led to cooperate temporarily so as to achieve a given goal. Moreover, many research work deal with event-driven SOA (EDA-SOA) [Schulte and Natis (2003), Michelson (2006)] — where communication between users, applications and services is carried out by events, rather than using remote procedure calls. In particular Prado2017 propose an event-driven SOA which provides context awareness in the scope of , whereby the generation of an event can trigger the concurrent execution of one or more services. When a given event occurs, different services can be triggered automatically, endowing the system with the capability of real-time sensing and rapid response to events in a loosely coupled, distributed computing environment. In general, pure SOA and EDA have their own limitations, but could complement each other; that is, some degree of service coordination can be achieved among mutually-independent services through the event mechanism. As mentioned by Cheng2017, such a complementarity suits well the features of , requiring high autonomy inside a domain and efficient coordination across domains; furthermore, it both improves the real-time response to constantly changing business requirements and minimises the impact on the existing application system to allow a large-scale, distributed service application to be easily developed and maintained.

Many aspects developed in the aforementioned works have worked as sources of inspiration for , in particular in how the model and architecture are conceived and designed. Following the SOA principles, aims at modelling ubiquitous intelligence in a dynamic context by promoting portability and interoperable interaction over a network (via proper standards) and emphasising the separation of the service interface from its implementation. While following the EDA principles, goes beyond the state-of-the-art mainly as far as context-awareness is concerned, in particular by supporting the injection of intelligence within existing services/agents via the awareness of the context, thus promoting their adaptivity.

9 Conclusion & Future Work


In this paper we propose the approach for distributed situated intelligence as the natural evolution of LP in the context of nowadays pervasive computing systems. We discuss its properties and its computational and architectural models by relating and comparing them to the notions and development of LP over the years, tracked in related.

The main advantages of exploiting an LP-based approach in pervasive systems amount at (i) writing declaratively complex rules involving the context, (ii) assessing provable statements about the expressive power and decidability of the context model, and (iii) actually supporting light-weight reasoning and cooperation among distributed components. We also present a first prototype implementation built on top of the system, to demonstrate and test the effectiveness of the approach.

Our service-based approach, in particular, (i) encourages representing and reasoning with situations using a declarative language, providing a high level of abstraction; (ii) supports the incremental construction of context-aware systems by providing modularity and separation of concerns; (iii) promotes the cooperation and interoperation among the different entities of a pervasive system; and (iv) enables reasoning over data streams, like those collected by sensors.

Of course, a number of enhancements are still possible, both to the model and to the infrastructure. From the model viewpoint, specific space-awareness methods could be defined and added: for instance, a solveNeighbours primitive to deal with the space around either the client or the server, making it possible to opportunistically federate LP engines upon need as a form of dynamic service composition. From the infrastructure viewpoint, we plan to focus on the design and implementation of a specialised LP-oriented middleware, dealing with heterogeneity of platforms as well as with distribution, life-cycle, interoperability, and coordination of multiple situated engines – possibly based on the existing technology and middleware [Omicini and Zambonelli (1999)] – so as to explore the full potential of logic-based technologies in scenarios and applications. Also, providing some sort of distributed service directories enabling dynamic discovery of services – in turn promoting opportunistic interactions with clients or other services (for service composition) – is surely a promising path to follow to further widen the applicability of the approach in pervasive scenarios.


  • Alkhabbas et al. (2017) Alkhabbas, F., Spalazzese, R., and Davidsson, P. 2017. Architecting emergent configurations in the Internet of Things. In 2017 IEEE International Conference on Software Architecture (ICSA). IEEE, Los Alamitos, CA, USA, 221–224.
  • Bettini et al. (2010) Bettini, C., Brdiczka, O., Henricksen, K., Indulska, J., Nicklas, D., Ranganathan, A., and Riboni, D. 2010. A survey of context modelling and reasoning techniques. Pervasive and Mobile Computing 6, 2, 161–180. Context Modelling, Reasoning and Management.
  • Brogi and Ciancarini (1991) Brogi, A. and Ciancarini, P. 1991. The concurrent language, Shared Prolog. ACM Transactions on Programming Languages and Systems 13, 1 (Jan.), 99–123.
  • Brogi and Gorrieri (1989) Brogi, A. and Gorrieri, R. 1989. A distributed, net oriented semantics for Delta Prolog. In International Joint Conference on Theory and Practice of Software Development (TAPSOFT ’89), J. Díaz and F. Orejas, Eds. Lecture Notes in Computer Science, vol. 351. Springer, Berlin Heidelberg, 162–177.
  • Brownlee (2011) Brownlee, J. 2011. Clever algorithms: nature-inspired programming recipes. Lulu Press, Morrisville, NC, USA.
  • Bugliesi et al. (1994) Bugliesi, M., Lamma, E., and Mello, P. 1994. Modularity in logic programming. Journal of Logic Programming 19–20, 443–502. Special Issue: Ten Years of Logic Programming.
  • Calegari et al. (2018) Calegari, R., Denti, E., Dovier, A., and Omicini, A. 2018. Extending logic programming with labelled variables: Model and semantics. Fundamenta Informaticae 161, 53–74.
  • Calegari et al. (2017) Calegari, R., Denti, E., Mariani, S., and Omicini, A. 2017. Logic Programming as a Service (LPaaS): Intelligence for the IoT. In 2017 IEEE 14th International Conference on Networking, Sensing and Control (ICNSC 2017), G. Fortino, M. Zhou, Z. Lukszo, A. V. Vasilakos, F. Basile, C. Palau, A. Liotta, M. P. Fanti, A. Guerrieri, and A. Vinci, Eds. IEEE, Los Alamitos, CA, USA, 72–77.
  • Calegari et al. (2018) Calegari, R., Denti, E., Mariani, S., and Omicini, A. 2018. Logic programming as a service in multi-agent systems for the Internet of Things. International Journal of Grid and Utility Computing (in press).
  • Cannata et al. (2010) Cannata, A., Karnouskos, S., and Taisch, M. 2010. Evaluating the potential of a service oriented infrastructure for the factory of the future. In 8th IEEE International Conference on Industrial Informatics (INDIN 2010). IEEE, Los Alamitos, CA, USA, 592–597.
  • Chen et al. (2003) Chen, H., Finin, T., and Joshi, A. 2003. An ontology for context-aware pervasive computing environments.

    The Knowledge Engineering Review

     18, 3 (Sept.), 197–207.
  • Cheng et al. (2017) Cheng, B., Wang, M., Zhao, S., Zhai, Z., Zhu, D., and Chen, J. 2017. Situation-aware dynamic service coordination in an IoT environment. IEEE/ACM Transactions on Networking 25, 4 (Aug.), 2082–2095.
  • Clark (1978) Clark, K. L. 1978. Negation as failure. See Gallaire and Minker (1978), 293–322.
  • Clark (1987) Clark, K. L. 1987. PARLOG: The language and its applications. In PARLE Parallel Architectures and Languages Europe. Volume II: Parallel Languages. Eindhoven, The Netherlands, 15–19 June 1987. Proceedings, J. W. de Bakker, A. J. Nijman, and P. C. Treleaven, Eds. Lecture Notes in Computer Science, vol. 259. Springer, Berlin, Heidelberg, 30–53.
  • Clark and Gregory (1981) Clark, K. L. and Gregory, S. 1981. A relational language for parallel programming. In 1981 Conference on Functional Programming Languages and Computer Architecture (FPCA ’81). ACM, New York, NY, USA, 171–178.
  • Cunha et al. (1989) Cunha, J. C., Ferreira, M. C., and Pereira, L. M. 1989. Programming in Delta Prolog. In Logic Programming, Proceedings of the 6th International Conference (ICLP 1989), Lisbon, Portugal, 19-23 June 1989, G. Levi and M. Martelli, Eds. MIT Press, Cambridge, MA, USA, 487–504.
  • Cusumano (2010) Cusumano, M. 2010. Cloud computing and SaaS as new computing platforms. Communications of the ACM 53, 4 (Apr.), 27–29.
  • Denti et al. (2001) Denti, E., Omicini, A., and Ricci, A. 2001. tuProlog: A light-weight Prolog for Internet applications and infrastructures. In Practical Aspects of Declarative Languages. 3rd International Symposium (PADL 2001), Las Vegas, NV, USA, 11–12 Mar. 2001, Proceedings, I. V. Ramakrishnan, Ed. Lecture Notes in Computer Science, vol. 1990. Springer, Berlin, Heidelberg, 184–198.
  • Deransart et al. (1996) Deransart, P., Ed-Dbali, A., and Cervoni, L. 1996. Prolog: The Standard. Reference Manual. Springer, Berlin, Heidelberg.
  • Dey (2001) Dey, A. K. 2001. Understanding and using context. Personal and Ubiquitous Computing 5, 1 (Jan.), 4–7.
  • EJB (2017) EJB. 2017. Home Page. http://www.oracle.com/technetwork/java/javaee/ejb/.
  • Erl (2005) Erl, T. 2005. Service-Oriented Architecture: Concepts, Technology, and Design. Prentice Hall / Pearson Education International, Upper Saddle River, NJ, USA.
  • Etter et al. (2006) Etter, R., Costa, P. D., and Broens, T. 2006. A rule-based approach towards context-aware user notification services. In 2006 ACS/IEEE International Conference on Pervasive Services (ICPS 2006). IEEE, Lyon, France, 281–284.
  • Familiar (2015) Familiar, B. 2015. Microservices, IoT, and Azure: Leveraging DevOps and Microservice Architecture to Deliver SaaS Solutions, 1st ed. Apress, Berkely, CA, USA.
  • Fielding and Taylor (2002) Fielding, R. T. and Taylor, R. N. 2002. Principled design of the modern Web architecture. ACM Transactions on Internet Technology 2, 2 (May), 115–150.
  • Finin et al. (2001) Finin, T., Joshi, A., Kagal, L., Ratsimore, O., Korolev, V., and Chen, H. 2001. Information agents for mobile and embedded devices. In Cooperative Information Agents V. 5th InternationalWorkshop (CIA 2001), Modena, Italy, 6–8 May 2001. Proceedings, M. Klusch and F. Zambonelli, Eds. Springer, Berlin, Heidelberg, 264–286.
  • Gallaire and Minker (1978) Gallaire, H. and Minker, J., Eds. 1978. Logic and Data Bases. Springer, Boston, MA, USA.
  • Gelernter (1985) Gelernter, D. 1985. Generative communication in Linda. ACM Transactions on Programming Languages and Systems 7, 1 (Jan.), 80–112.
  • Guinard et al. (2010) Guinard, D., Trifa, V., Karnouskos, S., Spiess, P., and Savio, D. 2010. Interacting with the SOA-based Internet of Things: Discovery, query, selection, and on-demand provisioning of Web Services. IEEE Transactions on Services Computing 3, 3 (July), 223–235.
  • Guinard et al. (2010) Guinard, D., Trifa, V., and Wilde, E. 2010. A resource oriented architecture for the Web of Things. In 2010 Internet of Things (IOT). IEEE, Los Alamitos, CA, USA, 1–8.
  • Hachem et al. (2014) Hachem, S., Pathak, A., and Issarny, V. 2014. Service-oriented middleware for large-scale mobile participatory sensing. Pervasive and Mobile Computing 10, 66–82. Selected Papers from the Eleventh Annual IEEE International Conference on Pervasive Computing and Communications (PerCom 2013).
  • Heuer et al. (2015) Heuer, J., Hund, J., and Pfaff, O. 2015. Toward the Web of Things: Applying web technologies to the physical world. Computer 48, 5 (May), 34–42.
  • Hu et al. (2012) Hu, B., Wang, Z., and Dong, Q. 2012. A modeling and reasoning approach using description logic for context-aware pervasive computing. In

    Emerging Research in Artificial Intelligence and Computational Intelligence: International Conference, AICI 2012, Chengdu, China, October 26-28, 2012. Proceedings

    , J. Lei, F. L. Wang, H. Deng, and D. Miao, Eds. Communications in Computer and Information Science, vol. 315. Springer, Berlin, Heidelberg, 155–165.
  • J2EE (2017) J2EE. 2017. Home Page. http://www.oracle.com/technetwork/java/javaee/.
  • Java Persistence API (2017) Java Persistence API. 2017. Home Page. http://docs.oracle.com/javaee/6/tutorial/doc/bnbpz.html.
  • Jersey (2017) Jersey. 2017. Home Page. http://jersey.java.net.
  • jose.4.j (2017) jose.4.j. 2017. Home Page. http://bitbucket.org/b_c/jose4j/.
  • JSON (2017) JSON. 2017. Home Page. http://www.json.org.
  • Karnouskos et al. (2012) Karnouskos, S., Colombo, A. W., Bangemann, T., Manninen, K., Camp, R., Tilly, M., Stluka, P., Jammes, F., Delsing, J., and Eliasson, J. 2012. A SOA-based architecture for empowering future collaborative cloud-based industrial automation. In 38th Annual Conference on IEEE Industrial Electronics Society (IECON 2012). IEEE, Los Alamitos, CA, USA, 5766–5772.
  • Loke (2004) Loke, S. W. 2004. Representing and reasoning with situations for context-aware pervasive computing: a logic programming perspective. The Knowledge Engineering Review 19, 3 (Sept.), 213–233.
  • (2018) . 2018. Home page. http://lpaas.apice.unibo.it.
  • Mariani and Omicini (2015) Mariani, S. and Omicini, A. 2015. Coordinating activities and change: An event-driven architecture for situated MAS. Engineering Applications of Artificial Intelligence 41, 298–309.
  • Martelli (1995) Martelli, M. 1995. Constraint logic programming: Theory and applications. In 1985-1995: Ten years of Logic Programming in Italy, M. Sessa, Ed. Palladio Editrice, Salerno, Italy, 137–166.
  • Messina et al. (2017) Messina, F., Mikkilineni, R., and Morana, G. 2017. Middleware, framework and novel computing models for grid and cloud service orchestration. International Journal of Grid and Utility Computing 8, 71.
  • Michelson (2006) Michelson, B. M. 2006. Event-driven architecture overview: Event-driven SOA is just part of the EDA story. Report, Patricia Seybold Group. Feb.
  • Monteiro (1984) Monteiro, L. 1984. A proposal for distributed programming in logic. In Implementations of Prolog, J. A. Campbell, Ed. Artificial Intelligence. Ellis Horwood Limited, Chicester, UK, 329–340.
  • MQTT (2017) MQTT. 2017. Home Page. http://mqtt.org.
  • Naish (1988) Naish, L. 1988. Parallelizing NU-Prolog. In Logic Programming, Proceedings of the 5th International Conference and Symposium, Seattle, Washington, 15-19 Aug. 1988, R. A. Kowalski and K. A. Bowen, Eds. MIT Press, Cambridge, MA, USA, 1546–1564.
  • Nalepa and Bobek (2014) Nalepa, G. J. and Bobek, S. 2014. Rule-based solution for context-aware reasoning on mobile devices. Computer Science and Information Systems 11, 1, 171–193.
  • Niezen (2013) Niezen, G. 2013. Ontologies for interaction: Enabling serendipitous interoperability in smart environments. Journal of Ambient Intelligence and Smart Environments 5, 1 (Jan.), 135–137.
  • Nii (1986) Nii, H. P. 1986. The blackboard model of problem solving and the evolution of blackboard architectures. The AI Magazine 7, 2 (Summer), 38–106.
  • Oliya and Pung (2011) Oliya, M. and Pung, H. K. 2011. Towards incremental reasoning for context aware systems. In Advances in Computing and Communications: First International Conference, ACC 2011, Kochi, India, July 22-24, 2011. Proceedings, Part I, A. Abraham, J. Lloret Mauri, J. F. Buford, J. Suzuki, and S. M. Thampi, Eds. Communications in Computer and Information Science, vol. 190. Springer, Berlin, Heidelberg, 232–241.
  • Omicini and Zambonelli (1999) Omicini, A. and Zambonelli, F. 1999. Coordination for Internet application development. Autonomous Agents and Multi-Agent Systems 2, 3 (Sept.), 251–269. Special Issue: Coordination Mechanisms for Web Agents.
  • Palù and Torroni (2010) Palù, A. D. and Torroni, P. 2010. 25 years of applications of logic programming in Italy. In A 25-Year Perspective on Logic Programming, A. Dovier and E. Pontelli, Eds. Springer, Berlin, Heidelberg, 300–328.
  • Parker (2008) Parker, L. E. 2008. Distributed intelligence: Overview of the field and its application in multi-robot systems. Journal of Physical Agents 2, 1, 5–14.
  • Payara (2017) Payara. 2017. Home Page. http://www.payara.fish.
  • Pontelli et al. (2008) Pontelli, E., Cao Son, T., and Baral, C. 2008. A logic programming based framework for intelligent Web Service composition. In Managing Web Service Quality: Measuring Outcomes and Effectiveness. IGI Global, Hershey, PA, USA, 193–221.
  • Prado et al. (2017) Prado, A. G. D., Ortiz, G., and Boubeta-Puig, J. 2017. CARED-SOA: A context-aware event-driven service-oriented architecture. IEEE Access 5, 4646–4663.
  • Ranganathan et al. (2004) Ranganathan, A., Al-Muhtadi, J., and Campbell, R. H. 2004. Reasoning about uncertain contexts in pervasive computing environments. IEEE Pervasive Computing 3, 2 (Apr.), 62–70.
  • Ranganathan and Campbell (2003) Ranganathan, A. and Campbell, R. H. 2003. An infrastructure for context-awareness based on first order logic. Personal and Ubiquitous Computing 7, 6 (Dec.), 353–364.
  • Reiter (1978) Reiter, R. 1978. On closed world data bases. See Gallaire and Minker (1978), 55–76.
  • Ricci et al. (2017) Ricci, A., Viroli, M., Omicini, A., Mariani, S., Croatti, A., and Pianini, D. 2017. Spatial Tuples: Augmenting physical reality with tuple spaces. In Intelligent Distributed Computing X. Proceedings of the 10th International Symposium on Intelligent Distributed Computing – IDC 2016, Paris, France, October 10-12 2016, C. Badica, A. El Fallah Seghrouchni, A. Beynier, D. Camacho, C. Herpson, K. Hindriks, and P. Novais, Eds. Studies in Computational Intelligence, vol. 678. Springer, Berlin, Heidelberg, 121–130.
  • Richards (2016) Richards, M. 2016. Microservices AntiPatterns and Pitfalls. O’Reilly, Sebastopol, CA, USA.
  • Robinson (1965) Robinson, J. A. 1965. A machine-oriented logic based on the resolution principle. Journal of the ACM 12, 1 (Jan.), 23–41.
  • Salber et al. (1999) Salber, D., Dey, A. K., and Abowd, G. D. 1999. The context toolkit: Aiding the development of context-enabled applications. In SIGCHI Conference on Human Factors in Computing Systems (CHI ’99). ACM, New York, NY, USA, 434–441.
  • Schulte and Natis (2003) Schulte, R. W. and Natis, Y. V. 2003. Event-driven architecture complements SOA. Research note, Gartner. 8 July.
  • Shapiro (1987) Shapiro, E. Y. 1987. Concurrent Prolog – Vol. 1: Collected Papers. Logic Programming. The MIT Press, Cambridge, MA, USA.
  • Smart (2017) Smart, P. 2017. Situating machine intelligence within the cognitive ecology of the Internet. Minds and Machines 27, 2 (June), 357–380.
  • Ueda (1986) Ueda, K. 1986. Guarded Horn clauses. In Logic Programming ’85. Proceedings of the 4th Conference Tokyo, Japan, 1–3 July 1985, E. Wada, Ed. Lecture Notes in Computer Science, vol. 221. Springer, Berlin, Heidelberg, 168–179.
  • Wang et al. (2011) Wang, H., Mehta, R., Supakkul, S., and Chung, L. 2011. Rule-based context-aware adaptation using a goal-oriented ontology. In 2011 International Workshop on Situation Activity & Goal Awareness (SAGAware ’11). ACM, New York, NY, USA, 67–76.
  • Wolfram et al. (1984) Wolfram, D. A., Maher, M. J., and Lassez, J.-L. 1984. A unified treatment of resolution strategies for logic programs. In 2nd International Conference on Logic Programming (ICLP 1984), S.-Å. Tärnlund, Ed. Association for Logic Programming, Uppsala, Sweden, 263–276.
  • Zambonelli et al. (2015) Zambonelli, F., Omicini, A., Anzengruber, B., Castelli, G., DeAngelis, F. L., Di Marzo Serugendo, G., Dobson, S., Fernandez-Marquez, J. L., Ferscha, A., Mamei, M., Mariani, S., Molesini, A., Montagna, S., Nieminen, J., Pianini, D., Risoldi, M., Rosi, A., Stevenson, G., Viroli, M., and Ye, J. 2015. Developing pervasive multi-agent systems with nature-inspired coordination. Pervasive and Mobile Computing 17, 236–252. Special Issue “10 years of Pervasive Computing” In Honor of Chatschik Bisdikian.