Pervasive computing promotes an environment that blurs the distinction between digital and physical devices and integrates all entities in a physical space into a cohesive programmable unit. Some of the early research activities in pervasive computing focused on developing infrastructures for pervasive applications. These infrastructures successfully merged physical and digital entities in an environment to create aware homes, smart offices and active spaces. In recent years, ad-hoc pervasive computing has attracted attention with the proliferation of low cost, short-range wireless devices. Ad-hoc pervasive computing does not assume digital devices to be tied to physical environments and aims to create digital "clusters" that can be viewed as a unified entity. The user can program this cluster of devices with a single programming interface. In this paper, AVC introduce our middleware, called Mobile Gaia, for ad-hoc pervasive computing. Mobile Gaia is a services-based middleware that integrates resources of various devices. It manages several functions such as forming and maintaining device collections, sharing resources among devices and enables seamless service interactions. It also provides an application framework to develop applications for the device collection. The application framework decomposes the application into smaller components that can run on different devices in this collection. We discuss the architecture of mobile Gaia and introduce a sample application that has been designed using our middleware.

Pervasive Computing advocates the enhancement of physical spaces with computing and communication resources that help users perform various kinds of tasks. We call these enhanced physical spaces Active Spaces. Active Spaces are highly dynamic — the context and resources available in these evironments can change rapidly. The large number of entities present in these spaces and the dynamism associated with them make it difficult for developers to program these environments. It is not always clear at development time which resources are to be used for performing various kinds of tasks and how to use them. In this paper, we introduce a new high-level programming model for pervasive computing environments, Olympus. The main feature of this model is that developers can specify Active Space entities and common Active Space operations at an abstract, high level. Active Space entities (which include services, applications, devices, physical objects, locations and users) can be specified using high level descriptions. Our framework resolves these descriptions into actual Active Space entities based on constraints specified by the developer, ontological descriptions of entities, the resources available in the current space, space-level policies and the current context of the space. The programming model also provides the developers with operators for commonly used functions. Examples of operators include start, stop and move components. Thus, developers do not have to worry about how various tasks are performed in the space in which their program is to be deployed. These details are taken care of by the model and the developer is free to focus on the actual logic of the program. In this paper, we discuss the programming model, its implementation and several example Active Space programs that have been developed using this model.

Component technology promotes code reuse by enabling the construction of complex applications by assembling off-the-shelf components. However, components depend on certain characteristics of the environment in which they execute. They depend on other software components and on hardware resources. In existing component architectures, the application developer is left with the task of resolving those dependencies, i.e. making sure that each component has access to all the resources it needs and that all the required components are loaded. Nevertheless, according to encapsulation principles, developers should not be aware of the component internals. Thus, it may be difficult to find out what a component really needs. In complex systems, such as the ones found in modern distributed environments, this manual approach to dependency management can lead to disastrous results. Current systems rely heavily on manual configuration by users and system administrators. This is tolerable now, when users have to manage a few computers. But, in the near future, people will have to deal with thousands of computing devices and it will no longer be acceptable to require the user to configure each of them. This paper presents the results of our 6 year research (from 1998 to 2003) in the area of automatic configuration, describing an integrated architecture for managing dependencies in distributed component-based systems. The architecture supports automatic configuration and dynamic resource management in distributed heterogeneous environments. We describe a concrete implementation of this architecture, present experimental results, and compare our approach to other works in the area. Copyright © 2005 John Wiley & Sons, Ltd.

Ubiquitous computing has fueled the idea of constructing sentient, information-rich "smart spaces" that extend the boundaries of traditional computing to encompass physical spaces, embedded devices, sensors, and other machinery. To achieve this, smart spaces need to capture situational information so that they can detect changes in context and adapt themselves accordingly. However, without considering basic security issues ubiquitous computing environments could be rife with vulnerabilities. Ubiquitous computing environments impose new requirements on security. Security services, like authentication and access control, have to be non-intrusive, intelligent, and able to adapt to the rapidly changing contexts of the spaces. We present a ubiquitous security mechanism that integrates context-awareness with automated reasoning to perform authentication and access control in ubiquitous computing environments.

Active networks aim to provide a software framework that enables network applications to customize the processing of their communication packets. Security is of critical importance to the success of active networking. This paper presents a design and a description of the implementation for securing the node of an active network using active networking principles. The secure node architecture includes an active node operating system security API, an active security guardian, and quality of protection (QoP) provisions. The architecture supports highly customized and situational policies created by users and applications dynamically. It permits active nodes to satisfy the application-specific dynamic security and protection requirements. The secure node architecture can provide a fundamental base for securing the active network infrastructure. We describe the integration of secure node architecture into an active network software system to demonstrate its flexible and innovative features.

Ubiquitous computing is poised to revolutionize the way we compute and interact with each other. However, unless privacy concerns are taken into account early in the design process, we will end up creating a very effective distributed surveillance system, which would be a dream come true for electronic stalkers and "big brothers". We present a protocol, which preserves the privacy of users and keeps their communication anonymous. In effect, we create a "mist" that conceals users from the system and other users. Yet, users will still be able to enjoy seamless interaction with services and other entities that wander within the ubiquitous computing environment.

This paper discusses the design and implementation for supporting customized security services in active networks using active networking principles. The customized security services support is based on a secure node architecture that includes an active node operating system security API, an active security guardian, and quality of protection provisions. The support of highly customized security services permits active nodes to satisfy the application-specific dynamic security and protection requirements. It associates quality of protection with network software and application security. Applications can dynamically select the suitable security configurations and services at each active routing node, based on their security and performance requirements. The secure node architecture, together with the support of dynamically customized security services, can provide a fundamental base for securing the active network infrastructure and active applications.

We discuss our approach to constructing a dynamic and secure smart home environment and tackling the challenges associated with it. We envision a smart home as an active environment populated with smart, dynamically configurable consumer devices capable of interacting with humans and other smart devices. In such a dynamic and active environment, there is a great need for an agile, lightweight, distributed security mechanism. This security mechanism needs to be programmable and able to evolve as rapidly as the environment itself. Yet, this mechanism should be able to adapt to environments with scarce resources. We present Tiny SESAME to meet these challenges while utilizing Jini/sup TM/ technology from Sun Microsystems to handle the common parts of distributed devices. Tiny SESAME is a lightweight component-based, Java-implementation of a subset of SESAME. SESAME is an extension to Kerberos that supports public key technologies, access control, and delegation of access rights. We discuss our Tiny SESAME and how it could be integrated with handheld and consumer devices.

The first decades of the new millennium will witness an explosive growth in the number and diversity of networked devices and portals. We foresee high degrees of mobility, heterogeneity, and interactions among computing devices connected to global networks. While previous research in distributed operating systems solved many problems related to resource management, they seldom addressed the problems of heterogeneity and dynamic adaptability. On the other hand, middleware solutions, like CORBA and Java/Jini, solve part of the heterogeneity problem by permitting seamless communication among different platforms. But, they do not address dynamic resource management and adaptability for applications requiring high-performance distributed computing. This paper presents 2K, an integrated operating system architecture that addresses the problems of resource management in heterogeneous networks, dynamic adaptability and configuration of component-based distributed applications.

Computer users are increasingly multi-device equipped and no longer sedentary. It is desirable that the execution environment in any of these devices be customized to the user preferences and to the device characteristics. This paper describes a framework for managing execution environments in 2K, an adaptable, distributed, network-centric, user- and application-oriented operating system aimed at accommodating change. A 2K environment is a container of components, devices and configuration parameters and provides an execution context for the user within the 2K distributed system. A user has a distributed execution environment that consists of several subenvironments running on different platforms or temporarily suspended to be resumed later. The management of the execution environments is designed to provide a user-centric view of the system; it facilitates user mobility, by liberating users from the restriction of being explicitly attached to specific platforms, and by seamlessly recruiting resources where they are available.

We present a new protocol, called the Delay /Re-Read Protocol, for controlling concurrent access to a database. The protocol uses a combination of preventive and corrective measures for maintaining consistency. On recognizing that a transaction has read inconsistent data, the Protocol applies a corrective measure which requires the transaction to re-read some data. Alternatively, on recognizing that a transaction is about to write data which will result in inconsistency, the Protocol applies a preventive measure which delays the Write. A Read request is always granted without delay. The Protocol is deadlock-free, requires no backup data, and supports a greater degree of concurrency than Two Phase Locking. A transaction is never aborted or delayed indefinitely by the Protocol.

A direct, one-step transformation is presented for transforming an arbitrary LR ( k ) context-free grammar, G , to an LR (1) grammar, G ′, which completely covers G . Under additional hypotheses, G ′ may be made LR (0).

A method is presented for directly transforming an arbitrary LR( k ) grammar to an equivalent LR(1) grammar. It is further shown that the method transforms an arbitrary prefix-free LR( k ) grammar to an equivalent LR(0) grammar. It is argued that the method is efficient and offers some advantages over traditional “look-ahead” parsing methods. Finally, it is demonstrated that the method can be used to transform an LR(1) grammar to an equivalent SLR(1) grammar, which in turn can be easily transformed to an equivalent (1, 1) bounded right-context grammar.