For performance and compatibility reasons, developers tend to use native code in their applications (or simply apps). This makes a bidirectional data flow through multiple contexts, i.e., the Java context and the native context, in Android apps. Unfortunately, this interaction brings serious challenges to existing dynamic analysis systems, which fail to capture the data flow across different contexts. In this paper, we first performed a large-scale study on apps using native code and reported some observations. Then, we identified several scenarios where data flow cannot be tracked by existing systems, leading to uncaught information leakage. Based on these insights, we designed and implemented NDroid, an efficient dynamic taint analysis system that could track the data flow between both Java context and native context. The evaluation of real apps demonstrated the effectiveness of NDroid in identifying information leakage with reasonable performance overhead.

Due to the increasing scale and complexity of software products, software maintenance especially on bug resolution has become a challenging task. Generally in large-scale software programs, developers depend on software artifacts (e.g., bug report, source code and change history) in bug repositories to complete the bug resolution task. However, a mountain of submitted bug reports every day increase the developers' workload. Therefore, ‘How to effectively resolve software defects by utilizing software artifacts?’ becomes a research hotspot in software maintenance. Considerable studies have been done on bug resolution by using multi-techniques, which cover data mining, machine learning and natural language processing. In this paper, we present a literature survey on tasks, challenges and future directions of bug resolution in software maintenance process. Our investigation concerns the most important phases in bug resolution, including bug understanding, bug triage and bug fixing. Moreover, we present the advantages and disadvantages of each study. Finally, based on the investigation and comparison results, we propose the future research directions of bug resolution.

An important part of software maintenance is bug report analysis during bug-fixing, especially for large-scale software projects. Since bugs reported to the bug repository need to be fixed, triagers are responsible to identify appropriate developers to execute the fix. Previous research focused on optimizing this process, such as by duplicate detection and use of developer recommendations for reducing the workload of triagers. However, there were scant studies that analyzed developer roles (e.g. reporter and assignee) in the bug-fixing process. Therefore, in this paper, we perform an in-depth empirical study of the different roles that developers perform in bug resolution. By extracting the factors that affect bug resolution from the analysis results, we propose a novel bug triage algorithm to recommend the appropriate developers to fix a given bug. We implement the proposed recommendations on the Eclipse and Mozilla Firefox projects, with the results showing that the new bug triage algorithm can effectively recommend which experts should fix given bugs.

The amount of data stored in databases is increasing at a tremendous rate. They are oftentimes stored over the web to be accessed by various clients. One useful and interesting query to a collection of databases is to capture a consistent snapshot of a set of interested attributes across the databases. While traditional snapshot algorithms for a distributed database could be adopted, they are mainly designed for database recovery and are costly to execute. We need efficient algorithms to return good-enough snapshots for querying purposes, in the absence of a consistent but costly snapshot as defined in distributed systems. In this paper, we propose the notion of an approximate consistent snapshot by considering and minimizing the deviation of the collected snapshot covering the interested attributes from a reference absolute snapshot. There are several variations of this kind of approximate snapshots. We propose effective algorithms to capture such snapshots in a collection of databases and then conduct performance evaluation on their efficiency. We believe that this notion of approximate consistency would be useful in practical situations.

Android provides native development kit through JNI for developing high-performance applications (or simply apps). Although recent years have witnessed a considerable increase in the number of apps employing native libraries, only a few systems can examine them. However, none of them scrutinizes the interactions through JNI in them. In this paper, we conduct a systematic study on tracking information flows through JNI in apps. More precisely, we first perform a large-scale examination on apps using JNI and report interesting observations. Then, we identify scenarios where information flows uncaught by existing systems can result in information leakage. Based on these insights, we propose and implement NDroid, an efficient dynamic taint analysis system for checking information flows through JNI. The evaluation through real apps shows NDroid can effectively identify information leaks through JNI with low performance overheads.

As computer and interaction technologies mature, a much broader range of media is now used for input and output, each of which has its own rich repertoire of techniques, instruments, and cultural heritage. The combination of multiple media can produce novel multimedia human-computer interaction approaches which are more efficient and interesting than traditional single media methods. This paper presents CalliPaint, a system for cross-modal art generation that links together Chinese ink brush calligraphy writing and Chinese landscape painting. We investigate the mapping between the two modalities based on concepts of metaphoric congruence, and implement our findings into a prototype system. A multi-step evaluation experiment with real users suggests that CalliPaint provides a realistic and intuitive experience that allows even novice users to create attractive landscape paintings from writing. Comparison with a general-purpose digital painting software suggests that CalliPaint provides users with a more enjoyable experience. Finally, exhibiting CalliPaint in an open-access location for use by casual users without any training shows that the system is easy to learn.

Due to the difficulties and importance of multi-hop broadcasts in low duty-cycled wireless sensor networks, we propose a novel Delay-Constrained and Energy-Balanced (DCEB) broadcast protocol. DCEB neither assumes time synchronization for sleep scheduling, which requires all neighboring nodes to wake up at the same time, nor assumes duty-cycled awareness, which makes the protocol difficult to use in low duty-cycled operations. In our DCEB protocol, a distributed algorithm for constructing a broadcast backbone is presented, including its energy-balanced maintenance mechanism. Then, the decision conditions of broadcast forwarding time with or without delay constraint are deduced. Experimental results prove that DCEB reduces much more broadcast cost under the decision conditions and provides better broadcast performance than the Unicast Scheme.

The advances in technologies of cloud computing and mobile computing enable the newly emerging mobile cloud computing paradigm. Three approaches have been proposed for mobile cloud applications: 1) extending the access to cloud services to mobile devices; 2) enabling mobile devices to work collaboratively as cloud resource providers; 3) augmenting the execution of mobile applications on portable devices using cloud resources. In this paper, we focus on the third approach in supporting mobile data stream applications. More specifically, we study the computation partitioning, which aims at optimizing the partition of a data stream application between mobile and cloud such that the application has maximum speed/throughput in processing the streaming data. To the best of our knowledge, it is the first work to study the partitioning problem for mobile data stream applications, where the optimization is placed on achieving high throughput of processing the streaming data rather than minimizing the make span of executions in other applications. We first propose a framework to provide runtime support for the dynamic partitioning and execution of the application. Different from existing works, the framework not only allows the dynamic partitioning for a single user but also supports the sharing of computation instances among multiple users in the cloud to achieve efficient utilization of the underlying cloud resources. Meanwhile, the framework has better scalability because it is designed on the elastic cloud fabrics. Based on the framework, we design a genetic algorithm to perform the optimal partition. We have conducted extensive simulations. The results show that our method can achieve more than 2X better performance over the execution without partitioning.

Existing XML filtering approaches suffer from excessive overheads incurred in matching time and the storage/memory space needed during the matching process. This makes them unsuitable in mobile computing environment, where computing resources are extremely scarce. Hence there is a need to formulate a filtering mechanism that optimizes the computation and space constraints in performing XML filtering across a distributed environment. In our experiments, we found that the time imposed on parsing is a dominant factor of the total matching time cost, and the space needed is largely dependent on the structural representation. Motivated by these insights, we developed a highly compact structure representation using bloom filter, which also provides an easy solution for separation of the parsing process from the matching process so as to relief the burden of parsing from the matching. In general, our proposed method includes a preprocessing component, where the incoming documents/subscriptions are parsed and fed into the bloom-filter creator, and a matching component, where the bloom-filter will be used for evaluation. Experiments show that, by our approach, the matching time is significantly reduced due to the separation of parsing and matching, and the space for indexing structure is tremendously reduced due to the compactness of bloom filter. Although the bloom filter introduced false positive errors in the matching results, it can be controlled to a selectable and reasonable range. Importantly, considering the significant speedup and performance gain, our approach represents a viable solution when time/space efficiency is paramount.

Wireless sensor networks (WSNs) should handle multiple sensing tasks for various applications. How to improve the quality of the data acquired in such resource constrained environment is a challenging issue. In this paper, we propose a sensor-channel co-allocation model for scheduling the sensing tasks. The proposed model considers the capability, coupling and load balancing constraints for sensing data acquisition, and can guarantee transmission of sensed data in real-time while avoiding data incompleteness in an efficient way. A spatiotemporal metric called sensing-span is proposed to evaluate the tasks' execution cost of achieving desired data quality. We extend computation task scheduling a lgorithms to support sensor-channel co-allocation problem and a heuristic called Minimum Service Capability Fragment (MSCF) is introduced for task scheduling to minimize the waste of reserved channel capacity. Simulation results show that MSCF can improve the performance of data acquisition in WSNs as compared with other heuristics, when scheduling a large number of concurrent data acquisition tasks.

Computation and networking resources in mobile operating environments are much scarcer and more dynamic than in desktop operating environments. Mobile applications can leverage on the benefits of adaptive computing to optimize the QoS delivery based on contextual situations. Fuzzy control models have been successfully applied to various distributed network QoS management systems. However, existing models are either application-specific or limited to abstract modeling and simple conceptual scenarios which do not take into account overall model scalability. Specifically, the large number of QoS parameters in a mobile operating environment causes an exponential increase in the number of rules correspondingly increases the demand for processing power to infer the rules. Hierarchical fuzzy systems were introduced to reduce the number of rules using hierarchical fuzzy control, in which correlated linguistic variables are hierarchically inferred and grouped into abstract linguistic variables. In this paper, we propose a mobile QoS management framework that uses a hierarchical fuzzy control model to support a highly extensible and structured adaptation paradigm. The proposed framework integrates several levels of QoS abstractions derived from user-perceived requirements.

One way to improve the throughput of a wireless ad hoc network at the media access (MAC) layer is to allow as much as possible concurrent transmissions among neighboring nodes. In this paper, we present a novel high-throughput MAC protocol, called Concurrent Transmission MAC(CTMAC), which supports concurrent transmission while allowing the network to have a simple design with a single channel, single transceiver, and single transmission power architecture. CTMAC inserts additional control gap between the transmission of control packets (RTS/CTS) and data packets (DATA/ACK), which allows a series of RTS/CTS exchanges to take place between the nodes in the vicinity of the transmitting or receiving node to schedule possible multiple, concurrent data transmissions. To safeguard the concurrent data transmission, collision avoidance information is included in the control packets and used by the neighboring nodes to determine whether they should begin their transmissions. Also, to isolate the possible interference between DATA packets and ACK packets, a new ACK sequence mechanism is proposed. Simulation results show that a significant gain in throughput can be obtained by the CTMAC protocol compared with the existing work including the IEEE 802.11 MAC protocol.

In a mobile cooperative caching environment, we observe the need for cooperating peers to cache useful data items together, so as to improve cache hit from peers. This could be achieved by capturing the data requirement of individual peers in conjunction with their mobility pattern, for which we realized via a GROup-based COoperative CAching scheme (GroCoca). In GroCoca, we define a tightly-coupled group (TCG) as a collection of peers that possess similar mobility pattern and display similar data affinity. A family of algorithms is proposed to discover and maintain all TCGs dynamically. Furthermore, two cooperative cache management protocols, namely, cooperative cache admission control and replacement, are designed to control data replicas and improve data accessibility in TCGs. A cache signature scheme is also adopted in GroCoca in order to provide information for the mobile clients to determine whether their TCG members are likely caching their desired data items and to perform cooperative cache replacement Experimental results show that GroCoca outperforms the conventional caching scheme and standard COoperative CAching scheme (COCA) in terms of access latency and global cache hit ratio. However, GroCoca generally incurs higher power consumption.

Computation and networking resources in mobile operating environments are much scarcer and more dynamic than in desktop operating environments. Mobile applications require the benefits of adaptive computing to optimize the QoS management of dynamic contextual situations. Fuzzy control models have been successfully applied to various distributed network QoS managements systems. However, these models are either application-specific or limited to abstract modeling and simple conceptual scenarios that do not take into account overall model scalability. Specifically, the large number of QoS parameters in mobile operating environment causes the rule-explosion problem, in which an exponential increase in the number of rules increases the demand for processing power to infer the rules. Hierarchical fuzzy systems were introduced to reduce the number of rules using hierarchical fuzzy control, in which correlated linguistic variables are hierarchically inferred and grouped into abstract linguistic variables which can then be used as input for higher level fuzzy rules. In this paper, we propose a mobile QoS management framework that uses a hierarchical fuzzy control model to support a highly extensible and uncomplicated adaptation paradigm. This framework makes use of the synergy between mobile operating environments, mobile services and mobile applications, produces optimal system performance and satisfies the QoS needs of individual mobile applications.

The use of middleware is one important approach to facilitating adaptation across wireless and mobile environments, where augmented service entities are composed and deployed to shield mobile clients from the effects of dynamic network characteristics. The MCL system provides a language-based approach to the building of mobile applications running in an adaptive middleware, MobiGATE. In particular, MCL is formalized by means of the design and development of a semantic model based on Z language, which can be used to analyze architectural descriptions and detect possible composition errors like feedback loops. To verify the semantic model and its ability to provide runtime checking of composition, we have developed and implemented a Java tool to demonstrate how Z semantic models are mapped into computational structures to provide on-the-fly verifications.

In wireless sensor networks, energy is the most crucial resource. In-network data processing is a common technique in which an intermediate proxy node is chosen to house a possibly complicated data transformation function to consolidate the sensor data streams from the source nodes, en route to the sink node. We investigate into the placement problem of the proxy. We formulate and solve the energy minimization problem analytically, based on an ENergy- Efficient Rate-Governed Yardstick (ENERGY). An optimal solution is derived based on complete network topology information. Taking into account realistic sensor network constraints that only neighboring network connectivity is known to a node, we develop an approximate but effective solution, ENERGY . We evaluate the performance of ENERGY, which performs well even in low-density networks and for queries requesting from data sources at a distance.

Abstract The monitor concept provides a structured and flexible high‐level programming construct to control concurrent accesses to shared resources. It has been widely used in a concurrent programming environment for implicitly ensuring mutual exclusion and explicitly achieving process synchronization. This paper proposes an extension to the monitor construct for detecting runtime errors in monitor operations. Monitors are studied and classified according to their functional characteristics. A taxonomy of concurrency control faults over a monitor is then defined. The concepts of a monitor event sequence and a monitor state sequence provide a uniform approach to history information recording and fault detection. Rules for detecting various types of faults are defined. Based on these rules, fault‐detection algorithms are developed. A prototypical implementation of the proposed monitor construct with runtime fault detection mechanisms has been developed in Java. We shall briefly report our experience with and the evaluation of the robust monitor prototype. Copyright © 2005 John Wiley & Sons, Ltd.

Abstract The use of middleware is one important approach in facilitating adaptation across wireless and mobile environments, where augmented service entities are composed and deployed to shield mobile clients from the effects of dynamic network characteristics. The MobiGate Coordination Language (MCL) system provides a language‐based approach to the building of mobile applications running in an adaptive middleware, MobiGATE. The concept of the separation of concerns forms the underlying and unifying principle in the provision of the adaptive composition of services. Specifically, a coordination language, MCL, is designed to provide rich constructs supporting the definition of compositions, with constrained type validation and checking. In particular, MCL is formalized by means of the design of a semantic model based on the Z language, which can be used to analyze architectural descriptions and detect possible composition errors such as feedback loops and open circuit problems. Copyright © 2006 John Wiley & Sons, Ltd.

The use of gateway proxies is one important approach to facilitating adaptation across wireless and mobile environments. Importantly, augmented service entities deployed within the gateway proxy residing on the wired network can be composed and deployed to shield mobile clients from the effects of poor network characteristics. The usual approach to the static composition of service entities on the gateway proxy is to have these service entities interact with each other by explicitly invoking procedures on the named interface, but such a tight coupling of interfaces inhibits the flexible composition and adaptation of the service entities to the dynamic operating characteristics of wireless networks. In this paper, we present a mobile gateway for the active deployment of transport entities or, for short, MobiGATE (pronounced Mobi-Gate). MobiGATE is a mobile middleware framework that supports the robust and flexible composition of transport entities, known as streamlets. The flow of data traffic is subjected to processing by a chain of streamlets. Each streamlet encapsulates a service entity that adapts the flow of traffic across the wireless network. To facilitate the dynamic reconfiguration of the streamlets, we advocate applying the concept of coordination as the unifying approach to composing these transport service entities. Importantly, MobiGATE delineates a clear separation of interdependent parts from the service-specific computational codes of those service entities. It does this by using a separate coordination language, called MobiGATE coordination language (MCL), to describe the coordination among streamlet service entities. The complete design, implementation, and evaluation of the MobiGATE system are presented in this paper. Initial experimental results validate the flexibility of the coordination approach in promoting separation-of-concern in the reconfiguration of services, while achieving low computation and delay overheads.

The infiltration of the Web as the preferred choice for online e-commerce and IT applications has motivated the need to introduce innovative mechanisms to enforce strong security monitoring and control on transactions conducted over a distributed environment. The smart card technology presents an attractive solution for providing strong security and access control mechanisms that are tightly bound and associated to the individual carrying and owning the card. Despite its potential, smart card services have not been integrated into the networked environment in the way other portable computing devices, such as notebooks, PDA, mobile phones, and so on, have been. This has motivated our design for a distributed computing platform for smart card services to operate over a service-oriented architecture (SOA) based on evolving Web services technology. In particular, the paper presents the design of the WSCard (in short for Web services card) architecture and its implementation based on the application of Web services wrapping technology. Importantly, the design allows us to exploit Web services flexibility to provide a heterogeneous and promote rapid integration of smart card services as first class citizens of Web services. With WSCard, existing service-oriented applications can seamlessly interoperate with smart card services by treating the card services as native Web services, while employing established Web services standards - SOAP, WSDL and UDDI.

In this paper, we propose a reliable multicast protocol for mobile agent communications, which is a multicast extension to our previous adaptive and reliable protocol (ARP). ARP uses the mailbox-based scheme, where each mobile agent is associated with a mailbox for message delivery. The mailbox can be decoupled from the mobile agent and migrate with lower mobility. By adjusting the system parameters such as synchronization between mobile entities and mailbox migration frequency, ARP achieves adaptability and ensures reliability. In extending ARP to group communications, we group mailboxes residing on a host and belonging to the same multicast group into a cluster, and let all mailbox clusters form a logical ring. We present a token-based algorithm and a mailbox migration algorithm to achieve atomicity and total ordering of multicast messages. Also, we prove the correctness of the protocol and discuss the performance evaluation results obtained from simulations.

Caching is a key technique for improving data retrieval performance of mobile clients. The emergence of state-of-the-art peer-to-peer communication technologies now brings to reality what we call "cooperative caching" in which mobile clients not only can retrieve data items from mobile support stations, but also from the cache in their peers, thereby inducing a new dimension for mobile data caching. In this paper, we propose a distributed group-based cooperative caching scheme, in which we define the concept of a tightly-coupled group (TCG) by capturing the data affinity of individual peers and their mobility patterns, in a mobile broadcast environment. A distributed stable peer discovery protocol is proposed for discovering all TCGs dynamically. In addition, a cache signature scheme is adopted to provide hints for the mobile clients to determine whether their required data items are cached by their neighboring peers, and to perform cooperative cache replacement to increase overall data availability. Simulation studies are conducted to evaluate the effectiveness of our distributed group-based cooperative caching scheme.

Context-aware mobile computing middleware is designed to automatically adapt its behavior to changing environment. To achieve this, an important issue to be addressed is how to effectively select services for adaptation according to the user's current context. Existing work does not adequately address this issue. In this paper, we propose a fuzzy-based service adaptation model (FSAM) that can be used in context-aware middleware. We formulate the service adaptation process by using fuzzy linguistic variables and membership degrees to define the context situations and the rules for adopting the policies of implementing a service. We propose three fitness functions to calculate the fitness degree for each policy based on the distance of fuzzy status between the policy and the current context situation. The decision for service adaptation is achieved by selecting the policy with the largest fitness degree. A context-aware application scenario called Campus Assistant is used to exemplify the proposed service adaptation process and demonstrate its effectiveness.

GOP is a graph-oriented programming model which aims at providing high-level abstractions for configuring and programming cooperative parallel processes. With GOP, the programmer can configure the logical structure of a parallel/distributed program by constructing a logical graph to represent the communication and synchronization between the local programs in a distributed processing environment. This paper describes a visual programming environment, called VisualGOP, for the design, coding, and execution of GOP programs. VisualGOP applies visual techniques to provide the programmer with automated and intelligent assistance throughout the program design and construction process. It provides a graphical interface with support for interactive graph drawing and editing, visual programming functions and automation facilities for program mapping and execution. VisualGOP is a generic programming environment independent of programming languages and platforms. GOP programs constructed under VisualGOP can run in heterogeneous parallel/distributed systems. Copyright © 2005 John Wiley & Sons, Ltd.

WEBGOP is a programming architecture for collaborative Web services using graph-oriented programming. The motivation for the project comes from the realization that the integration of collaborative Web services lacks support. The aim of WEBGOP is to extend the Web from a client-server system to a structured multipoint system. A graph abstraction of the network provides the structure for the integration of Web services and facilitates their configuration and programming. Using WEBGOP, a logical graph representing a virtual-overlay network over the Internet is created to link up collaborative Web services. Web services are individually or jointly invoked through either unicast or multicast messages within the overlay network. All messages are based on the simple-object access protocol (SOAP). This forms an extension of the hypertext transfer protocol (HTTP) to support the distributed invocation of Web services. The Web services on different servers work collaboratively for a multipoint network application. This project provides a structured integration of Web services by extending the support of intermediary processing in a multipoint service. It also provides a rich network-programming interface for a new class of integrated Web applications while retaining the use of the Internet protocol and HTTP.

Caching is a key technique for improving data retrieval performance of mobile clients in mobile environments. The emergence of robust and reliable peer-to-peer (P2P) technologies now brings to reality what we call "cooperative caching" in which mobile clients can access data items from the cache in their neighboring peers. This paper considers a COoperative CAching scheme for mobile systems, called COCA. A cache signature scheme is devised for COCA that provides hints for the mobile clients to determine whether a required data item is cached by their neighboring peers based on their local state. The trade-off between the improvement in system performance and the overheads of the cache signature scheme in COCA is discussed. The performance of COCA with and without the cache signature scheme is evaluated through a number of simulated experiments. COCA is shown to be capable of effectively reducing the number of server requests and power consumption, as well as shortening the access latency as the number of neighboring peers increases. The inclusion of cache signature scheme further improves on the access latency.

Using gateway proxies is one important approach to facilitating adaptation across wireless and mobile environments. Importantly, augmented service entities deployed within the gateway proxy residing on the wired network can be composed and deployed to shield mobile clients from the effects of poor network characteristics. The usual approach to the static composition of service entities on the gateway proxy is to have these service entities interact with each other by explicitly invoking procedures on the named interface. The tight coupling of interfaces inhibits the flexible composition and adaptation of the service entities to the dynamic operating characteristics of wireless networks. We present a Mobile GATEway for the Active deployment of Transport Entities or MobiGATE (pronounced as Mobi-Gate) for short. MobiGATE is a mobile middleware framework that supports the robust and flexible composition of transport entities, known as streamlets. The flow of data traffic is subjected to processing by a chain of streamlets. Each streamlet encapsulates a service entity that serves to adapt the flow of traffic across the wireless network. To facilitate the dynamic reconfiguration of the streamlets, we advocate applying the concept of coordination as the unifying approach to composing these transport service entities. Importantly, MobiGATE delineates a clear separation of interdependency parts from the service-specific computational codes of those service entities by using a separate coordination language to describe the coordination among streamlet service entities. To this end, we have defined a compositional language called MobiGATE Coordination Language (MCL) that provides rich constructs to support the definition of compositions, with constrained type validation and checking.

Mobile agents (MAs) can support mobile computing by carrying out tasks autonomously for a mobile user temporarily disconnected from the network. We describe PDAgent, a lightweight and highly portable platform for developing and deploying mobile agent-enabled applications on wireless handheld devices. Our approach offers the following advantages: (i) It does not require installing MA server on handheld devices and supports the adoption of any kind of mobile agent system at network hosts, while at the same time allow mobile users to have control of mobile agent activities; (ii) It support dynamic downloading of MA-enabled applications which can be made aware of and adaptive to the user's current context, and deploying the application to perform various tasks on behalf of the user over the wired network; (iii) It requires the minimum network connectivity and cost for users to deploy their applications. PDAgent provides APIs which allow developers to build new mobile applications on top of PDAgent. Example applications have been developed for PDAgent. We report on and discuss the results of experimental performance evaluations of PDAgent.

Caching is a key technique for improving data retrieval performance of mobile clients. The emergence of robust and reliable peer-to-peer (P2P) communication technologies now brings to reality what we call "cooperating caching" in which mobile clients not only can retrieve data items from mobile support stations, but also can access them from the cache in their neighboring peers, thereby inducing a new dimension for mobile data caching. This work extends a cooperative caching scheme, called COCA, in a pull-based mobile environment. Built upon the COCA framework, we propose a group-based cooperative caching scheme, called GroCoca, in which we define a tightly-coupled group (TCG) as a set of peers that possess similar movement pattern and exhibit similar data affinity. In GroCoca, a centralized incremental clustering algorithm is used to discover all TCGs dynamically, and the MHs in same TCG manage their cached data items cooperatively. In the simulated experiments, GroCoca is shown to reduce the access latency and server request ratio effectively.

Using gateway proxies is one important approach to facilitating adaptation across wireless and mobile environments. Importantly, augmented service entities deployed within the gateway proxy residing on the wired network can be composed and deployed to shield mobile clients from the effects of poor network characteristics. The usual approach to the static composition of service entities on the gateway proxy is to have these service entities interact with each other by explicitly invoking procedures on the named interface. The tight coupling of interfaces inhibits the flexible composition and adaptation of the service entities to the dynamic operating characteristics of wireless networks. We present a Mobile GATEway for the active deployment of transport entities or MobiGATE (pronounced as MobiGate) for short. MobiGATE is a mobile middleware framework that supports the robust and flexible composition of transport entities, known as streamlets. The flow of data traffic is subjected to processing by a chain of streamlets. Each streamlet encapsulates a service entity that serves to adapt the flow of traffic across the wireless network. To facilitate the dynamic reconfiguration of the streamlets, we advocate applying the concept of coordination as the unifying approach to composing these transport service entities. Importantly, MobiGATE delineates a clear separation of interdependency parts from the service-specific computational codes of those service entities by using a separate coordination language to describe the coordination among streamlet service entities. To this end, we have defined a compositional language called MobiGATE coordination language (MCL) that provides rich constructs to support the definition of compositions, with constrained type validation and checking.

The formulation of a context-aware middleware requires researchers to devise suitable control mechanisms that allow applications to directly participate in resource adaptation in response to dynamic operating environments. This paper describes the design and implementation of an event model for a highly adaptive mobile middleware, Web Proxy for Actively Deployable Services (WebPADS) platform. The event model provides a highly composable event notification framework that uses multiple levels of environment monitors to provide a complex setup of composite events. Based on the event model and the dynamic reconfiguration feature WebPADS supports context awareness and a high level of adaptation to contextual changes through reconfiguration and migration of services.

XML (extensible Markup Language) has been developed and deployed by domain-specific standardization bodies and commercial companies. Studies have been conducted on a wide variety of issues encompassing XML. In the use of XML for wireless computing, the focus has been on investigating ways to efficiently represent XML data for transmission over a wireless environment. We propose a middleware, Xstream (XML Streaming), for efficiently streaming XML contents over a wireless environment by leveraging the rich semantics and structural characteristics of XML documents and by flexibly managing units containing fragments of data into autonomous units, known as XDU (Xstream Data Unit) fragments. The concept of an XDU is fundamental to the operation of Xstream. It provides for the efficient transfer of documents across a wireless link and allows other issues and challenges pertaining to wireless transmission to be addressed. By fragmenting and organizing an XML document into XDU fragments, we are able to incrementally send fragments across a wireless link, while the receiver is able to perform look-ahead processing of the document without having to wait for the entire document to be downloaded. We propose a fragmenting strategy based on the value of the wireless link's Maximum Transfer Units (MTUs). In addition, we present and evaluate several packetizing strategies, i.e., strategies wherein a collection of XDUs are grouped into a packet to optimize packet delivery and processing. At the receiving end of this process, a reassembly strategy incrementally reconstructs the XML document as XDU fragments are being received, thereby facilitating client application implementation of look-ahead processing.

XML (eXtensible Markup Language) has been developed and deployed by domain-specific standardization bodies and commercial companies. We investigate the possibilities and issues encompassing the use of generalized XML in a wireless computing environment. Current approaches of fragmenting data do not take into account of the semantics and structure of the data, therefore ignoring the specific needs of individual application. We propose a middleware, Xstream (XML Streaming) for augmenting XML contents by leveraging on the rich semantics and structural characteristics of the XML document into autonomous units, which are known as XDU (Xstream Data Unit). In this paper we describe the framework and the techniques involved and study the performance of the techniques.

Based on business processes, composite Web services combine the offerings of two or more Web services to achieve the desired business goals. Several candidate standards have been proposed, providing a foundation for composite Web service specifications. However, at a higher level, there is no framework that supports composite Web service construction and automation. We propose a framework that facilitates the visual design, validation and automation of composite Web services. The framework is based mainly on Web service composition graph (WSCG), the underlying formalism for composite Web services. Using graph grammar and graph transformation defined on WSCG, the static topological structure of a composite Web service can be described in an intuitive way and the automation of the constructed composite Web services is also facilitated with a sound formal semantic basis. We also outline the design and implementation of a prototype for the proposed framework.

WebGOP is a programming architecture for collaborative web services using graph oriented programming. The motivation of the project comes form the realization of the lack of support for the integration of collaborative Web services. The aim of WebGOP is to extend the Web from a client-server system to a structured multi-point system. A graph abstraction of network provides the structure for the integration of Web services and facilitates their configuration and programming. Using WebGOP, a logical graph representing a virtual overlay network over the Internet is created to link up collaborative Web services. The Web services on different servers work collaboratively for a multi-point network application.

This paper describes a dynamic service reconfiguration model where the proxy is composed of a chain of service objects called mobilets (pronounced as mo-be-lets), which can be deployed onto the network actively. This model offers flexibility because the chain of mobilets can be dynamically reconfigured to adapt to the vigorous changes in the characteristics of the wireless environment, without interrupting the service provision for other mobile nodes. Furthermore, mobilets can also be migrated to a new proxy server when the mobile node moves to a different network domain. We have realized the dynamic service reconfiguration model by crafting its design into a programmable infrastructure that forms the baseline architecture of the WebPADS (short for Web Proxy for Actively Deployable Services) system.

Abstract This paper presents a graph‐oriented framework, called WebGOP, for architecture modeling and programming of Web‐based distributed applications. WebGOP is based on the graph‐oriented programming (GOP) model, under which the components of a distributed program are configured as a logical graph and implemented using a set of operations defined over the graph. WebGOP reshapes GOP with a reflective object‐oriented design, which provides powerful architectural support in the World Wide Web environment. In WebGOP, the architecture graph is reified as an explicit object which itself is distributed over the network, providing a graph‐oriented context for the execution of distributed applications. The programmer can specialize the type of graph to represent a particular architecture style tailored for an application. WebGOP also has built‐in support for flexible and dynamic architectures, including both planned and unplanned dynamic reconfiguration of distributed applications. We describe the WebGOP framework, a prototypical implementation of the framework on top of SOAP, and a performance evaluation of the prototype. The prototype demonstrated the feasibility of our approach. Results of the performance evaluation showed that the overhead introduced by WebGOP over SOAP is reasonable and acceptable. Copyright © 2003 John Wiley & Sons, Ltd.

Traditionally, middleware technologies, such as CORBA, Java RMI, and Microsoft's DCOM, have provided a set of distributed computing services that essentially abstract the underlying network services to a monolithic "black box." In a mobile operating environment, the fundamental assumption of middleware abstracting a unified distributed service for all types of applications operating over a static network infrastructure is no longer valid. In particular, mobile applications are not able to leverage the benefits of adaptive computing to optimize its computation based on current contextual situations. In this paper, we introduce the Mobile Platform for Actively Deployable Service (MobiPADS) system. MobiPADS is designed to support context-aware processing by providing an executing platform to enable active service deployment and reconfiguration of the service composition in response to environments of varying contexts. Unlike most mobile middleware, MobiPADS supports dynamic adaptation at both the middleware and application layers to provide flexible configuration of resources to optimize the operations of mobile applications. Within the MobiPADS system, services (known as mobilets) are configured as chained service objects to provide augmented services to the underlying mobile applications so as to alleviate the adverse conditions of a wireless environment.

This paper presents a novel architectural approach to support fault tolerance in component-based distributed software (CBDS) through dynamic reconfiguration. Using the graph-oriented programming (GOP) model, the software architecture of CBDS is specified by a logical graph which is reified as an explicit object distributed over the network. Dynamic reconfiguration is implemented by executing a set of operations defined over the graph. The approach supports fault tolerance by dynamically reconfiguring the CBDS upon detection of faults. We describe the basic model, the system architecture and its prototype implementation on top of CORBA.

Describes a Web proxy architecture called WebPADS, short for "Web Proxy for actively deployable services." The RebPADS was developed to enhance Web applications running on a wireless network. The RebPADS provides mechanisms to automatically locate and configure a flexible and adaptive wireless Web proxy. In addition, it provides a framework that facilitates the development of add-on services, where the services can be actively deployed and migrated across Web proxies, in order to adapt to the changing wireless environment.

This paper presents a novel approach, called WebGOP, for architecture modeling and programming of web-based distributed applications. WebGOP uses the graph-oriented programming (GOP) mode, under which the components of a distributed program are configured as a logical graph and implemented using a set of operations defined over the graph. WebGOP extends the application of GOP to the World Wide Web environment and provides more powerful architectural support. In WebGOP, the architecture graph is reified as an explicit object which itself is distributed over the network providing a graph-oriented context for the execution of distributed applications. The programmer can specialize the type of a graph to represent a particular architecture style tailored for an application. WebGOP also has built-in support for flexible and dynamic architectures, including dynamic reconfiguration. We describe the WebGOP framework, a prototypical implementation of the framework on top of SOAP, and performance evaluation of the prototype. Results of the performance evaluation showed that the overhead introduced by WebGOP over SOAP is reasonable and acceptable.

This paper describes a Web proxy architecture called WebPADS, which is in short for "Web proxy for actively deployable services". WebPADS is developed to enhance Web applications running on wireless networks. WebPADS provides mechanisms that automatically locate and configure a flexible and adaptive wireless Web proxy. In addition, it provides a framework that facilitates the development of add-on services, which can be actively deployed and migrated across Web proxies, in order to adapt to the changing wireless environment.

Abstract XML holds the promise to yield (1) a more precise search by providing additional information in the elements, (2) a better integrated search of documents from heterogeneous sources, (3) a powerful search paradigm using structural as well as content specifications, and (4) data and information exchange to share resources and to support cooperative search. We survey several indexing techniques for XML documents, grouping them into flat‐file, semistructured, and structured indexing paradigms. Searching techniques and supporting techniques for searching are reviewed, including full text search and multistage search. Because searching XML documents can be very flexible, various search result presentations are discussed, as well as database and information retrieval system integration and XML query languages. We also survey various retrieval models, examining how they would be used or extended for retrieving XML documents. To conclude the article, we discuss various open issues that XML poses with respect to information retrieval and database research.

The monitor concept provides a structured and flexible high-level programming construct to control concurrent accesses to shared resources. It has been widely used in concurrent programming environments for implicitly ensuring mutual exclusion and explicitly achieving process synchronization. This paper proposes an extension to the monitor construct for detecting run-time errors in monitor operations. Monitors are studied and classified according to their functional characteristics. A taxonomy of concurrency control faults over a monitor is then defined. The concepts of a monitor event sequence and a monitor state sequence provide a uniform approach to history information recording and fault detection. Rules for detecting various types of faults are defined. Based on these rules, fault detection algorithms are developed. A prototypical implementation of the proposed monitor construct with run-time fault detection mechanisms has been developed in Java. We briefly report our experience with and evaluation of our robust monitor prototype.

The paper presents the design and implementation of a self-paced and adaptive courseware, in short SAC. The main focus of SAC is to formulate a model that encompasses the important requirements of supporting an adaptive learning courseware environment. The paper begins by discussing the issues and design requirements of developing an interactive and adaptive learning system that is able to individualize a student learning style, with the ultimate objective of maximizing his learning experience and effectiveness. The system has been designed and implemented on a three-tier Web application architecture, which uses the AHAM (Adaptive Hypermedia Application Model) approach to structure the domain, user and teaching model for use by the adaptation engine.

This paper describes a distributed monitor construct implemented in Java. The monitor construct has been widely used for ensuring mutual exclusion and achieving process synchronization in a centralized multiprogramming environment. Extending the monitor to a distributed environment facilitates the development of distributed applications which require resource sharing and synchronization. The distributed monitor construct presented in this paper is based on a well-known tree-based distributed mutual exclusion algorithm proposed by Kerry Raymond, augmented with of a two-level system structure for scalability and efficiency. The design and implementation of the facility in Java has been presented in a previous paper. In this paper we focus on the correctness analysis and performance evaluation of the construct. Using a Java application for solving the distributed version of the producer-consumer problem, experiments have been carried out to evaluate the performance of the proposed distributed constructor. The results show that, with the use of the two-level system architecture, the average amount of time and the average number of messages used by a process to gain permission to enter its critical section are improved. Furthermore, factors that affect the performance including the tree configuration, the distribution of processes over the nodes, the workload, and the length of the critical sections, are discussed and the observations from the results are reported.

Programmable networks are a class of evolving network architecture aimed to overcome the slow evolution of existing network protocols by augmenting networking nodes and associated software drivers with the capability to be programmable. When applied, new services can be deployed and implemented rapidly to enable customization of network properties for domain-specific applications. In this paper, we propose the PANTA architecture, which will support robust and rapid deployment of new services over existing network infrastructures based on the concept of a transport splicing technique. It uses a graph-oriented approach as the unifying abstraction for programming the underlying active network structure.