Search

This paper presents a twofold context modelling approach that integrates beliefs (uncertain knowledge) and facts to reason about various everyday situations. Awareness of everyday situations enables mobile devices to adapt to the social and conceptual settings in which they operate; it also enables resources which share a similar context to cooperate in order to carry out a distributed task on behalf of their user. Our context modelling process involves the identification of the context of interest, the determination of those aspects of a context which can be captured by employing sensors, the determination of contextual states for each aspect, and finally, the determination of logical and probabilistic relationships between the contextual aspects and the context they represent. We demonstrate our approach by modelling physical places. Data from various heterogeneous sensors build our system's belief, while containment relationships build its factual knowledge regarding places. The system utilises its belief and factual knowledge to reason about the whereabouts of a mobile user. [ABSTRACT FROM AUTHOR]

Web service QoS (Quality of Service) is a key factor for users to evaluate and select services. Traditionally, run-time QoS of web services stores in centralized QoS registry, which may have performance and availability problems. In this paper, we propose a P2P (Peer-to-Peer) QoS registry architecture for web services, named Q-Peer. Q-Peer is an unstructured P2P system. Query of QoS is naturally achieved by getting QoS address from corresponding service description. Q-Peer has a replication based mechanism to ensure load-balance of the whole architecture. The architecture takes advantage of P2P systems to ensure its availability, performance and autonomy. We are currently implementing Q-Peer and planning to test it on Planet-Lab. [ABSTRACT FROM AUTHOR]

Dynamic loading of code is a crucial and often neglected part of today's distributed systems that face increasing dynamics, complexity and heterogeneity. Ubiquitous computing and mobile computing even strengthen this trend. As the local availability of suitable code cannot be assumed in such environments, we propose a generic, decentralised code loading infrastructure. The whole process of publication, look-up, implementation selection and the final loading of platform-specific code is decentralised and requires only basic peer-to-peer functionality. In contrast to previous work, our infrastructure allows any peer participating in the network to offer and to obtain platform-specific code in a dynamic and heterogeneous environment. By building on our generic concept, we present a JXTA-based service for dynamic code loading, which is realised by extending and improving JXTA-built-in mechanisms for dynamic service integration. Subsequently, we show the practical application of our infrastructure by an integration into our CORBA middleware and an implementation of mobile objects and mobile web services. [ABSTRACT FROM AUTHOR]

An improved genetic algorithm is presented to select optimal web services composite plans from a lot of composite plans on the basis of global Quality-of-Service (QoS) constraints. The relation matrix coding scheme of genome is its basis. In this genetic algorithm, an especial fitness function and a mutation policy are proposed on the basis of the relation matrix coding scheme of genome. They enhance convergence of genetic algorithm and can get more excellent composite service plan because they accord with web services selection very well. The simulation results on QoS-aware web services selection have shown that the improved genetic algorithm can gain effectively the composite service plan that satisfies the global QoS requirements, and that the convergence of genetic algorithm was improved very well. [ABSTRACT FROM AUTHOR]

Smart item environments consist of networked nodes with heterogeneous hardware equipment and intermittent network connections. Using a common component technology allows for flexible distribution of components for processing of smart item data. Finding a good deployment plan for a new set of components in an infrastructure is called Component Placement Problem. We propose an approach for finding suitable deployment plans for components with special regard to the characteristics of smart item environments. Our method evaluates deployment plans in terms of both resource consumption and availability. From the analysis of the solution space we conclude that the number of network link uses is an important criterion for the quality of a deployment plan regarding both cost and availability. Based on this finding, we have derived a heuristic that creates deployment plans, which have a low number of link uses and are thus more likely of high quality. [ABSTRACT FROM AUTHOR]

In this paper we propose a framework for modeling mobile information systems. Mobility introduces several challenges and issues that impact the development of mobile systems. As a result, we want applications running on mobile devices to exhibit certain traits; they should be aware of the mobility and be adaptive to the changes that occur due to it. Literature has identified several types of mobility - among them, physical and logical mobility. The former pertains to tangible mobile entities like cars, devices and people, while the latter encompasses mobile software entities. In addition to these, this paper includes the concept of vertical mobility - the movement of a network connection between overlapping networks - in a UML profile for modeling mobile information systems. We discuss our experiences from a case study described in [1] , where we modeled a simple mobile information system and transformed parts of the model into code. [ABSTRACT FROM AUTHOR]

In this paper, we define a conceptual model that describes the relevant information about interactions between concerns that needs to be captured. We have developed a prototype system that, starting from this model, can automatically generate a set of rules that enables software developers to improve their understanding of concerns in middleware and their interactions. This rule-base is the basis for an expert system that can be queried about particular concern interactions and a software engineering tool to support an application development team. [ABSTRACT FROM AUTHOR]

In order to guarantee certain levels of QoS, a Web application needs to adapt itself to different execution contexts. However, because of the lack of coordination support in Web platforms, service providers respond to the challenge by simply providing multiple versions of a Web application, one for each context. We argue this top-down approach is neither efficient nor scalable: developing a context-specific application requires considerable effort and expertise while the ever-changing Internet never stops generating interesting contexts which can be exploited for better deployment. As an alternative, we propose a three-layer, bottom-up approach to building context-aware Web applications. At the bottom layer, we characterize a context-specific Web application with a particular component distribution plan which provides details for composing individual objects. In the middle layer, recursively defined configurations provide a bridge which relates high-level context features to low-level component distribution properties, where a configuration is a combination of configurations and/or component distribution properties. At the top level, a context management system selects desirable configurations according to the execution contexts. [ABSTRACT FROM AUTHOR]

Service Oriented Architectures (SOA's) enable powerful application and end user service composition from independently defined services. The effective deployment of such composed services requires adaptation of and interoperability between services. This challenge can be approached by specifying service composition in policies, and by enforcing these policies in a sophisticated run-time architecture. In this paper, we present an open architecture for enforcing and composing complex policies that can depend on the available services in the environment. Complex polices have typically been studied in the context of policy languages, yet they have never been fully supported in a SOA-based execution environment. We have created a flexible run-time architecture that maximizes interoperability, adaptability and evolution. We have prototyped our architecture on an Enterprise Service Bus and we illustrate how our solution supports realistic and complex policies. [ABSTRACT FROM AUTHOR]

Today, one can observe an ever increasing trend in the use of mobile systems. This change inevitably affects the software running on such devices by necessitating additional functionality such as context awareness and adaptive behavior. While some developers design their systems to be fully self-reliant with regard to context awareness, others aim for more synergistic approaches by allowing context sharing across devices. This paper describes our experience with first designing and implementing a basic context management system, and then with extending it to allow context distribution. In the proposed architecture, the developers define the context dependencies for their software independently of the availability of context information in their corresponding devices. An automated mechanism is then used to match these needs to the corresponding providers, even when those reside across distributed devices. This approach enables them to utilize shared context information at runtime thus reducing both development efforts and hardware costs. [ABSTRACT FROM AUTHOR]

Agent-based Web recommender systems are applications capable to generate useful suggestions for visitors of Web sites. This task is generally carried out by exploiting the interaction between two agents, one that supports the human user and the other that manages the Web site. However, in the case of large agent communities and in presence of a high number of Web sites these tasks are often too heavy for the agents, even more if they run on devices having limited resources. In order to address this issue, we propose a new multi-agent architecture, called MARS, where each user's device is provided with a device agent, that autonomously collects information about the local user's behaviour. A single profile agent, associated with the user, periodically collects such information coming from the different user's devices to construct a global user profile. In order to generate recommendations, the recommender agent autonomously pre-computes data provided by the profile agents. This recommendation process is performed with the contribution of a site agent which indicates the recommendations to device agents that visit the Web site. This way, the site agent has the only task of suitably presenting the site content. We performed an experimental campaign on real data that shows the system works more effectively and more efficiently than other well-known agent-based recommenders. [ABSTRACT FROM AUTHOR]

Ubiquitous computing environments are characterised by a high number of heterogeneous devices that generate a huge amount of context data. These data are used to adapt applications to changing execution contexts. However, legacy frameworks fail to process context information in a scalable and efficient manner. In this paper, we propose to organise the classical functionalities of a context manager to introduce a 3-steps cycle of data collection, interpretation, and situation identification. We propose the COSMOS framework, which is based on the concepts of context node and context management policies translated into software components in software architecture. This paper presents COSMOS and evaluates its efficiency throughout the example of the composition of context information to implement a caching/off-loading adaptation situation. [ABSTRACT FROM AUTHOR]

Presentation level integration now becomes an important and fast growing trend in enterprise computing and portals are the mainstream to realize it. However, there is not yet a definitive mechanism to achieve interoperability between the basic components of a portal i.e. portlets, whereby HTML data flows smoothly from one portlet to a neighboring one. This paper proposes an HTML fragments based approach to achieve portlet interoperability. Fragments are a block of HTML elements, which are generated by portlets and are used to aggregate a portal page. We first construct a presentation component, which is named as ShadowComponent, for each portlet involved in a portlet interoperation using its fragments, then define a data flow process between ShadowComponents using ECA rules, and finally drive such a process by creating events to fulfill data flow between ShadowComponents. As the fragments of a portlet are synchronized with their corresponding Shadow Component, such a process enables the portlet interoperation. Experimental results show that the proposed approach is effective in achieving portlet interoperability in portals. [ABSTRACT FROM AUTHOR]

Replication systems require a state-transfer mechanism in order to recover crashed replicas and to integrate new ones into replication groups. This paper presents and evaluates efficient techniques for parallel state transfer in such systems. These techniques enable a faster integration of replicas and improve overall service availability. On the basis of previous work on distributed download in client-server and peer-to-peer systems, we obtain parallel state-transfer mechanisms for replicated objects. Our algorithms support static and dynamic distributed download of state without a priori knowledge about the state size. A non-blocking transfer minimises the time of service unavailability during state transfer. In addition, partial state capturing is presented as an additional technique that improves the parallel transfer of large states. [ABSTRACT FROM AUTHOR]

We present in this paper a generic approach for process transformation into strong mobile entity. Our approach is based on processes Serialisation using source code transformation, which generates the source code of a strong mobile process. Our approach is suitable for transforming distributed applications into mobile applications where every process can be migrated independently any time. We applied our approach to Java Thread by designing a grammar describing the generated mobile process code. The evaluation results of generated mobile Threads shows good performances. [ABSTRACT FROM AUTHOR]

Migration of running application code is considered a very attractive and desired mechanism to improve application performance, resource sharing, self-adaptability, etc. This mechanism seems to be even more important nowadays, considering the growing interest in the area of mobile computing and mobile networks. This paper briefly presents a migration mechanism for a CORBA Component Model platform. We discuss general issues related to migration of running code, further elaborated in the context of CCM. We also propose an extension to the original CCM model which provides interfaces to implement migration. The paper presents the most important problems which appeared during implementation of a prototype facility and it discusses possible solutions. One of the most fundamental issues related to mobility of running code is the residual dependency problem. The intention of the work is not to provide a solution to this (possibly unsolvable) problem, but to propose an approach which would make programmers aware of its existence. Thus, the paper allows readers to make more conscious decisions when designing their components. The paper ends with an evaluation of the prototype implementation on top of OpenCCM, an open source Java implementation of the CORBA Component Model. [ABSTRACT FROM AUTHOR]

Contemporary object-oriented programming seeks to enable distributed computing by accessing remote objects using blocking remote procedure calls. This technique, however, suffers from several drawbacks because it relies on the assumption of stable network connections and synchronous method invocations. In this paper we present an approach to support distributed programming, which rely on local object replicas keeping themselves synchronized using an underlying peer-to-peer infrastructure. We have termed our approach Peer-to-peer Distributed Shared Objects (PDSO). This PDSO approach has been implemented in the DOLCLAN framework. An evaluation demonstrates that DOLCLAN can be utilized to create a real distributed collaborative system for ad-hoc collaboration in hospitals, which demonstrates that the approach can support the creation of non-trivial distributed applications for pervasive computing. [ABSTRACT FROM AUTHOR]

Mobile computing is characterised by variations in user needs and in the computing and communication resources. We have developed a middleware centric approach for the development of software capable of dynamically adapting to such variations. The middleware leverages models of needs and resources and the adaptation capabilities of the software and performs context monitoring, adaptation planning and dynamic reconfiguration at runtime. In this paper we focus on the modelling of resources of a distributed mobile computing infrastructure and how the resource model is used in adaptation planning. We present a distributed resource management framework and mechanisms necessary to maintain an up to date resource model at runtime. The challenge is to balance the level of abstraction so as to hide some of the heterogeneity of the actual infrastructure while retaining sufficient detail to serve the needs of distributed and centralized adaptation planning. The proposed framework is illustrated through a running example. [ABSTRACT FROM AUTHOR]

Because they are required to support component deployment and composition, modern execution environments embody a number of common features such as dynamic linking and support for multiple component versions. These features help to overcome some classical maintenance problems focused largely on component evolution, where successive generations of collaborating components need to be kept collaborating. What has been less studied has been component adaptation, whereby a component developed in an environment consisting of one set of service components is required to operate in one or several other environments containing qualitatively different components. In this paper we examine the needs developers and deployers have arising out of component adaptation and explore the concept of Flexible Dynamic Linking as a means of satisfying them. We describe a suite of tools developed to demonstrate this approach to component adaptation support within the .NET Common Language Runtime. [ABSTRACT FROM AUTHOR]

Constructing and executing distributed applications that can adapt to their current operating context, in order to maintain or enhance Quality of Service (QoS) attribute levels, are complex tasks. Managing multiple, interacting QoS features is particularly difficult since these features tend to be distributed across the system and tangled with other features. The crosscutting nature of QoS features can make them difficult to evolve, and it can make it complicated to dynamically optimize with respect to provided QoS during execution. Furthermore, it complicates efficient construction of application variants that differ in their QoS characteristics to suit various execution contexts. This paper presents an aspect-oriented and model driven approach for constructing and a QoS-aware middleware for execution of QoS-sensitive applications. Aspect-oriented modeling techniques are used to separate QoS features from primary application logic, and for efficient specification of alternative application variants. Model driven engineering techniques are used to derive run-time representations of application variants from platform independent models. The developed middleware chooses the best variant according to the current operating context and the available resources. [ABSTRACT FROM AUTHOR]

The present emergence of loosely-coupled, inter-enterprise collaboration, i.e., virtual organizations calls for new kind of middleware: generic, common facilities for managing contract-governed collaborations and the autonomous business services between which those collaborations are formed. While further work is still needed on the functional governance of the collaborations and services, even more work is awaiting on the management of non-functional aspects of the virtual enterprises and their members. In this paper, languages and architectures for service level agreement between Web Services are discussed and the maturity of the service level management solutions is reflected against the needs of federated virtual organizations. [ABSTRACT FROM AUTHOR]

Software components embedded in wireless devices are subject to behavior which cannot be fully and realistically predicted. This calls for a runtime management infrastructure that is able to observe and control the components' states and to make their behaviors explicit, tangible and understandable, in any case and at any time. In this paper, we propose a framework for remotely administrating the functional behavior of software components deployed on wireless nodes. This framework is based on components which are locally managed by internal managers on the wireless side. The controllable nature of components relies on executable UML models that persist at runtime. On the administration side, models are replicated and synchronized with the models that constitute the inner workings of the wireless components. [ABSTRACT FROM AUTHOR]

Context-aware applications use and manipulate context information to detect high-level situations, which are used to adapt application behavior. This paper discusses the specification of situations in context-aware applications and introduces a rule-based approach to detect situations. Situations are specified using a combination of UML class diagrams and OCL constraints. We support a wide range of situations, which can be composed of more elementary kinds of context. We discuss how to cope with distribution and to exploit it beneficially for context manipulation and situation detection. We employ a generic rule-based platform (DJess [2]) to support the derivation of situations in a distributed fashion. [ABSTRACT FROM AUTHOR]

Implementing context-dependent behaviour of pervasive computing applications puts a great burden on programmers: Devices need to continuously adapt not only to their own context, but also to the context of other devices they interact with. We present an approach that modularises behavioural adaptations into roles. Role selection takes the context of all the devices involved in an interaction into account, ensures an unambiguous scope of adaptation even in the presence of concurrency, and protects the privacy of the devices. Thus, our context-dependent role (CDR) model facilitates expressing interactions between applications in different, possibly conflicting contexts. [ABSTRACT FROM AUTHOR]

The ODP Enterprise Language concept of Role provides a useful abstraction for behaviour in a context that is independent of how the behaviour is enacted in a run time system. In CORBA implementations of ODP systems a client object reference variable is analogous to a Role - it is a placeholder for an object whose behaviour is specified by an IDL type. The DSTC UML Profile for Enterprise Distributed Object Computing expresses the Role concept as a UML Action, which is a placeholder for behaviour in UML, and has an attribute representing constraints on the objects that may perform the behaviour (fill the Role). CORBA Object reference variables are assigned to object references using some "bootstrapping mechanism", implemented by a programmer, perhaps using a Trader or Naming Service to locate suitable objects. For the first time in UML, the DSTC EDOC Profile allows designers to specify Roles independent of the class of objects that may perform the Roles. Designers also specify which objects are appropriate for filling which Roles. Furthermore the mapping of this Profile to CORBA technology allows automatic generation of Trader query code to bootstrap the object references of a distributed application according to the high-level design, not the whims of the programmer. [ABSTRACT FROM AUTHOR]