On the desktop, users are accustomed to having visible handles to objects that they can organize, share, and manipulate. Web applications today feature many loosely defined classes of such objects, like flight itineraries, products for sale, people, recipes, and restaurants, but there are no interoperable handles for these high-level semantic objects. On the web, users need visible handles that can represent an evolving set of semantically rich objects. Such handles would enable a simple, direct, and consistent interface for data representation and transfer. This thesis proposes Clui, a platform for exploring a new data type, called a Webit, that provides uniform handles to objects. Users drag and drop Webits between sites to transfer data, auto-fill search forms, map associated locations, or share Webits with others. While Clui offers a developer API to add Webit support to web sites, Clui plugins allow users to use Webits immediately. Plugins create Webits by extracting semantic data from existing web pages, and they augment sites with drag and drop targets that accept and interpret Webits, all without requiring the cooperation of site developers. Contributions of this thesis include design principles, derived from experimentation, that guide the functionality and behavior of handles for web objects; a system design that provides an adoption path for such handles; and a scalable approach for realizing handles that enforce access controls. To evaluate the usability of Webits, we conducted two in-laboratory studies and collected qualitative observations and feedback. The results suggest that the system is usable and effective in improving user efficiency. While using the system, participants expressed enthusiasm and delight, and believed that Webits would be useful for their daily web activities. (Copies available exclusively from MIT Libraries, libraries.mit.edu/docs - docs@mit.edu)

We propose an execution model for web apps that eschews the current need for static partitioning of web apps into client-side JavaScript and server-side "data center" code, but rather enables dynamic partitioning by allowing the client and server to share code and migrate computation between each other. Our model abstracts and represents shared code and data as a graph of fixed-sized chunks; our runtime then manages and migrates the graph rather than managing the code and its dependencies directly. We demonstrate our model through PhotoBoss, a suite of web apps for editing high-resolution photos.

Cloud systems differ fundamentally in how they offer and charge for resources. While some systems provide a generic programming abstraction at coarse granularity, e.g., a virtual machine rented by the hour, others offer specialized abstractions with fine-grained accounting on a per-request basis. In this paper, we explore Tasklets, an abstraction for instances of short-duration, generic computations that migrate from a host requiring computation to hosts that are willing to provide computation. Tasklets enable fine-grained accounting of resource usage, enabling us to build infrastructure that supports trading computing resources according to various economic models. This computation model is especially attractive in settings where mobile devices can utilize resources in the cloud to mitigate local resource constraints.

On the desktop, users are accustomed to having visible handles to objects that they want to organize, share, or manipulate. Web applications today feature many classes of such objects, like flight itineraries, products for sale, people, recipes, and businesses, but there are no interoperable handles for high-level semantic objects that users can grab. This paper proposes Clui, a platform for exploring a new data type, called a Webit, that provides uniform handles to rich objects. Clui uses plugins to 1) create Webits on existing pages by extracting semantic data from those pages, and 2) augmenting existing sites with drag and drop targets that accept and interpret Webits. Users drag and drop Webits between sites to transfer data, auto-fill search forms, map associated locations, or share Webits with others. Clui enables experimentation with handles to semantic objects and the standards that underlie them.

Modern computing substrates like cloud computing clusters, massively multi-core processors, and general-purpose GPUs offer a wealth of computing power with the caveat that programmers must carefully structure their programs to fit within various hardware and communication limits in order to get high performance. Unfortunately, modern abstractions expressly hide machine structure from the program and program structure from the machine, hindering automatic optimization. We introduce an alternative computing abstraction--a linked graph of finite-sized memory chunks--that explicitly exposes the size and structure of programs to the operating system. The chunk graph enables the operating system to use size and structure to optimize how programs are mapped onto complex machine structure.

Even as users rely more on the web for their computing needs, they continue to depend on a desktop-like area for quick access to in-use resources. The traditional desktop is file-centric and prone to clutter, making it suboptimal for use in a web-dominated world. This paper introduces Cloudtop, a browser plugin that offers a lightweight workplace for temporary items, optimized around the idea that its contents originate from and will ultimately return to the web. Cloudtop improves upon the desktop by 1) implementing a simple, time-based notebook metaphor for managing clutter, 2) capturing and bundling extensible metadata for web resources, and 3) providing a platform for greater interface uniformity across sites.

Even as users rely more on the web for their computing needs, they continue to depend on a desktop-like area for quick access to in-use resources. The traditional desktop is file-centric and prone to clutter, making it suboptimal for use in a web-dominated world. This paper introduces Cloudtop, a browser plugin that offers a lightweight workplace for temporary items, optimized around the idea that its contents originate from and will ultimately return to the web. Cloudtop improves upon the desktop by 1) implementing a simple, time-based notebook metaphor for managing clutter, 2) capturing and bundling extensible metadata for web resources, and 3) providing a platform for greater interface uniformity across sites.

We present ChunkStream, a system for efficient streaming and interactive editing of online video. Rather than using a specialized protocol and stream format, ChunkStream makes use of a generic mechanism employing chunks. Chunks are fixed-size arrays that contain a mixture of scalar data and references to other chunks. Chunks allow programmers to expose large, but fine-grained, data structures over the network. ChunkStream represents video clips using simple data types like linked lists and search trees, allowing a client to retrieve and work with only the portions of the clips that it needs. ChunkStream supports resource-adaptive playback and ''live'' streaming of real-time video as well as fast, frame-accurate seeking; bandwidth-efficient high-speed playback; and compilation of editing decisions from a set of clips. Benchmarks indicate that ChunkStream uses less bandwidth than HTTP Live Streaming while providing better support for editing primitives.

The current desktop metaphor is unsuitable for the coming age of cloud-based applications. The desktop was developed in an era that was focused on local resources, and consequently its gestures, semantics, and security model reflect heavy reliance on hierarchy and physical locations. This paper proposes a new user interface model that accounts for cloud applications, incorporating representations of people and new gestures for sharing and access, while minimizing the prominence of location. The model's key feature is a lightweight mechanism to group objects for resource organization, sharing, and access control, towards the goal of providing simple semantics for a wide range of tasks, while also achieving security through greater usability.

Debugging pervasive applications is difficult due to their distributed, asynchronous, and dynamic nature. To help ease the debugging process, we propose PerViz, a developer-targeted tool that enhances system visibility through real-time visualizations of system state, semi-automates application restarts and positioning, and enables both real-time and asynchronous collaboration in debugging between developers. Developers interact with PerViz through a web browser, which provides a convenient, centralized location to study and filter aggregated application debugging logs and state. In our experience with using PerViz, we have found its log aggregation and real-time visualizations to be key facilitators for effective debugging.

We present ChunkStream, a system for efficient streaming and interactive editing of online video. Rather than using a specialized protocol and stream format, ChunkStream makes use of a generic mechanism employing chunks. Chunks are fixed-size arrays that contain a mixture of scalar data and references to other chunks. Chunks allow programmers to expose large, but fine-grained, data structures over the network. ChunkStream represents video clips using simple data types like linked lists and search trees, allowing a client to retrieve and work with only the portions of the clips that it needs. ChunkStream supports resource-adaptive playback and "live" streaming of real-time video as well as fast, frame-accurate seeking; bandwidth-efficient high-speed playback; and compilation of editing decisions from a set of clips. Benchmarks indicate that ChunkStream uses less bandwidth than HTTP Live Streaming while providing better support for editing primitives.

We present a middleware platform for assembling pervasive applications that demand fault-tolerance and adaptivity in distributed, dynamic environments.Unlike typical adaptive middleware approaches, in which sophisticated component model semantics are embedded into an existing, underlying platform (e.g., CORBA, COM, EJB), we propose a platform that imposes minimal constraints for greater flexibility.Such a tradeoff is advantageous when the platform is targeted by automatic code generators that inherently enforce correctness by construction.Applications are written as simple, single-threaded programs that assemble and monitor a set of distributed components.The approach decomposes applications into two distinct layers: (1) a distributed network of interconnected modules performing computations, and (2) constructor logic that assembles that network via a simple block-diagram construction API.The constructor logic subsequently monitors the configured system via a stream of high-level events, such as notifications of resource availability or failures, and consequently provides a convenient, centralized location for reconfiguration and debugging.The component network is optimized for performance, while the construction API is optimized for ease of assembly.

We describe an approach to automate certain high-level implementation decisions in a pervasive application, allowing them to be postponed until runtime. Our system enables a model in which an application programmer can specify the behavior of an adaptive application as a set of open-ended decision points. We formalize decision points as Goals, each of which may be satisfied by a set of scripts called Techniques. The set of Techniques vying to satisfy any Goal is additive and may be extended at runtime without needing to modify or remove any existing Techniques. Our system provides a framework in which Techniques may compete and interoperate at runtime in order to maintain an adaptive application. Technique development may be distributed and incremental, providing a path for the decentralized evolution of applications. Benchmarks show that our system imposes reasonable overhead during application startup and adaptation.

The rapid increase in the number and variety of consumer-level electronic devices without the corresponding development of device management technology has lead to a configuration nightmare. We propose to use goal-oriented programming over a substrate of network-portable objects to help reduce the amount of configuration users must do in order to have their applications use their devices efficiently. We detail an architecture and describe a prototype system using existing pervasive computing technology that plays music on the most appropriate devices without requiring user interaction and configuration

The adaptivity demands of ubiquitous computing motivate applications structured around implementation choices that are (a) made at runtime, reflecting available resources; (b) reevaluated and potentially changed during application operation, accommodating failures and resource discovery; and (c) locally extensible beyond choices anticipated (and fixed) by central application code. To this end, we explore a new organization for adaptive applications involving the formalization of Goals as representations of abstract services and a universe of Techniques which compete to provide them. In our model the selection of Techniques to satisfy each Goal is performed by an application-generic runtime process which continues so long as the Goal remains active, allowing applications to adapt to runtime changes in available resources. The set of available Techniques is potentially open, distributed, and incrementally extensible, providing paths for the decentralized evolution of applications.

Robust pervasive computing applications today span heterogeneous systems and often need to be dynamic and adaptive. However, traditional, asynchronous distributed systems are generally too complex and require developers to be deeply aware of the intricacies of the underlying system and platform. Furthermore, building adaptive applications also proves difficult because traditional systems tend to impose a static API between distributed components. The interfaces are determined at compile-time and provide no mechanism for changing the relationships between components during runtime, such as to adapt to hardware upgrade or failure.

Contemporary pervasive computing environments demand mechanism for coherently addressing high-level user needs despite changing availability of resources. We propose the formalization of goals as the semantic basis for this mechanism, and sketch a system architecture that separates policy-rich goals-level planning code from a policy-neutral component assembly model.