In this paper, we present a middleware for synchronization of opaque and structured data in a mobile and resource-constrained environment. The presented Syxaw (Synchronizer with XML-awareness) system distinguishes itself from related proposals in that it interoperates transparently with resources on the World Wide Web, and by exhibiting a model of synchronization that is both easy to understand and well suited for weak devices in a mobile and ubiquitous environment. We demonstrate the feasibility of the proposed system by considering several usage scenarios, including working on the Web and collaborative XML editing. We consider system performance on a mobile wireless device, and examine the impact of different optimization techniques to the performance. According to our analysis, Web interoperability suggests that the data share model be kept simple and conservative, and that moving functionality onto the client is advantageous. We find that the techniques of operation bundling and concurrent use of network downlink and uplink improve network utilization, but that achieving full bandwidth usage with a weak client is challenging in practice.
In recent years, both the number and capabilities of mobile devices have increased rapidly to the point where the mobile world is becoming a significant part of the Internet. Another recent trend is the increase in XML use for communication between applications. However, the mobile world has been reluctant to adopt XML due to its verbosity and processing needs.
We consider here the problem of providing an XML-based messaging system for mobile devices. We analyze the requirements that the environment places on such a system and elaborate on these requirements by concentrating on three components that seem most amenable to improvements, namely XML processing interfaces, XML serialization, and message transfer protocols. In tandem with the analysis we also present the design and implementation of our messaging system that addresses these requirements.
Our experimentation of this system is extensive and performed completely on real devices and real wireless networks. Based on our implementation and experimentation we conclude that there is potential for improvement in XML messaging. The largest gains are achieved by using an asynchronous programming style and by using a compact serialization format. The improvements are also individually integratable into existing systems.
Content-based routing of information and publish/subscribe have been proposed as a communication paradigm for advanced and mobile applications. In content-based routing, messages are forwarded based on queries on their content that clients and routers establish beforehand. In this paper, we examine the cost and safety of handoff protocols for subscribers and publishers in content-based routing networks. We examine two useful properties for mobility-aware content-based routing systems, namely completeness and mobility-safety. Then we determine the upper and lower bound handoff costs for three interesting topologies, a number of optimizations, and show that if completeness cannot be assumed the signalling cost is considerably higher and flooding needs to be used. We present simulation results for subscriber mobility and mobility-safety proofs for the investigated protocols. Both theoretical and experimental results show that rendezvous points may be used to significantly reduce the signalling cost of handoffs.
Event-based systems are seen as good candidates for supporting distributed applications in dynamic and ubiquitous environments because they support decoupled and asynchronous one-to-many and many-to-many information dissemination. Event systems are widely used because asynchronous messaging provides a flexible alternative to RPC. They are typically implemented using an overlay network of routers. A content-based router forwards event messages based on filters that are installed by subscribers and other routers. This paper addresses the optimization of content-based routing tables organized using the covering relation and presents novel configurations for improving local and distributed operation. We present the poset-derived forest data structure and variants that perform considerably better under frequent filter additions and removals than existing data structures. The results offer a significant performance increase to currently known covering-based routing mechanisms.
In this paper, we present a summary of our experiences with mobile middleware research in the four-year Fuego Core project. The presented work focuses on data communication and synchronization. We present three middleware services for data communication and synchronization, namely the messaging, event, and file synchronizer services, and discuss their development and usage. We conclude with an integrated architecture of these services and the lessons we have learned.
In this paper we investigate the handover cost and mobility-safety of content streams. Content streams are continuous flows of information from one node in a distributed network to another. The flows are established using publish/subscribe primitives and content-based routing of information. We examine two useful properties for mobility-aware content routing systems, namely completeness and mobility-safety. Then we determine the topology update cost for three interesting topologies, a number of optimizations, and show that if completeness cannot be assumed the signalling cost is considerably higher and content-based flooding needs to be used. We present simulation results for subscriber mobility for the investigated protocols. Both theoretical and experimental results show that rendezvous-points may be used to significantly reduce the signalling cost of handovers.
In this paper we present a generic formal framework for filter merging in content-based routers. The proposed mechanism is independent of the used filtering language and routing data structure. We assume that the routing structure computes the minimal cover set. It supports merging of filters from local clients, hierarchical routing, and peer-to-peer routing. The mechanism is also transparent and does not require modifications in other routers in the distributed system to achieve benefits. In addition to content-based routers, the system may also be used in firewalls and auditing gateways. We present and analyze experimental results for the system.
The event paradigm and publish/subscribe systems allow clients to asynchronously receive information that matches their interests. The requirements of mobile computing present new challenges pertaining to event delivery that need to be solved. In this paper, we formally examine several state transfer protocols for different pub/sub topologies. The new results of this paper are the cost functions for both subscriber and publisher mobility, and investigation and formulation of completeness of subscriptions and advertisements. The results show that rendezvous points are good for pub/sub mobility, handovers in incomplete topologies are more costly than in complete, and the brokers involved with mobility have no way of detecting completeness based on local information alone.
In this paper, we formally define a useful data structure for content-based routing and event delivery. The poset (partially ordered set)-derived forest data structure is induced by the partial order created by the covering relation between event filters. Two extensions of the basic data structure are discussed: colored forests and the weakly merging forest. We give performance figures for the data structure using a workload generator and compare it with the filters poset structure. The experimental results indicate that the poset-derived forest performs considerably better than directed acyclic graph-based structures. The presented algorithms and mechanisms generalize to any covering relations and are thus applicable for different filtering languages.
Event-based computing is a generic enabler for the next generation mobile services and applications that need to meet user requirements irrespective of time and location. The event paradigm and publish/subscribe systems allow clients to asynchronously receive information that matches their interests. We outline an event architecture for mobile computing that addresses two key requirements: terminal mobility and user mobility. The system consists of access servers, event channels and a mechanism for locating event channels. The architecture uses filter covering and merging for supporting high accuracy in event delivery, reducing communication cost, and improving event processing on terminals and servers. Experimental results based on the merging system are also examined.
Event-based computing is vital for the next generation mobile services and applications that need to meet user requirements irrespective of time and location. The event paradigm is a form of asynchronous one-to-many communication and allows clients to receive information that matches their interests through filtering. Event-based communication is a good candidate for mobile computing, because it is asynchronous and supports disconnected operation. However, user and terminal mobility present problems pertaining to synchronization and delivery that need to be solved. In this paper, we examine and analyze mobility in the Rendezvous-Notify architecture. This event-delivery architecture is based on two server roles: access servers that maintain subscription information and buffered events, and resolution servers that are responsible for event channels and routing events to access servers. Access to event channels is done using a rendezvous mechanism.
The population of mobile devices capable of participating in the Internet has increased dramatically in the last few years. To include this population into the Web service world requires support for the most important features, in particular security at the message level. This paper covers our approach to implement XML security specifications on mobile devices that allows efficient single-pass processing of XML encryption and signatures. Furthermore, we propose extensions to security specifications to better take into account the needs of mobile devices. We demonstrate the performance of our implementation, as well as our proposed extensions, through experiments, carried out in a real mobile environment.
In the wireless world there has recently been much interest in alternate serialization formats for XML data, mostly driven by the weak capabilities of both devices and networks. However, an alternate serialization format is not easily made compatible with XML security features such as encryption and signing. We consider here ways to integrate an alternate format with security, and present a solution that we see as a viable alternative. In addition to this, we present extensive performance measurements, including ones on a mobile phone, on the effect of an alternate format when using XML-based security. These measurements indicate that, in the wireless world, reducing message sizes is the most pressing concern, and that processing efficiency gains of an alternate format are a much lesser concern.
XML is currently being used as the message syntax for Web services. To enable small mobile devices to use Web services, this XML use must not be too resource-consuming. Due to several measurements indicating otherwise, alternate serialization formats for XML data have been proposed. We present here a format for XML data designed from the ground up for the mobile environment. The format is simple, yet gives acceptable document sizes and is efficiently processable. An automaton-based approach gives further improvements when full or partial schema information is available. We provide performance measurements verifying these claims and also consider some issues arising from the use of an alternate XML serialization format.
Web services are becoming an increasingly important part of the Internet service infrastructure. Their reliance on XML and HTTP has raised concerns on the overhead in message processing and transmission, especially in the mobile wireless community. In this paper we present a review of the main problematic areas in the current use of Web services, namely the verbosity of the XML format, the processing interfaces currently used for XML, and the transfer protocols used. We also present the design of an XML messaging system that we have developed to solve these issues in a larger mobile middleware platform. Finally, we identify issues that arise due to these proposed solutions and need to be addressed in the future.
XML has recently made inroads into the data-oriented world of machine-to-machine interaction, most prominently in the form of SOAP and Web services. In this paper we present a new programming interface that views XML documents as sequences of events, and into which awareness of data typing is built in. These two features are intended to make the interface attractive for data-oriented applications that do not use XML internally. Our experience in using this interface in a mobile middleware system indicates that this sequentiality combined with type awareness and properly-layered higher-level interfaces provides a very natural way of handling XML for the data-oriented world.
SOAP is rapidly gaining popularity as the Web service protocol. At the same time, small mobile devices with wireless access, in particular to the Internet, are becoming more prevalent. At first look, it would seem that SOAP as a protocol consumes quite a lot of network bandwidth and processor time. Therefore its suitability for small devices and wireless links needs to be evaluated. This paper presents two optimizations that can be applied to typical uses of SOAP, message compression and persistent connections, and measures their performance in some common situations. Asynchronous messaging with SOAP is also treated briefly. The measurements indicate that a suitable compression scheme can save bandwidth substantially, and that the protocols underlying the typical use of SOAP can be improved considerably in the presence of unreliable high-latency networks.
Note: Copyright 2003 Springer-Verlag
The Open Source mobility middleware developed in the Fuego Core project provides a stack for efficient XML processing on limited devices. Its components are a persistent map API, advanced XML serialization and out-of-order parsing with byte-level access (XAS), data structures and algorithms for lazy manipulation and random access to XML trees (RefTree), and a component for XML document management (RAXS) such as packaging, versioning, and synchronization. The components provide a toolbox of simple and lightweight XML processing techniques rather than a complete XML database. We demonstrate the Fuego XML stack by building a viewer and multiversion editor capable of processing gigabyte-sized Wikipedia XML files on a mobile phone. We present performance measurements obtained on the phone, and a comparison to implementations based on existing technologies. These show that the Fuego XML stack allows going beyond what is commonly considered feasible on limited devices in terms of XML processing, and that it provides advantages in terms of decreased set-up time and storage space requirements compared to existing approaches.
Note: Copyright ICST 2008. This is the author's version of the work. It is posted here by permission of ICST. Limited to noncommercial access and personal use.
With the advent of XML we have seen a renewed interest in methods for computing the difference between trees. Methods that include heuristic elements play an important role in practical applications due to the inherent complexity of the problem. We present a method for differencing XML as ordered trees based on mapping the problem to the domain of sequence alignment, applying simple and efficient heuristics in this domain, and transforming back to the tree domain. Our approach provides a method to quickly compute changes that are meaningful transformations on the XML tree level, and includes subtree move as a primitive operation. We evaluate the feasibility of our approach and benchmark it against a selection of existing differencing tools. The results show our approach to be feasible and to have the potential to perform on par with tools of a more complex design in terms of both output size and execution time.
Note: Copyright ACM 2006. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version was published in the 2006 ACM Symposium on Document Engineering. http://doi.acm.org/10.1145/1166160.1166183
We present a novel mechanism for collection and object synchronization based on context information. The mechanism is based on a distributed event system and uses event filters for representing context and realizing context queries. The central operations of the system are storing and retrieving objects by their context. The new feature of the system is context-based synchronization, which allows synchronizing collections of objects continuously based on the given context. The system may be used also for context-based service provisioning. We present mechanisms for both collection and object synchronization. The former uses the publish/subscribe paradigm and the latter builds on an XML-aware file synchronizer. We focus on the first mechanism and also discuss the use of the system on mobile and wireless devices. We present a context-aware photo library as an example application.
There are two main approaches to optimistic file system synchronization: distributed file systems and file synchronizers. The former type is characterized by a log-based approach that depends on access to file system internals, the latter by a state-based approach that utilizes the standard file system interface, which is a limiting factor for change detection efficiency.
We propose a hybrid approach that 1) defines a minor extension to the semantics of the file system interface that enables efficient state-based file system change detection and 2) employs selectively instantiated XML documents to make the use of state-based algorithms for optimistic synchronization feasible on large file systems.
The hybrid approach is simple, well-suited for current file system architectures, and it allows us to leverage existing state-based reconciliation algorithms. An initial implementation shows our approach to be feasible, lightweight, interoperable, and satisfactory from a performance point of view.
Three-way merging is a technique that is used to reintegrate changes to a document when multiple independently modified copies have been made. Tools for three-way merge of ASCII text files exist in the form of the ubiquitous diff and patch tools, but these are of limited applicability when parts of the documents have been rearranged.
Our fault-tolerant three-way merge for XML and HTML was designed to support rearrangements to document structure, as well as situations where the wellformedness of the document has been lost. This is achieved by taking a text-based approach that recognizes moved text and uses normalization and denormalization of whitespace.
As there are many possibilities for merging moved text we decided to base the design of the merge on principles derived from a set of use cases, which systematically explore different merging situations. This design process should help ensure that the chosen merge is useful from a practical point of view.
Three-way merging is a technique that may be employed for reintegrating changes to a document in cases where multiple independently modified copies have been made. While tools for three-way merge of ASCII text files exist in the form of the ubiquitous diff and patch tools, these are of limited applicability to XML documents.
We present a method for three-way merging of XML which is targeted at merging XML formats that model human-authored documents as ordered trees (e.g. rich text formats, structured text, drawings, etc.). To this end, we investigate a number of use cases on XML merging (collaborative editing, propagating changes across document variants), from which we derive a set of high-level merge rules. Our merge is based on these rules.
We propose that our merge is easy to both understand and implement, yet sufficiently expressive to handle several important cases of merging on document structure that are beyond the capabilities of traditional text-based tools. In order to justify these claims, we applied our merging method to the merging tasks contained in the use cases. The overall performance of the merge was found to be satisfactory.
The key contributions of this work are: a set of merge rules derived from use cases on XML merging, a compact and versatile XML merge in accordance with these rules, and a classification of conflicts in the context of that merge.
Note: Copyright ACM 2004. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version was published in the 2004 ACM Symposium on Document Engineering. http://doi.acm.org/10.1145/1030397.1030399
Optimistic replication approaches are often employed on mobile devices, which raises the need for reconciliation of concurrently modified data. We propose that three-way merging algorithms, in particular those that are able to process tree-structured data in XML format, make good candidates for a generic data reconciliation engine on mobile devices.
By exchanging data through XML files we impose minimal constraints on application design and are able to offer reconciliation services to a large number of existing applications. Reconciliation support can be added to an application in several increments, allowing application developers to choose a suitable level of support compared to implementation effort. We give two examples of reconciliation by three-way merging of XML.
Note: Copyright ACM 2003. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version was published in the 2003 International Workshop on Data Engineering for Wireless and Mobile Access. http://doi.acm.org/10.1145/940923.940940
Software agents are one of the building blocks of ambient intelligence and pervasive computing. Adaptation to changes in the execution context is necessary in order to provide continuous and smooth provision of services for wireless clients. In this paper, we present a system for adapting a service consisting of multiple agents based on application, terminal and communication models and profiles. The system adapts and composes the service by finding the best combination of local and external agents to contact. The context models are based on experimentation with actual devices and environments. We present a theoretical cost model for runtime service composition, and examine experimental results that are based on an example scenario.
Note: Copyright 2003 Springer-Verlag
Software agent technology is based on event-driven entities that use asynchronous messaging and high-level languages to communicate. Agents may subscribe information from other agents, update their internal models based on received messages and notifications, and publish notifications to listening agents. Currently, most agent architectures do not employ content-based dissemination of messages or notifications, and the agents need to take care of subscription management. In this paper, we examine the benefits of providing a distributed event service for agents that supports mobile components and filtering. We consider using distributed event filtering in enhancing agent functionality and simplifying the agent application development by delegating subscription management to the middleware system.
Java and middleware are becoming popular on PDAs and small devices with the advent of small-footprint virtual machines. In this paper, we examine agent messaging on small devices based on our experiences with MicroFIPA-OS, which is an agent toolkit for small devices. Since agents communicate by sending and receiving messages, it is reasonable to expect that the system should minimize communication latency both within a platform and between agent platforms. We present and discuss different deployment options for connecting terminal agents with the fixed network agent community. The performance measurement focuses on messaging both within the PDA device and between the device and another external agent platform.
Note: Copyright 2002 Springer-Verlag
Current small devices, such as Personal Digital Assistants (PDAs), are powerful enough to enable the use of Java applications and middleware. In this paper, we present the Java based MicroFIPA-OS, which is an agent platform for enabling software agents on small devices. We give an overview of the system, the target environment and examine the performance on two current PDAs.
XML is a widely-used technology for interoperable data representation, and its scope of usage has widened even more in recent years. However, this expansion of XML's application areas has identified limitations and inefficiencies that seem inherent in XML due to its verbosity and redundancy. Because of this, various industry groups and standardization organizations have undertaken to define alternate representations of XML data to better address their needs while still retaining compatibility with XML. This paper provides an overview of the arguments in favor of a binary format in scientific computing, of work done in this area by the W3C, and some benchmarks comparing XML with various processing techniques available with binary formats.
Session Initiation Protocol (SIP) is an application-layer control protocol for creating, modifying and terminating sessions with one or more participants. These sessions include Internet telephone calls, multimedia distribution, and multimedia conferences. SIP includes an extensible framework for asynchronous event notification. This paper investigates the interworking of SIP events with a generic publish/subscribe system. Publish/subscribe systems typically support anonymous one-to-many form of communication, which is not supported by the default SIP event package. We present the design and implementation of a gateway component, and discuss supporting expressive subscription semantics using filters and also mobile clients.
One of the main problems with IP has been its lack of security. Although IPSec and DNSSec have provided some level of security to IP, the notion of a true identity for hosts is still missing. Typically, the IP address of the host has been used as the host identity, regardless of the fact that it is nothing more than routing information. The purpose of the Host Identity Payload/Protocol (HIP) architecture is to add cryptographically based name space, the Host Identity, to the IP protocol. The Host Identity serves as the identity of the host, whereas the IP address is merely used for routing purposes. In this paper, we describe the HIP architecture further, and present our IPv6 based implementation of HIP for Linux.
In recent years, XML has been widely adopted as a universal format for structured data. A variety of XML-based systems have emerged, most prominently SOAP for Web services, XMPP for instant messaging, and RSS and Atom for content syndication. This popularity is helped by the excellent support for XML processing in many programming languages and by the variety of XML-based technologies for more complex needs of applications.
Concurrently with this rise of XML, there has also been a qualitative expansion of the Internet's scope. Namely, mobile devices are becoming capable enough to be full-fledged members of various distributed systems. Such devices are battery-powered, their network connections are based on wireless technologies, and their processing capabilities are typically much lower than those of stationary computers.
This dissertation presents work performed to try to reconcile these two developments. XML as a highly redundant text-based format is not obviously suitable for mobile devices that need to avoid extraneous processing and communication. Furthermore, the protocols and systems commonly used in XML messaging are often designed for fixed networks and may make assumptions that do not hold in wireless environments.
This work identifies four areas of improvement in XML messaging systems: the programming interfaces to the system itself and to XML processing, the serialization format used for the messages, and the protocol used to transmit the messages. We show a complete system that improves the overall performance of XML messaging through consideration of these areas.
The work is centered on actually implementing the proposals in a form usable on real mobile devices. The experimentation is performed on actual devices and real networks using the messaging system implemented as a part of this work. The experimentation is extensive and, due to using several different devices, also provides a glimpse of what the performance of these systems may look like in the future.
In recent years, XML has been accepted as the format of messages for several applications. Prominent examples include SOAP for Web services, XMPP for instant messaging, and RSS and Atom for content syndication. This XML usage is understandable, as the format itself is a well-accepted standard for structured data, and it has excellent support for many popular programming languages, so inventing an application-specific format no longer seems worth the effort.
Simultaneously with this XML's rise to prominence there has been an upsurge in the number and capabilities of various mobile devices. These devices are connected through various wireless technologies to larger networks, and a goal of current research is to integrate them seamlessly into these networks.
These two developments seem to be at odds with each other. XML as a fully text-based format takes up more processing power and network bandwidth than binary formats would, whereas the battery-powered nature of mobile devices dictates that energy, both in processing and transmitting, be utilized efficiently.
This thesis presents the work we have performed to reconcile these two worlds. We present a message transfer service that we have developed to address what we have identified as the three key issues: XML processing at the application level, a more efficient XML serialization format, and the protocol used to transfer messages.
Our presentation includes both a high-level architectural view of the whole message transfer service, as well as detailed descriptions of the three new components. These components consist of an API, and an associated data model, for XML processing designed for messaging applications, a binary serialization format for the data model of the API, and a message transfer protocol providing two-way messaging capability with support for client mobility. We also present relevant performance measurements for the service and its components.
As a result of this work, we do not consider XML to be inherently incompatible with mobile devices. As the fixed networking world moves toward XML for interoperable data representation, so should the wireless world also do to provide a better-integrated networking infrastructure. However, the problems that XML adoption has touch all of the higher layers of application programming, so instead of concentrating simply on the serialization format we conclude that improvements need to be made in an integrated fashion in all of these layers.
Event architectures provide various applications under distributed environment. Such applications include mobile computing, control systems, e-commerce, real time, system and network management. Different event models presently in use are Common Object Request Broker Architecture (CORBA), JINI and, Grid Simple Object Access Protocol (SOAP) systems. Recently, research and trial experiments are conducted with Session Initiation Protocol (SIP) Event framework an extension of the SIP. Though there are many such existing event architectures, interworking between these systems is still an open issue.
In this thesis, the publish/subscribe(pub/sub) model, a communication paradigm for complex distributed applications and the SIP, newly emerging standard are considered. The pub/sub system works in a loosely-coupled manner offering one-to-many asynchronous event dissemination. In this model, anonymity between the publisher and subscriber can possibly be maintained. In contrast, the SIP event system supports solicited subscription and notification. In this thesis, an interworking architecture is proposed for the two different and, non-interoperable event systems namely, the pub/sub and SIP event framework.
This thesis presents the gateway component designed to accomplish the goal of interworking between the pub/sub and SIP event systems. Future directions of research to enhance the proposed interworking architecture is discussed.
The goal of this thesis was to design and implement an application programming interface for Host Identity Protocol (HIP) aware network applications using the C language. The results of the design are evaluated against the given requirements. Different design alternatives are introduced and analyzed in order to rationalize the design. A reference implementation was developed as a proof of concept. Few example applications were ported to use the API.
The outcome of the design meets the requirements. The API follows the design of the sockets API closely and extends it only when reuse of the design is not possible. The new API increases the control over the HIP layer for advanced applications. Applications can also specify their own endpoint identities. Typical applications can utilize the API in a simple way that hides the details of the endpoint identifiers and locators. A HIP enabled application can fall back to plain TCP/IP seamlessly if the peer host does not support HIP.
The work brought up some future work items. The API may also be useful to other protocols based on the identity-locator split. A Quality of Service and a mobility event API need to be specified. FTP and other applications using "referrals" require also further work.
Host Identity Protocol offers improvements to the way we current see the Internet. By enabling mobility, multihoming and encryption, the HIP could be the next major boost to the Internet. While still being an working item in Internet Engineering Task Force, it has already attracted attention of five groups, who have created five different and interoperable implementations. We join one of the groups, the HIPL (HIP for Linux), to improve their implementation.
As the Linux 2.6 kernel makes its first appearences, individual people, companies and institutions will still use the older Linux 2.4 kernel because it has had enough time to mature and stabilize.
Due to the properties of the Linux 2.4 the time-consuming algorithms are usually not implemented in the kernel. The problem is that the kernel executes in highest priority level and cannot be preempted by the user processes. The direct implication is that time-consuming algorithms would render the computer "useless" for the user processes.
In this thesis we implement time-consuming HIP algorithms in Linux 2.4 kernel. Our mission is to create an environment in the kernel where the algorithms can be ran so that the user processes get time on the CPU as well.
User research suggests that in the everyday life of people there are numerous occasions when people are unaware of each other's situations (Kankainen et al. 2001). Sometimes it could be considered beneficial for people to know more of the setting in which other people are. This could initiate collaboration when people would realise that something interesting is occurring outside their present environment.
The purpose of this study is to investigate how a messaging service could distribute information of people's situations. The problem in this type of service is that each time the situation of a person changes, other people should receive a situation information update. This would result in a large amount of information sent, which could not be brought entirely to the attention of the user, since it would be disturbing. Instead people are only sent information of situations in which the recipient is expected to be present. This type of operation would help people avoid missing activities that they are likely to attend.
This study follows the constructive research approach. A literature study examines the capabilities of tomorrow's computing environment in providing situation information of people. These capabilities are then taken into account when designing the service. The service prototype itself is implemented using known algorithms, and thus has a connection to previous research. Finally, the practical functioning of the service is evaluated using a simulation environment that is developed for this very purpose.
The acceptability of the constructed service is evaluated using a framework from Nielsen (1993). The results show that the service can fairly well recognise the situations in which people are expected to be present and inform the people of these situations. The results demonstrate that the service can be used both to remind and inform of situations in which people would like to participate.
Mobile computing and pervasive computing introduce a more dynamic network environment. As a side-effect, location of services becomes problematic for clients accessing the services. A number of service discovery solutions aim to raise the abstraction level of the location to solve the problem; the trend is to discover services not based on network addresses but based on service usage intentions. Even though the current service discovery solutions (Bluetooth, Jini, Universal Plug'N'Play, Salutation, and Service Location Protocol) succeed in doing this, they have a limited support for interoperability. Nonetheless, a need for federating service discovery domains is imminent due to the nature of the mobile and pervasive computing.
No comprehensive analysis of the service discovery solutions exists. This thesis proposes a taxonomy for the service discovery solutions to fill the gap. The taxonomy then acts as an input to the requirements analysis process, which produces the requirements for a service broker architecture capable of federating service discovery solutions. A design of a proposed service broker architecture is then derived from the requirements. A prototype implementation of the architecture is also presented and analyzed together with the architecture itself.
This page generated by Feather, a toolkit for the FubML bibliography format.