Giulio Piancastelli

simpA: An agent-oriented approach for programming concurrent applications on top of Java

More and more aspects of concurrency and concurrent programming are becoming part of mainstream programming and software engineering, due to several factors such as the widespread availability of multi-core/parallel architectures and Internet-based systems. This leads to the extension of mainstream object-oriented programming languages and platforms-Java is a main example-with libraries providing fine-grained mechanisms and idioms to support concurrent programming, in particular for building efficient programs. Besides this fine-grained support, a main research goal in this context is to devise higher-level, coarse-grained abstractions that would help building concurrent programs, as pure object-oriented abstractions help building large component-based programs. To this end, in this paper we present simpA, a Java-based framework that provides programmers with agent-oriented abstractions on top of the basic OO layer, as a means to organize and structure concurrent applications. We first describe the application programming interface (API) and annotation framework provided to Java programmers for building simpA applications, and then we discuss the main features of the approach from a software engineering point of view, by showing some programming examples. Finally, we define an operational semantics formalizing the main aspects of this programming model.

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-grainedconcurrency 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-orientedabstraction layer on top of the basic OO layer to organize and structure applications.

The architecture and design of a malleable object-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 - rather than maximum - 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---such as easy deployability, lightness, and configurability. In this paper, we first describe tuPrologs 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.

Agent-Oriented Programming for Client-Side Concurrent Web 2.0 Applications

Using the event-driven programming style of JavaScript to develop the concurrent and highly interactive client-side of Web 2.0 applications is showing more and more shortcomings in terms of engineering properties such as reusability and maintainability. Additional libraries, frameworks, and AJAX techniques do not help reduce the gap between the single-threaded JavaScript model and the concurrency needs of applications. We propose to exploit a different programming model based on a new agent-oriented abstraction layer, where first-class entities – namely agents and artifacts – can be used, respectively, to capture concurrency of activities and their interaction, and to represent tools and resources used by agents during their activities. We specialise the model in the context of client-side Web development, by characterising common domain agents and artifacts that form an extension of an existing programming framework. Finally, we design and implement a simple but significant case study to showcase the capabilities of the model and verify the feasibility of the technology.

Context-Dependent Evaluation Methodology for Open Source Software

Many evaluation methodologies have been proposed to mitigate the risks of choosing Open Source Software as an effective solution to an enterprise’s problem. This work extracts the shared traits from the most important and widely known evaluation models, and re-applies them to create a new methodology. This methodology has been designed both to be used for the creation of a common knowledge base, and to be specialized for application in the context of the particular breed of smalland medium-size enterprises found on the Italian ground.

A Multi-theory Logic Language for the World Wide Web

Despite the recent formalization of the Web in terms of Representational State Transfer (REST) architectural style and Resource-Oriented Architecture (ROA), current tools for Web programming generally misunderstand its design. Based on REST/ROA insights, we claim that logic languages are suited for promoting the Web architecture and principles. The mapping of REST/ROA abstractions onto elements of Contextual Logic Programming also permits runtime modification of resource behavior. In this paper we present Web Logic Programming as a Prolog-based language for the Web embedding REST/ROA principles, meant to be the basis of an application framework for rapid prototyping.

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 prin- ciples. 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.