Today, application development for wireless sensor networks (WSN) depends mainly on event-based programming models, making it difficult for programmers to write and maintain WSN applications. Further, the lossy wireless communication channel between nodes within these networks create the need for protocols that take advantage of asynchronous message passing. To address these issues, we present an analysis of communication patterns within the WSN domain and introduce spatially and temporally aware RPC extensions that exploit these patterns. This model, which we refer to as remote service method invocation (RSMI), provides Anycast-RPC and oneway-RPC.

Embedded application developers create applications for a wide range of devices with different resource constraints. Developers want to maximize the use of the limited resources available on the device while still not exceeding the capabilities of the device. To do this, the developer must be able to scale his software for different platforms. In this paper, we present a software engineering methodology that automatically scales software to different platforms. We intend to have the application developer write high level functional specifications of his software and have tools that automatically scale the underlying runtime. These tools will use the functional and non-functional constraints of both the hardware and client application to produce an appropriate runtime. Our initial results show that the proposed approach can scale operating systems and virtual machines that satisfy the constraints of varying hardware/application combinations.

Virtual machines (VM) are promising as system software in sensor networks. A major impediment to their widespread acceptance is their performance over- head. Compiling VM bytecode to native code addresses this, but increases footprint and code distribution costs. Thus, there is an important tradeoff between cost of computing and cost of communication due to code distri- bution. In this paper, we describe a remote Just-In-Time (JIT) compilation service that is effective in combining interpretation with native execution to arrive at an efficient hybrid execution configuration. The principles apply to any middleware used to develop applications in sensor networks.

Sensor networks are being deployed at massive scales, containing a range of platforms. Programming paradigms for sensor networks should meet the attendant challenges of scale and heterogeneity. Researchers have considered virtual machines as a means to address these challenges. However, in order to satisfy the resource limitations of sensor nodes, they export only a minimal set of services to the application programmer. This makes applications of even moderate complexity difficult to implement. We present VMSTAR --- a framework for building resource-efficient virtual machines that scale and export comprehensive service suites on a per-application basis. We advocate the use of fine-grained software synthesis to build resource-efficient system software, and facilitate both application changes and system software upgrades at runtime through an efficient incremental update scheme. We have used our framework to build virtual machines on the Mica platform and describe how virtual machines are effective in meeting the difficult demands of heterogeneity and reprogrammability.

The progress of mobile device technology unfolds a new spectrum of applications that challenges conventional infrastructure models. Most of these devices are perceived by their users as "appliances" rather than computers and accordingly the application management should be done transparently by the underlying system unlike classic applications managed explicitly by the user. Memory management on such devices should consider new types of mobile applications involving code mobility such as mobile agents, active networks and context aware applications. This paper describes a new code management technique, called "code collection " and proposes a specific code collection algorithm, the Adaptive Code Collection Algorithm (ACCAL). Code collection is a mechanism for transparently loading and discarding application components on mobile devices at runtime that is designed to permit very low memory usage and at the same time good performance by focusing memory usage on the hotspots of the application. To achieve these goals, ACCAL uses properties specific to executable code and enhances conventional data management methods such as garbage collection and caching. The results show that fine-grained code collection allows large applications to execute by using significantly less memory while inducing small execution time overhead.

Dynamic evolution allows designers to move logic from interpreted data structures into directly executed code. This provides the efficiency of code-driven security enforcement without sacrificing flexibility. The Evolvable Systems Project (ESP) at University of California, is developing techniques for safely and securely evolve distributed Java applications at runtime. We briefly describe the design and implementation of a type-safe model for dynamically modifying Java programs on a single host. We then describe how this model can be applied for building an adaptive security infrastructure. An extension of the single host model to a distributed environment is considered. Finally, we conclude with a brief outline of the project and the future work.

Writing distributed programs is difficult. To ease this task, we introduce a new programming abstraction which we call a mobility attribute. Mobility attributes provide a syntax that describes the mobility semantics of program components. Programmers attach mobility attributes to program components to dynamically control the placement of these components within the network. Mobility attributes intercept component invocations and decide whether and where to move a component before the component executes. This allows the programmer to improve her program's runtime efficiency by colocating components and resources. We present MAGE, an object oriented distributed system, that supports mobility attributes and illustrates their utility.

A packet scheduling scheme is an important component of a network node. The choice of a scheme dictates the allocation of network resources among contending flows of the network. In this paper we study packet scheduling in the context of active networks. In an active network, intermediate nodes, called active nodes, can perform customized computations on every packet. Programmability in active networks is achieved by having active packets carry either programs or references to programs that are injected into the active nodes offline. As each packet arrives at an active node, the node executes the program associated with the packet and then routes the packet to the next node. Traditionally, packet scheduling schemes are used to allocate a single resource fairly. This cannot be directly applied to active nodes because active nodes contain multiple resources, such as CPU and bandwidth. Moreover, these resources are inter-dependent. Hence, allocating one resource fairly does not entail allocating the other resources fairly. We describe a simple packet scheduling algorithm to allocate multiple resources fairly in an active node. Using simulations, we show that the algorithm effectively allocates both CPU and bandwidth resources fairly among the contending flows.

There is considerable interest in programs that can migrate from one host to another and execute. Mobile programs are appealing because they support efficient utilization of network resources and extensibility of information servers. However, since they cross administrative domains, they have the ability to access and possibly misuse a host's protected resources. In this paper, we present a novel approach for controlling and protecting a site's resources. In this approach, a site uses a declarative policy language to specify a set of constraints on accesses to resources. A set of code transformation tools enforces these constraints on mobile programs by integrating the access constraint checking code directly into the mobile program and resource definitions. Using this approach, a site does not need to explicitly include calls to reference monitors in order to protect resources. The performance analysis show that the approach performs better than reference monitor-based approaches in many cases. Copyright © 2000 John Wiley & Sons, Ltd.

Most implementationsof HTTP servers do not distinguish among requests to differeut pages.This has the implicatiou that requests for popular pages have the tendency to overwhelm the requests for other pages.In addition, HTTP servers do not allow a site to specify policies for server resource allocation.This paper presents a notion of wality of service that enables a site to customize how an HTTP server should respond to external requests by setting priorities among page requests and allocating server resources.It also describes a design and an implementation of a distributed HTTP server, QoS Web Server, that enforces the quality of service constraints.The performance aualysis of the prototype server indicates that the server provides the desired quality of service with minimal overhead.