As developers debug, they often have to seek the origins of wrong values they see in their debugger. This search must be performed backwards in time since the code causing the wrong value is executed before the wrong value appears. Therefore, locating the origin of wrong values with breakpoint- or log- based debuggers demands persistence and significant experience.

Breakpoints are perhaps the quintessential feature of a de-bugger: they allow a developer to stop time and study the program state. Breakpoints are typically specified by selecting a line of source code. For large, complex, web pages with multiple developers, the relevant source line for a given user interface problem may not be known to the developer. In this paper we describe the implementation of breakpoints in dynamically created source, and on error messages, network events, DOMmutation, DOMobject property changes, and CSS style rule updates. Adding these domain-specific breakpoints to a general-purpose debugger for Javascript allows the developer to initiate the debugging process via Web page abstractions rather than lower level source code views. The breakpoints are implemented in the open source Fire-bug project, version 1.5, for the Firefox Web browser.

Opportunistic augmentation denotes connecting a personal mobile device to another device to gain a transient advantage for the user. For example, a mobile phone user might borrow a large display and keyboard from a desktop personal computer. This uniquely ubiquitous computing activity requires effective device and service discovery as well as appropriate media usable across two or more devices. In this paper we show how session initiation protocol (SIP), the call signaling protocol for voice over IP, effectively separates discovery from media-rendering selection in opportunistic augmentation. This separation improves system flexibility while allowing users or system administrators to choose the most appropriate discovery technologies for the environment. We also describe two phone-centric discovery mechanisms and demonstrate the practicality of the system by implementation and use in a test environment.

This paper describes methods for service selection and service access for mobile, sensor-enhanced web clients such as wireless cameras or wireless PDAs with sensor devices attached. The clients announce their data-creating capabilities in "Produce" headers sent to servers; servers respond with forms that match these capabilities. Clients fill in these forms with sensor data as well as text or file data. The resultant system enables clients to access dynamically discovered services spontaneously, as their users engage in everyday nomadic activities.

Digital appliances designed to simplify everyday tasks are readily available to end consumers. For example, mobile users can retrieve Web content using handheld devices since content retrieval is well-supported by infrastructure services such as transformational proxies. However, the same type of support is lacking for input-centric devices, those that create content and allow users to share content. This lack of infrastructural support makes input-centric devices hard to use and less useful.The Appliance Data Services project seeks to explore a vision of an appliance computing world where users move data seamlessly among various devices. Based on this vision, we formulate three principles that guide the design of an architecture that helps realize this vision: bring devices to the forefront, minimize the number of device features, and place functionality in the network infrastructure. We evaluate our implementation of the ADS architecture based on these principles, and build applications using the ADS framework to evaluate the ease with which appliance computing applications can be built using the framework. We find that it is relatively simple to build and extend applications on ADS that make using digital devices easier, which results in the devices themselves becoming more useful.

Jalape~no is a virtual machine for Java TM servers written in Java. A running Java program involves four layers of functionality: the user code, the virtual-machine, the operating system, and the hardware. By drawing the Java / non-Java boundary below the virtual machine rather than above it, Jalape~no reduces the boundary-crossing overhead and opens up more opportunities for optimization. To get Jalape~no started, a boot image of a working Jalape ~no virtual machine is concocted and written to a file. Later, this file can be loaded into memory and executed. Because the boot image consists entirely of Java objects, it can be concocted by a Java program that runs in any JVM. This program uses reflection to convert the boot image into Jalape~no's object format. A special Magic class allows unsafe casts and direct access to the hardware. Methods of this class are recognized by Jalape~no's three compilers, which ignore their bytecodes and emit special-purpose machine code. User code w...