User-interruption in human-computer interaction (HCI) is an increasingly important problem. Many of the useful advances in intelligent and multitasking computer systems have the significant side effect of greatly increasing user-interruption. This previously innocuous HCI problem has become critical to the successful function of many kinds of modern computer systems. Unfortunately, no HCI design guidelines exist for solving this problem. In fact, theoretical tools do not yet exist for investigating the HCI problem of user-interruption in a comprehensive and generalizable way. This report asserts that a single unifying definition of user-interruption and the accompanying practical taxonomy would be useful theoretical tools for driving effective investigation of this crucial HCI problem. These theoretical tools are constructed here. A comprehensive analysis is conducted through the existing literature. Theoretical constructs from several relevant but diverse fields are identified and discussed. A unifying definition of user-interruption is synthesized. This new definition is supported with an array of postulates, assertions, and a taxonomy of human interruption to facilitate its practical application.

Abstract-- Reuse of large-grain software components offers the potential for significant savings in application development cost and time. Successful component reuse and substitutability depends both on qualities of the components reused as well as the software context in which the reuse is attempted. Disciplined approaches to the structure and design of software applications offers the potential of providing a hospitable setting for such reuse. We present the results of a series of exercises designed to determine how well “offthe-shelf” components could be reused in applications designed in accordance with the C2 software architectural style. The exercises involved the reuse of two user-interface constraint solvers, two graphics toolkits, a World Wide Web browser, and a persistent object manager. A subset of these components was used to construct numerous variations of a single application (thus an application family). The exercises also included construction of a simple development environment for locating and downloading a component off the Web and incorporating it into an application. The paper summarizes the style rules that facilitate reuse and presents the results from the exercises. The exercises were successful in a variety of dimensions; one conclusion is that the C2 style offers significant reuse potential to application developers. At the same time, wider trials and additional tool support are needed. 1 Index Terms-- software reuse, architectural styles, messagebased architectures, component-based development, graphical user interfaces (GUI). I.

Reuse of large-grain software components offers the potential for significant savings in application development cost and time. Successful reuse of components and component substitutability depends both on qualities of the components reused as well as the software context in which the reuse is attempted. Disciplined approaches to the structure and design of software applications offers the potential of providing a hospitable setting for such reuse. We present the results of a series of exercises designed to determine how well "off-the-shelf" constraint solvers could be reused in applications designed in accordance with the C2 software architectural style. The exercises involved the reuse of SkyBlue and Amulet's one-way formula constraint solver. We constructed numerous variations of a single application (thus an application family). The paper summarizes the style and presents the results from the exercises. The exercises were

Ideally, a software project commences with requirements gathering and specification, reaches its major milestone with system implementation and delivery, and then continues, possibly indefinitely, into an operation and maintenance phase. The software system’s architecture is in many ways the linchpin of this process: it is supposed to be an effective reification of the system’s technical requirements and to be faithfully reflected in the system’s implementation. Furthermore, the architecture is meant to guide system evolution, while also being updated in the process. However, in reality developers frequently deviate from the architecture, causing architectural erosion, a phenomenon in which the initial, “as documented ” architecture of an application is (arbitrarily) modified to the point where its key properties no longer hold. Architectural recovery is a process frequently used to cope with architectural erosion whereby the current, “as implemented ” architecture of a software system is extracted from the system’s implementation. In this paper we propose a light-weight approach to architectural recovery, called Focus, which has three unique facets. First, Focus uses a system’s evolution requirements to isolate and incrementally recover only the fragment of the system’s architecture affected by the evolution. In this manner, Focus allows engineers to direct their primary attention to the part of the system that is immediately impacted by the desired change; subsequent

During the past decade, object-orientation (OO) has become the dominant software development methodology, accompanied by a number of modeling notations, programming languages, and development environments. OO applications of today are increasingly complex and userdriven. They are also developed more rapidly and evolved more frequently than was the case with software systems of the past. All of these factors contribute to a plethora of potential problems when maintaining and evolving an OO application. These problems are caused by architectural erosion, where the initial architecture of an application is (arbitrarily) modified to the point where its key properties no longer hold. We propose an approach, called Focus, whose goal is to enable effective evolution of such an application with minimal effort, by recovering its architecture and using it as the basis of evolution. Focus allows engineers to direct their primary attention to the part of the system that is directly impacted by the desired change; subsequent changes will incrementally uncover additional parts of the system’s architecture. We have applied Focus to four off-the-shelf applications to date. We discuss its key strengths and point out several open issues that will frame our future work.

This paper surveys the techniques currently known as safe and secure execution mechanisms for mobile objects. In this paper we distinguish safety and security in the following way. Safety means that illegal resource access is inhibited and handled in a systematic way.For example, in some programming languages, safe data structures are provided (such as lists in Lisp) to permit only safe operations to be applied to the data, or an exception handling mechanism is provided for the programmers to explicitly describe fault-handling. Security means to provide protection and integrity in the presence of malicious users. Notice that security subsumes safety. Encoding of an electronic mail message is atypical means of assuring secure communication. Thus, security issues can be divided into two sets: issues covered and not covered by safety. The former in general can be dealt with by preparing only mechanisms, while the latter can be dealt with by preparing both mechanisms and policies [19]. Often, a program that attacks security is designed not to violate safety, because if it did, it would be easily detected by the system. Thus, security maintenance always requires a security policy that draws a clear line between unsecure and secure things. The security maintenance mechanism watches and verifies every operation performed by a questionable object according to the given security policy.

Current object-oriented development practice is centered around application frameworks. In this paper, we argue that this approach is misleading, as it distracts from the ultimate goal of composing software out of "software components" originating from different sources. In particular, we suggest a model of software composition that is based on passing of "first-class messages" rather than on inheritance. In most object-oriented programming languages, messages and the methods that get executed in response to receiving them are only "second class citizens". In these languages, one can send a message to an object, but one cannot further manipulate the message itself as a data object. As a consequence, many of the operations that a naive observer might expect to be available are in fact not usually offered. Examples of such missing operations are the ability to store arriving messages in a data structure and execute them asynchronously later, perhaps in a different order, or the capabili...

Remote Method Invocation (RMI) is available in the current Java language design and implementation, providing the much-needed capability of allowing objects running in different Java processes to collaborate using a variation on the popular Remote Procedure Call (RPC). Although RMI provides features which are desirable for high-performance distributed computing, its design and implementation are deficient in key areas of importance to the high-performance computing community in general. This paper addresses the key deficiencies of RMI and how these deficiencies affect the design and implementation of distributed object applications. Reflective RMI (RRMI) is an open RMI implementation which makes better use of the object-oriented features of Java. RRMI is so-called reflective because it directly employs the reflection capabilities of the current Java language to invoke methods remotely. RRMI makes use of the dynamic class loader (a class called NetClassLoader) to allow client/server app...

This document contains a brief overview of the Java based application DeApp. The latter is set out to provide an easily extendable and platform-independent framework to solve function optimization problems with Differential Evolution (DE). ________________________________________ 1) International Computer Science Institute, 1947 Center Street, Berkeley, CA 947041198, Suite 600, Fax: 510-643-7684. E-mail: storn@icsi.berkeley.edu. 2 1.1.

A large group of computer users are now mobile; they either make use of more than one computer or carry lap-top computers with them. User migration is often hindered by inadequate programming models and architectures. This paper describes an architecture which permits the user's environment to migrate with them. A corner-stone of this architecture is the ability of persistent Java systems to save and restore the state of active computations. This concept is extended to permit computations to be restored on different machines thus permitting a user's environment to migrate. The architecture also addresses the difficult issue of channel mobility between two migratory applications. It is therefore general enough to support arbitrary distributed mobile computations. 1 Introduction Many computer users make use of more than one computer, for example, it is common to have a computer at work and another at home. Sometimes within the workplace a user may use more than one computer,...