Resource pools are collections of computational resources (e.g., servers) which can be used by different applications in a shared way. A crucial aspect in these pools is to allocate resources so as to ensure their proper usage, taking into account workload and specific requirements of each application. An interesting approach, in this context, is to allocate the resources in the best possible way, aiming at optimal resource usage. Workload, however, varies over time, and in turn, resource demands will vary too. To ensure that optimal resource usage is always in place, resource shares should be defined dynamically and over time. It has been claimed that utility functions are the main tool for enabling such self-optimizing behavior. Whereas many solutions with this characteristic have been proposed to date, none of them presents true decentralization within the context of shared pools. In this article, we then propose a decentralized model for optimal resource usage in shared resource pools, providing practical and theoretical evidence of its feasibility.

Software tools are used to compare multiple versions of a textual document to help a reader understand the evolution of that document over time. These tools generally support the comparison of only two versions of a document, requiring multiple comparisons to be made to derive a full history of the document across multiple versions. We present Deep Diffs, a novel visualisation technique that exposes the multiple layers of history of a document at once, directly in the text, highlighting areas that have changed over multiple successive versions, and drawing attention to passages that are new, potentially unpolished or contentious. These composite views facilitate the writing and editing process by assisting memory and encouraging the analysis of collaboratively-authored documents. We describe how this technique effectively supports common text editing tasks and heightens participants' understanding of the process in collaborative editing scenarios like wiki editing and paper writing.

Visualisations of dynamic networks are animated over time, reflecting changes in the underlying data structure. As viewers of these visualisations, it is up to us to accurately perceive and keep up with the constantly shifting view, mentally noting as visual elements are added, removed, changed and rearranged, sometimes at great pace. In a complex data set with a lot happening, this can put a strain on the observer's perceptions, with changes in layout and visual population disrupting their internalised mental model of the visualisation, making it difficult to understand what the changes represent. We present Showtime, a novel visualisation technique which dilates the flow of time so that observers have proportionally more time to understand each change based on the density of activity in the visualisation. This is paired with a novel timeline element which tracks the flow of time visually.

Shared resource pools are facilities featuring a certain amount of resources which can be used by different applications. For managing resources in such pools, the demand of each application can be used. Such a demand, however, is driven by the workload, which varies over time. For that reason, adaptive approaches have been proposed for the management of shared resources pools. Whereas a number of solutions exist in this context, they are either not truly decentralized or do not apply to the problem we are dealing with. In this paper, we then present Darma, an approach for managing shared resource pools in a truly decentralized, adaptive, and optimal way.

Self-managing policies provide a self-management behavior for autonomic systems developed with ASSL (Autonomic System Specification Language). With ASSL we have successfully developed special autonomic prototypes of both the NASA ANTS (Autonomous Nano-Technology Swarm) concept mission and NASAs Voyager Mission. In these prototypes, we applied ASSL self-managing policies to drive the missions in critical situations in response to environmental or system changes. Therefore, the logical correctness of the ASSL specification of such policies appears to be of major importance. Experience has shown, however, that ASSL specifications may contain logical faults causing improper behavior. To handle such behavior, self-managing policies are often tested with manually injected inputs triggering events and satisfying constraints to allow for the activation, execution, and deactivation of these policies. The logical correctness of an ASSL self managing policy currently depends solely upon the relation between inputs and conclusion. In this paper, we present our initial work on a novel tool, part of the ASSL framework, that generates test cases based on change-impact analysis. Our main goal is to reduce testing costs and effort and improve the quality of testing, thus eventually assuring the logical correctness of the self-managing policies developed with ASSL.

As pervasive applications become prevalent in our day-to-day lives, the interactions of service provision and consumption between unknown and strange users are commonplace. Trust and reputation systems play a vital role in such application scenarios. One of the problems is that selfish users are reluctant to render the truthful recommendation without incentive. Even if there are incentives, self-interested users may maximise their profit by falsely declaring their opinions strategically. In this paper, we propose a strategy-proof trust mechanism which is a VCG (Vickrey-Clarke-Groves) mechanism for honest recommendation elicitation. The characteristics of the mechanism, such as the characteristics of social choice function and the properties of the payments, are also discussed. Simulation results show that our mechanism is effective in preventing strategic manipulation and guarantee that selfish users will give honest recommendations.

Highly sensorised systems present two parallel challenges: how to design a sensor suite that can efficiently and cost-effectively support the needs of given services; and to extract the semantically relevant interpretations, or ldquosituationsrdquo, from the flood of context data collected by the sensors. We describe mathematical structures called situation lattices that can be used to address these two problems simultaneously, allowing designers to both design and refine situation identification whilst offering insights into the design of sensor suites. We validate the accuracy and efficiency of our technique against a third-party data set and demonstrate how it can be used to evaluate sensor suite designs.

We present a solid study on the performance of a homological sensor network in partial sensing coverage, which means the network has at least one sensing coverage hole and we demonstrate that when sacrificing a little coverage the system lifetime can be prolonged significantly. In particular, we showed that when there is one sensing coverage hole (with a coverage rate of 97%) the system lifetime can be extended to 3-7 times compared with a full coverage strategy which gives a system lifetime increase with 1.2-3 times only. An algebraic topology tool, homology group, is used in our work to calculate sensing coverage of a sensor network. Unlike other approaches, our method does not need any node location or orientation information and it does not have any assumption about the code deployment control and domain geometry either. The only thing needed to calculate sensing coverage is a node to node communication graph.

Mobile ad hoc networks (MANETs) generally adopt a peer-to-peer architecture in which the nodes themselves provide routing and services to the network. Disconnectivity with peer nodes, induced by mobility, power drains and damage makes route maintenance difficult and degrade the network's ability to offer services reliably to its peer nodes. In this paper, we present a routing scheme for proactive management of such disconnections, by fusing and leveraging information derived from multiple levels of the network protocol stack using cross-layering. In addition to the disconnectivity information, this routing scheme utilises node's service level information and data/service replication to provide service from an alternate source (if there is one) even in the absence of the targeted source. Simulation results demonstrate significant improvements in route maintenance and service availability over other similar schemes.

Construct differs from other pervasive systems platforms in a number of key respects. It is completely standards-based, using RDF as its data exchange model and ZeroConf for resource discovery. It supports a knowledge-centric model of interaction where clients' actions are driven by queries and triggers about the context of the system. It uses gossiping to maintain a consistent state across a distributed data structure, which maximises robustness and scalability and avoids many problems with hot-spots and hot-paths in communications. Finally, it treats all information sources uniformly as sensors acting as inputs to uncertain reasoning algorithms.

Layered architectures are not sufficiently flexible to cope with the dynamics of wireless-dominated next generation communications. Cross-layer approaches may provide a better solution: allowing interactions between two or more non-adjacent layers in the protocol stack. Cross-layer architectures based on purely local information will not be able to support system-wide cross-layer performance optimization, context-awareness, etc. A new cross-layer architecture which provides a hybrid local and global view, using gossiping to maintain consistency has been proposed in [1]. This paper studies the possibilities of context-awareness in communications through this architecture by two examples. The first example uses user-centric context to control the available link-bandwidth and satisfy user accordingly. The second uses contextual information to control the transmission power of a mobile node.

Group recommender systems introduce a whole set of new challenges for recommender systems research. The notion of generating a set of recommendations that will satisfy a group of users, with potentially competing interests, is challenging in itself. In addition to this we must consider how to record and combine the preferences of many different users as they engage in simultaneous recommendation dialogs. In this paper we introduce a group recommender system that is designed to provide assistance to a group of friends trying to plan a skiing vacation.

Autonomic communications seek to improve the ability of network and services to cope with unpredicted change, including changes in topology, load, task, the physical and logical characteristics of the networks that can be accessed, and so forth. Broad-ranging autonomic solutions require designers to account for a range of end-to-end issues affecting programming models, network and contextual modeling and reasoning, decentralised algorithms, trust acquisition and maintenance---issues whose solutions may draw on approaches and results from a surprisingly broad range of disciplines. We survey the current state of autonomic communications research and identify significant emerging trends and techniques.

Existing context services mostly support context-aware applications inside a closed, tightly-scoped environment. In order to provide a user with real pervasive computing experiences, a context service must be able to support roaming applications across different environments. We propose a global context infrastructure to address this issue. We discuss the general architecture of the context infrastructure and the design of the context service in one local environment, which is based on a context flow language and the corresponding run-time environment.

Abstract Recent distributed shared memory (DSM) systems provide increasingly more support for the sharing of objects rather than portions of memory. However, like earlier DSM systems these distributed shared object systems (DSO) still force developers to use a single protocol, or a small set of given protocols, for the sharing of application objects. This limitation prevents the applications from optimizing their communication behaviour and results in unnecessary overhead. A current general trend in software systems development is towards customizable systems, for example frameworks, reflection, and aspect‐oriented programming all aim to give the developer greater flexibility and control over the functionality and performance of their code. This paper describes a novel object‐oriented framework that defines a DSM system in terms of aconsistency modeland an underlyingcoherency protocol. Different consistency models and coherency protocols can be used within a single application because they can be customized, by the application programmer, on a per‐object basis. This allows application specific semantics to be exploited at a very fine level of granularity and with a resulting improvement in performance. The framework is implemented in JAVA and the speed‐up obtained by a number of applications that use the framework is reported. Copyright © 2002 John Wiley & Sons, Ltd.

An executing thread, in an object oriented programming language, is spawned, directly or indirectly, by a main process. This in turn gets its instructions from a primary class. In Java there is no close coupling of a thread and the objects from which they were created. The use of a container abstraction allows us to group threads and their respective objects into a single structure. A container that holds threads whose variables are all housed within the container is a perfect candidate for strong migration. To achieve this we propose a combination of three techniques to allow the containers to migrate in a manner that approaches strong mobility yet does not resort to retaining bindings to resources across distant and unreliable networks.

In reengineering legacy code it is frequently useful to introduce a design pattern in order to add clarity to the system and thus facilitate further program evolution. We show that this type of transformation can be automated in a pragmatic manner and present a methodology for the development of design pattern transformations. We address the issues of the definition of a starting point for the transformation, the decomposition of a pattern into minipatterns and the development of corresponding minitransformations that can introduce these minipatterns to a program. We argue that behaviour preservation is a key issue and develop a rigorous argument of this for each minitransformation we discover. The architecture of an existing software prototype is also discussed and the results of applying this methodology to develop a transformation for the Factory Method pattern are presented.

No abstract available.

As use of object orientation for application development has increased, many researchers have investigated the design of object-based programming languages for distributed and persistent programming. This paper concentrates on reviewing a number of such languages for distributed or persistent programming. In each case, the focus is on the object model supported and the mechanisms and policies employed in the implementation of distributed or persistent objects. In particular, each language reviewed has been chosen to illustrate a particular object model or implementation strategy.