John J. Barton

People, places, things: Web presence for the real world

The convergence of Web technology, wireless networks, and portable client devices provides new design opportunities for computer/communications systems. In the HP Labs “Cooltown” project we have been exploring these opportunities through an infrastructure to support “web presence” for people, places and things. We put web servers into things like printers and put information into web servers about things like artwork; we group physically related things into places embodied in web servers. Using URLs for addressing, physical URL beaconing and sensing of URLs for discovery, and localized web servers for directories, we can create a location-aware but ubiquitous system to support nomadic users. On top of this infrastructure we can leverage Internet connectivity to support communications services. Web presence bridges the World Wide Web and the physical world we inhabit, providing a model for supporting nomadic users without a central control point.

The Jalapeño virtual machine

Jalapeno is a virtual machine for JavaTM servers written in the Java language. To be able to address the requirements of servers (performance and scalability in particular), Jalapeno was designed from scratch to be as self-sufficient as possible. Jalapenos unique object model and memory layout allows a hardware null-pointer check as well as fast access to array elements, fields, and methods. Run-time services conventionally provided in native code are implemented primarily in Java. Java threads are multiplexed by virtual processors (implemented as operating system threads). A family of concurrent object allocators and parallel type-accurate garbage collectors is supported. Jalapenos interoperable compilers enable quasi-preemptive thread switching and precise location of object references. Jalapenos dynamic optimizing compiler is designed to obtain high quality code for methods that are observed to be frequently executed or computationally intensive.

Implementing jalapeño in Java

Jalapeño is a virtual machine for Java#8482; servers written in Java.nA 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ño reduces the boundary-crossing overhead and opens up more opportunities for optimization.nTo get Jalapeño started, a boot image of a working Jalapeño 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ños object format.nA special MAGIC class allows unsafe casts and direct access to the hardware. Methods of this class are recognized by Jalapeños three compilers, which ignore their bytecodes and emit special-purpose machine code. User code will not be allowed to call MAGIC methods so Javas integrity is preserved.nA small non-Java program is used to start up a boot image and as an interface to the operating system.nJavas programming features — object orientation, type safety, automatic memory management — greatly facilitated development of Jalapeño. However, we also discovered some of the languages limitations.

A Web-based nomadic computing system

Abstract CoolTown offers a Web model for supporting nomadic users, based on the convergence of Web technology, wireless networks and portable devices. This paper describes how CoolTown ties Web resources to physical objects and places, and how users interact with resources using the information appliances they carry, from laptops to smart watches. Enabling the automatic discovery of URLs from our physical surroundings, and using localized Web servers for directories, we create location-aware but ubiquitous systems. On top of this infrastructure we leverage device connectivity to support communication services.

Making computers disappear: appliance data services

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.nThe 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.

Sensor-enhanced mobile web clients: an XForms approach

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.

Running the Web backwards: appliance data services

Abstract `Appliance digital devices such as handheld cameras, scanners, and microphones generate data that people want to put on Web pages. Unfortunately, numerous complex steps are required. Contrast this with Web output: handheld Web browsers enjoy increasing infrastructural support such as user-transparent transformation proxies, allowing unmodified Web pages to be conveniently viewed on devices not originally designed for the task. We hypothesize that the utility of input appliances will be greatly increased if they too were `infrastructure enabled. Appliance Data Services attempts to systematically describe the task domain of providing seamless and graceful interoperability between input appliances and the Web. We offer an application architecture and a validating prototype that we hope will `open up the playing field and motivate further work. Our initial efforts have identified two main design challenges: dealing with device heterogeneity, and providing a `no-futz out-of-the-box user experience for novices without sacrificing expressive power for advanced users. We address heterogeneity by isolating device and protocol heterogeneity considerations into a single extensible architectural component, allowing most of the application logic to deal exclusively with Web-friendly protocols and formats. We address the user interface issue in two ways: first, by specifying how to tag input with commands that specify how data are to be manipulated once injected into the infrastructure; second, by describing a late-binding mechanism for these command-tags, which allows `natural extensions of the devices UI for application selection and minimizes the amount of configuration required before end-users benefit from Appliance Data Services. Finally, we describe how to leverage existing services in the infrastructure; our prototype is based on HTTP and Java but our architecture could also leverage services connected via Jini or CORBA. We also describe an implemented prototype of parts of the architecture and a specific application.

Physical registration: configuring electronic directories using handheld devices

An important problem in pervasive computing is how to create and maintain manageable collections of pervasive resources appropriate for disparate and typically nomadic users. This article describes physical registration, a new, human-centric mechanism for constructing collections of resources in the form of electronic directories. Users identify physical objects using sensor-equipped wirelessly networked handheld devices to build directories of virtual entities associated with those objects. The entities can be Web resources accessible over a network, like printers, projectors, picture frames, or storage devices. They can also be Web resources correlated with objects like books or telephones that are not themselves accessible over a network. This article describes and motivates the method, then compares two implementations we have constructed.

Towards a real-world wide web

As computer hardware shrinks and lightens and as communications becomes cheaper and more widely available, we have new opportunities for software systems to support nomadic users of ubiquitous or pervasive computing services [16, 24]. We are interested in systems that support interaction with the physical world wherever users happen to be. More and more things in the physical world, such as our cars and domestic appliances, are becoming smart. Users need a convenient framework in which they can benefit from the smart artifacts around them. Users can also benefit from services built for non-electronic entities that they encounter in their everyday lives, such as goods on the shelves of stores, paintings in galleries and items in the office. We think the physical world and the virtual world would both be richer if they were more closely linked.The approaching pervasiveness of web technology, new kinds of wireless networks, and cheaper portable devices provide an opportunity to construct a virtual bridge between mobile users and physical entities. At HP Labs we have been exploring this opportunity through an infrastructure to support web presence for people, places and things [14], and the CoolTown demonstrator applications that run on top of the infrastructure [4].In this paper we discuss how we provide mobile people and devices with web-based services for things --- the physical entities --- in their environment. Things become web-present by embedding web servers in them or by hosting their web-presence within a web server. To enable services for web things we need a system that connects things and services. We will outline a system that leverages the power of the Web as a basis for nomadic computing, then highlight one important subsystem that uses DNS technology to name web things in a scalable and context dependent fashion.Section 2 describes our use of the Web as just enough middleware for nomadic computing, and describes web presence. Section 3 describes how we tackle the naming issues that arise in providing web presence for the things that mobile users encounter. Section 4 relates our work to that of others and concludes the paper.

Introduction to the special feature on Middleware for Mobile and Pervasive Computing

This special feature presents a collection of papers that discuss the main research topics that were presented at the Workshop on Middleware for Mobile Computing held on November 16, 2001, in conjunction with Middleware 2001, the IEEE/ACM International Conference on Distributed Systems Platforms in Heidelberg, Germany. Mobile and pervasive computing is an emerging phenomenon that promises to radically advance the benefits of computing in people’s everyday lives. Mark Weiser’s widely quoted 1991 paper envisions a world in which invisible interconnected computers enable people to perform their tasks and interact with other people more effectively. Such hardware and software will be embedded in the users’ physical environment and integrate seamlessly with their everyday tasks. Although significant work has been performed on each aspect of this vision, it is still far from being attained [1]. The focus of the workshop, and this feature, is on the software infrastructure that underlies mobile and pervasive computing applications. More specifically, we focus on the set of software components and services above the operating system, which is broadly referred to as middleware. The goal of the workshop was to identify the requirements on mobile and pervasive middleware and to present ongoing work that is developing and evaluating the platforms and services that make up such middleware. The first part of this feature contains four papers that describe key aspects of mobile and pervasive middleware in some detail.