this paper we discuss four major problems we have observed in our developing and deploying wide-area distributed object applications and middleware. First, most programs are developed ignoring the variable wide area conditions. Second, when application programmers do try to handle these conditions, they have great difficulty because these harsh conditions are different from thost of the local objects they are used to dealing with. Third, IDL hides information about the tradeoffs any implementation of an object must make. Fourth, there is presently no way to systematically reuse current technology components which deal with these conditions, so code sharing becomes impractical. In this paper we also describe our architecture, Quality of Service for CORBA Objects (QuO), which we have developed to overcome these limitations and integrate their solution by providing QoS abstractions to CORBA objects. First, it makes these conditions first class entities and integrates knowledge of them over time, space, and source. Second, it reduces their variance by masking. Third, it exposes key design decisions of an object's implementation and how it will be used. Fourth, it supports reuse of various architectural components and automatically generates others.

Implementing new operating systems is tedious, costly, and often impractical except for large projects. The Flux OSKit addresses this problem in a novel way by providing clean, well-documented OS components designed to be reused in a wide variety of other environments, rather than defining a new OS structure. The OSKit uses unconventional techniques to maximize its usefulness, such as intentionally exposing implementation details and platform-specific facilities. Further, the OSKit demonstrates a technique that allows unmodified code from existing mature operating systems to be incorporated quickly and updated regularly, by wrapping it with a small amount of carefully designed “glue” code to isolate its dependencies and export well-defined interfaces. The OSKit uses this technique to incorporate over 230,000 lines of stable code including device drivers, file systems, and network protocols. Our experience demonstrates that this approach to component software structure and reuse has a surprisingly large impact in the OS implementation domain. Four real-world examples show how the OSKit is catalyzing research and development in operating systems and programming languages. 1

Over the past ten years, the use of sociological methods and sociological reasoning have become more prominent in the analysis and design of interactive systems. For a variety of reasons, one form of sociological enquiry, ethnomethodology, has become something of a favoured approach. Our goal in this paper is to investigate the consequences of approaching system design from the ethnomethodological perspective. In particular, we are concerned with how ethnomethodology can take a foundational place in the very notion of system design, rather than simply being employed as a resource in aspects of the process such as requirements elicitation and specification. We begin by outlining the basic elements of ethnomethodology, and discussing the place that it has come to occupy in CSCW and, increasingly, in HCI. We discuss current approaches to the use of ethnomethodology in systems design, and point to the contrast between the use of ethnomethodology for critique and for design. Currently, und...

This paper presents dynamic feedback, a technique that enables computations to adapt dynamically to different execution environments. A compiler that uses dynamic feedback produces several different versions of the same source code; each version uses a different optimization policy. The generated code alternately performs sampling phases and production phases. Each sampling phase measures the overhead of each version in the current environment. Each production phase uses the version with the least overhead in the previous sampling phase. The computation periodically resamples to adjust dynamically to changes in the environment.

We argue that the software user, the developer, the designer and indeed the application logic itself all possess invaluable intelligence to gear how software should adapt itself to changing requirements and changing context. We present Chisel, an open framework for dynamic adaptation of services using reflection in a policy-driven, context-aware manner. The system is based on decomposing the particular aspects of a service object that do not provide its core functionality into multiple possible behaviours. As the execution environment, user context and application context change, the service object will be adapted to use different behaviours, driven by a human-readable declarative adaptation policy script. To demonstrate this framework we will provide a dynamically adaptive middleware for mobile computing. The framework will allow users and applications to make mobile-aware dynamic changes to the behaviour of various services of the middleware, and allow the addition of new unanticipated behaviours at run-time, without changing or stopping the middleware or an application that may be using it. This is achieved by implementing the behaviours as metatypes in Iguana/J, which supports non-invasive dynamic associations of metatypes to service objects without any requirement to interrupt, change or access the object’s source code.

CSCW toolkits are designed to ease development of CSCW applications. They provide common, reusable components for cooperative system design, allowing application programmers to concentrate on the details of their particular applications. The underlying assumption is that toolkit components can be designed and implemented independently of the details of particular applications. However, there is good evidence to suggest that this is not true. This paper presents a new technique which allows programmers to express application requirements, so that toolkit structures can be adapted to different circumstances. Prospero is a toolkit which uses this technique to meet different application needs flexibly.

Specialization has been recognized as a powerful technique for optimizing operating systems. However, specialization has not been broadly applied beyond the research community because current techniques, based on manual specialization, are time-consuming and error-prone. The goal of the work described in this paper is to help operating system tuners perform specialization more easily. We have built a specialization toolkit that assists the major tasks of specializing operating systems. We demonstrate the effectiveness of the toolkit by applying it to three diverse operating system components. We show that using tools to assist specialization enables significant performance optimizations without errorprone manual modifications. Our experience with the toolkit suggests new ways of designing systems that combine high performance and clean structure. 1

Two limitations of the current implementations of adaptive QoS behaviors are complexity associated with inserting them into common application contexts and lack of reusability across applications. What is needed is a way of bundling all the specification for systemic behavior into one place, and making it feasible to insert the collection of related QoS management artifacts into applications as a single, reusable behavior. As a means of addressing these issues, we have developed a new abstraction intended specifically to bundle together the lower level abstractions, specifications and implementations associated with providing adaptive QoS behaviors in a manner which is both easier to package and makes the behavior bundle reusable in a variety of applications and styles of use. In this paper we introduce the concept of “qoskets ” as reusable systemic behaviors, lay out elements of our design for qoskets within the QuO framework, and use a case study example to highlight the issues of using qoskets in practice. 1. Introduction and

We describe an abstract architecture of adaptive applications, and indicate where we believe crucial design decisions must be made. We illustrate the use of the abstract model in the design of an image proxy, and show where studies are required in determining the appropriate design points. In particular, even though adaptation to resource constraints is generally considered a systems problem, the adaptation is visible to the user in changes in utility, and so the user must be involved in designing the application. Finally, we discuss the politics that creep in when designers change the semantics of applications. 1 Introduction In an age of cheap mobile compute devices, we would like an ubiquitous computing environment [20] in which applications can follow us around as we move from computing interface to interface, and from device to device. However, because of the well-known constraints of battery power, display capabilities and network characteristics for mobile computing, the resour...

The Quality Objects (Quo) middleware is a set of ex-tensions to standard distributed object computing mid-dleware that is used to control and adapt quality of serv-ice in a number of distributed application environments, from wide-area to embedded distributed applications. This paper compares and contrasts the characteristics of key use cases and the variations in Quo implementations that have emerged to support them. We present these variations in the context of several actual applications being developed using the QUO middleware. 1.