A Multi-Theory Logic Programming Language for the World Wide Web

Despite the World Wide Web recent architectural formalization in terms of Representational State Transfer (REST) architectural style and Resource-Oriented Architecture (ROA), current languages and tools for Web programming generally suffer from a lack of understanding of its design constraints and from an abstraction mismatch that makes it difficult to fully exploit the Web potential. Based on the insights gained by REST and ROA, we claim that logic languages are well-suited for promoting the Web architecture and principles: in particular, the straightforward mapping of REST and ROA abstractions onto elements of Contextual Logic Programming allows for directly executable logic-based resource representations, as well as dynamic modification of resource behaviour at runtime. Along this line, in this paper we present Web Logic Programming as a Prolog-based language for the World Wide Web embedding the core REST and ROA principles, intended to work as the basis of a framework for the rapid prototyping of Web applications. We define the language operational semantics and discuss some simple but significant programming examples

A Logic Programming model for Web resources

In the latest years, substantial achievements have been obtained in the description and formalization of the architectural principles and design criteria underlying the World Wide Web. First, the Representational State Transfer (REST) architectural style for distributed hypermedia systems was introduced, defining the resource as the key abstraction of information; then, the Resource-Oriented Architecture (ROA) was presented as a REST-based set of guidelines and best practices for implementing services on Web resources. However, a resource programming model is still missing, since procedural and object-oriented web programming focussed on different abstractions, such as page, controller, and service. Instead, we adopt the logic declarative paradigm to define our model for resource-oriented programming, also showing how its peculiar features lead to novel possibilities for dynamic modification and extension of resource behavior at runtime. In this paper, we first map novel REST and ROA abstractions onto elements of structured logic programming. Then, we present Web Logic Programming as a Prolog-based language for the World Wide Web embedding the core REST and ROA principles, by defining its computation model and discussing a bookshelf sharing application example

simpA: A simple agent-oriented Java extension for developing concurrent applications

More and more aspects of concurrency and concurrent programming are becoming part of mainstream programming and software engineering, as a result of several factors, such as the widespread availability of multi-core / parallel architectures and Internet-based systems. Java has been one of the first mainstream languages providing a first-class native support for multi-threading, with basic low level fine-grained concurrency mechanisms. Besides this fine-grained support to concurrency, the identification of higher-level\u2014more coarse-grained\u2014support is important as soon as programming and engineering complex concurrent applications is considered, helping to bridge the gap between system design, implementation and testing. Accordingly, in this paper we present simpA, a library-based extension of Java which introduces a high-level coarse-grained support to prototyping complex, multi-threaded / concurrent applications: Java programmers are provided with an agent-oriented abstraction layer on top of the basic OO layer to organize and structure applications

simpA: A Simple Agent-Oriented Java Extension for Developing Concurrent Applications

Abstract. More and more aspects of concurrency and concurrent programming are becoming part of mainstream programming and software engineering, as a result of several factors, such as the widespread availability of multi-core / parallel architectures and Internet-based systems. Java has been one of the first mainstream languages providing a firstclass native support for multi-threading, with basic low level fine-grained concurrency mechanisms. Besides this fine-grained support to concurrency, the identification of higher-level—more coarse-grained—support is important as soon as programming and engineering complex concurrent applications is considered, helping to bridge the gap between system design, implementation and testing. Accordingly, in this paper we present simpA, a library-based extension of Java which introduces a high-level coarse-grained support to prototyping complex, multi-threaded / concurrent applications: Java programmers are provided with an agent-oriented abstraction layer on top of the basic OO layer to organize and structure applications.

Towards a logic framework for Web programming

Despite the popularity of the World Wide Web as a development platform, a proper description of its architectural principles and design criteria has been established only in the last decade, by the introduction of the REpresentational State Transfer (REST) architectural style, which defines the resource as the key abstraction of information. Languages and tools used for Web programming generally suffer from a lack of proper understanding of its architecture and design constraints, and from an abstraction mismatch that makes it hard to fully exploit the Web potential. Declarative languages are well-suited for a programming system aimed at being respectful of the Web architecture and principles. Among logic technologies, tuProlog has been explicitly designed to be one of the enabling components of Internet-based infrastructures: its engineering properties make it suitable for use on the Web, where logic programming allows modification of resource behaviour at runtime. Accordingly, in this paper we present a Prolog-based logic model for programming Web resources, and outline a framework for developing Web applications grounded on that model

Towards a Logic Language and Framework for Web Programming

Despite the popularity of the World Wide Web as a development platform, a proper description of its architectural principles and design criteria has been achieved only recently, by the introduction of the Representational State Transfer (REST) architectural style which defines the resource as the key abstraction of information. In fact, languages and tools currently used for Web programming gen- erally suffer from a lack of proper understanding of its architecture and design constraints, and from an abstraction mismatch that makes it hard to exploit the Web potential. Declarative languages are well-suited for a programming system aimed at being respectful of the Web architecture and principles. Among logic technologies, tuProlog has been explicitly designed to be one of the enabling components of Internet-based infrastructures: its engineering properties make it suitable for use on the Web, where logic programming allows modification of resource behaviour at runtime. Accordingly, in this paper we present a Prolog-based logic model for programming Web resources, and outline a framework for developing Web applications grounded on that model

The architecture and design of a malleable ob ject-oriented Prolog engine

The implementation of Prolog systems has a long history, from the first interpreter written in 1972 to de facto standard model of the Warren Abstract Machine. Although many architectural variations have been proposed, object-oriented design was left mostly unexplored, favoring other factors such as execution time and memory storage optimizations. However, today complex software systems are typically built as aggregates of heterogeneous components, where logic programming may effectively help facing key issues such as intelligence of components and management of interaction. In this scenario, implementation of logic languages could just aim at reasonable \u2013 rather than maximum \u2013 efficiency, requiring instead configurable and flexible architectures to allow for extensions and tailoring for different application domains. tuProlog is an object-oriented Prolog engine which has been designed to feature a malleable architecture at its core, and to exhibit the typical properties of basic components for complex dynamic systems and intelligent infrastructures\u2014such as easy deployability, lightness, and configurability. In this paper, we first describe tuProlog's malleable architecture, composed by a set of managers controlling sensible parts of the system, and operating around a minimal interpreter shaped as a Finite State Machine. Then, we support the malleability claim by discussing two possible architectural extension of the engine

Engineering Self-Organizing Systems Report for the 2 nd Year of PhD Course Engineering Self-Organizing Systems -Luca Gardelli 2 aliCE People… • Professors • Researchers Engineering Self-Organizing Systems -Luca Gardelli 4 Background and Motivations

Abstract The increasing complexity of artificial systems is a great challenge for the modern engineer. Specifically, aspects like pervasiveness, heterogeneity and distribution are in contrast with the necessity of a greater reliability. The theory of self-organization deals with natural systems, tipically made of several entities locally interacting with each other in order to preserve or increase the system organization upon environment perturbations. After introducing self-organization principles and current developments in the multi-agent systems (MAS) research community, it follows a discussion about our activities in that frame. Specifically, here we concentrate on methodological and architectural aspects: despite the inherent robustness of self-organizing systems, their design creates several problems, in particular predictability and reliability. Then, we analyse these problems exploiting formal modelling and stochastic simulation tools