Davide Rossi

Coordinating multiagent applications on the WWW: a reference architecture

The original Web did not support multiuser, interactive applications. This shortcoming is being studied, and several approaches have been proposed to use the Web as a platform for programming Internet applications. However, most existing approaches are oriented to centralized applications at servers, or local programs within clients. To overcome this deficit, we introduce PageSpace, that is a reference architecture for designing interactive multiagent applications. We describe how we control agents in PageSpace, using variants of the coordination language Linda to guide their interactions. Coordination technology is integrated with the standard Web technology and the programming language Java. Several kinds of agents live in the PageSpace: user interface agents, personal homeagents, agents that implement applications, and agents which interoperate with legacy systems. Within our architecture, it is possible to support fault-tolerance and mobile agents as well.

Jada - Coordination and Communication for Java Agents

In this chapter we are going to analyze mobile code issues in the perspective of object oriented systems in which thread migration is not supported. This means that both objects code and data can be transmitted from a place to another but not the current execution state (if any) associated to the object. This is the case with the Java language which is often used in the Word Wide Web for developing applets which are little applications downloaded on the fly and executed in the client machine. While this mechanism is quite useful for enhancing HTML documents with sound and animation, we think that this technology can give its best in the field of distributed-cooperative work, both in the perspective of Internet and Intranet connectivity. Java is indeed a concurrent, multithreaded language, but it offers little help for distributed programming. Thus, we introduce Jada, a coordination toolkit for Java where coordination among either concurrent threads or distributed Java objects is achieved via shared object spaces. By exchanging objects through tuple spaces, Java programs and applets can exchange data or synchronize their actions over a single host, a LAN, or even the Internet.

SLA-Driven Clustering of QoS-Aware Application Servers

In this paper, we discuss the design, implementation, and experimental evaluation of a middleware architecture for enabling service level agreement (SLA)-driven clustering of QoS-aware application servers. Our middleware architecture supports application server technologies with dynamic resource management: application servers can dynamically change the amount of clustered resources assigned to hosted applications on-demand so as to meet application-level quality of service (QoS) requirements. These requirements can include timeliness, availability, and high throughput and are specified in SLAs. A prototype of our architecture has been implemented using the open-source J2EE application server JBoss. The evaluation of this prototype shows that our approach makes possible JBoss resource usage optimization and allows JBoss to effectively meet the QoS requirements of the applications it hosts, i.e., to honor the SLAs of those applications

Tuple-based technologies for coordination

By tuple-based technologies we refer to any coordination system that uses associative access to shared dataspaces for communication / synchronization purposes.

Designing and architecting process-aware Web applications with EPML

An emerging class of Web applications is driving the evolution of the Web toward a Business System. These applications allow the participation of several actors to complex enterprise-wide (or even multi-enterprise) business processes and pose new challenges to the software designer and to the software architect. In this paper we show how, promoting an effective separation of concerns, a process modeling language and its enactment engine can be used in the modeling and in the implementation of process-aware Web applications.

XLinkProxy: external linkbases with XLink

In the linking model of the World Wide Web each link is stored in the referring document within an attribute of the A tag. All the hyperlink defined this way can reference a single resource or a single fragment. With the evolution of Web technologies more powerful linking languages (XLink and XPointer) have been proposed.Here we introduce XLinkProxy, a Web application that allows sophisticated hyperlink (defined using XLink and XPointer) to be defined outside referring documents, giving users the chance to build dynamic multidestination, multidirectional links databases.

Coordinating Java agents over the WWW

We introduce Jada, a programming toolkit for coordinating agents written in Java. Coordination among either concurrent threads or distributed Java objects is achieved via shared object spaces. By exchanging objects through object spaces, Java agents or applets can exchange data or synchronize their actions over the Internet, a LAN, a single host, or even inside a Java‐enabled browser. The access to an object space is performed using a set of methods of an ObjectSpace object. Such operations inspired by the Linda language are powerful enough to solve several coordination problems. Moreover, we show how Jada can be used as a coordination kernel for more complex coordination architectures.

Redesigning the Web: from passive pages to coordinated agents in PageSpaces

Currently, the Web does not support distributed applications well. Existing approaches are oriented towards centralized applications at servers, or local programs within clients. To overcome this deficit, the PageSpace platform was designed for distributed, coordinated agents in the Web. We take a specific approach to coordinate agents in PageSpace applications, namely variants of coordination language Linda that support rules and services to guide their cooperation. This technology is integrated with the standard Web technology and the language Java. Several kinds of agents live in the PageSpace: user interface agents, personal home agents, the agents that implement applications, and the kernel agents of the platform. Within the architecture it is possible to support fault tolerance and mobile agents as well.

On the Effectiveness of Manual and Automatic Unit Test Generation

The importance of testing has recently seen a significant growth, thanks to its benefits to software design (e.g. think of test-driven development), implementation and maintenance support. As a consequence of this, nowadays it is quite common to introduce a test suite into an existing system, which was not designed for it. The software engineer must then decide whether using tools which automatically generate unit tests (test suites necessary foundations) and how. This paper tries to deal with the issue of choosing the best approach. We will describe how different generation techniques (both manual and automatic) have been applied to a real case study. We will compare achieved results using several metrics in order to identify different approaches benefits and shortcomings. We will conclude showing the measure how the adoption of tools for automatic test creation can shift the trade-off between time and quality.

A multi-agent process centered environment integrated with the WWW

Presents ShaDOW, an environment for supporting the work of teams of software engineers engaged in geographically distributed software processes. Such an environment is designed and implemented over WWW middleware, and can be controlled by standard WWW browsers. Applications of this kind are complex and exciting examples of workflow systems. They need a suitable language to model the process and a suitable coordination architecture to build up the system. The Shade language, a coordination language based on the multiple tuple spaces coordination model, has been used as both process modeling language and as system design language.