In this paper, we present first steps towards a mobile and wearable system intended to help people who experience regular and spontaneous panic attacks due to panic disorder. The goal of the system is to predict oncoming panic attacks and to deliver in-the-moment interventions on a smartphone device. Interventions are intended to reduce symptom severity by enabling a user to respond to approaching panic episodes. An initial feasibility study is described where a small real-world data set was collected. Personalized prediction models were trained which take, as input, physiological data and output a binary classification of either pre-panic or non-panic. We demonstrate proof-of-concept of episode prediction on this small dataset.

Panic disorder is a serious condition that affects approximately six million adults in the United States per year. Reducing the severity of panic attack symptoms would allow a better quality of life for panic attack sufferers. This paper presents steps towards a mobile and wearable system that aims to help reduce the severity of symptoms experienced by individuals with this condition. The system provides a way to continuously monitor the physiological data of an individual via a wearable device. Users are able to report when panic attacks take place, along with a rating of the severity of symptoms experienced. Reported episodes provide ground truth data to build panic prediction models. The eventual goal of the system is to make predictions about approaching panic attacks and to deliver interventions that help the individual to cope with the approaching episode. We describe a mobile-based intervention that has been developed, which instructs the individual to perform breathing and relaxation exercises. Presently, the system has been utilized in a small pilot study where 10 individuals who suffer from panic disorder reported 29 panic attacks while collecting physiological data, along with the severity of symptoms. We found that out of 15 symptoms the ones with high severity reported were anxiety, worry and shortness of breath. Furthermore, physiological differences were observed between panic and non-panic intervals.

Qualitative reasoning can play an important role in early stage design. Currently, engineers explore the design space using simulation models built in languages such as Modelica. To make qualitative reasoning useful to them, designs specified in their languages must be translated into a qualitative modeling language for analysis. The contribution of this paper is a sound and effective mapping between Modelica and qualitative reasoning. To achieve a sound mapping, we extend envisioning, the process of generating all relevant qualitative behaviors, to support Modelica's declarative events. For an effective mapping, we identify three classes of additional constraints that should be inferred from the Modelica representation thereby exponentially reducing the number of unrealizable trajectories. We support this contribution with examples and a case study.

We describe ongoing research using natural English text queries as an intelligent interface for inferring answers from structured data in a specific domain. Users can express queries whose answers need to be deduced from data in different databases, without knowing the structures of those databases nor even the existence of the sources used. Users can pose queries incrementally, elaborating on an initial query, and ask follow-up questions based on answers to earlier queries.

This paper reports on the results of studies of task management to support the design of a task list manager. We examined the media used to record and organize to-dos and tracked how tasks are completed over time. Our work shows that, contrary to popular wisdom, people are not poor at prioritizing. Rather, they have well-honed strategies for tackling particular task management challenges. By illustrating what factors influence task completion and how representations function to support task management, we hope to provide a strong foundation for the design of a personal to-do list manager. We also present some preliminary efforts in this direction.

Service technicians in the field often come across difficult service problems that are new to them. They have a large number of resources that they can draw on to deal with such problems, including both people and documents. We have undertaken a detailed study of technicians' everyday work, and have discovered two distinct types of information use, reflecting two different problem-solving practices. The less frequently used problem-solving practice is instruction following, where technicians follow company-documented Repair Analysis Procedures (RAPs). The second, more common practice is gleaning, where the information is gathered from many sources -- including other technicians and informal tips, which are documents written by technicians describing their invented solutions to hard service problems. Our observations show how the informational and interface affordances of the system for accessing the tips support their easy incorporation into the gleaning approach for problem solving in difficult cases. We also recommend ways that RAPs can be augmented to provide affordances for gleaning, and more effective instruction following.

We discuss the treatment of prevention statements in both natural language semantics and knowledge representation, with particular regard to existence entailments. First order representations with an explicit existence predicate are shown to not adequately capture the entailments of prevention statements. A linguistic analysis is framed in a higher order intensional logic, employing a Fregean notion of existence as instantiation of a concept. We discuss how this can be mapped to a Cyc style knowledge representation.

Computer systems developed for groups of people often have built-in social imperatives, either explicitly or implicitly brought to bear during technology design and use.Even when users are active, ongoing participants in design, conflicts can arise between the social assumptions inscribed in technical mechanisms and those in existing or proposed social practices, resulting in changes to both.This paper describes the joint evolution of tools and social practices in Pueblo, a school-centered learning community supported by a MOO (an Internet-accessible virtual world).Examples illustrate how one can design and use a social practice to simplify a technical implementation, and how one can make a choice in technical implementation to work towards a desirable social goal.Social and technical practices in a network community co-evolve as social values and policies become clearer and as growth in the community pushes it toward changes in the distribution of authority and power.

No abstract available.

Two key ideas in garbage collection are generational collection and conservative pointer-finding. Generational collection and conservative pointer-finding are hard to use together, because generational collection is usually expressed in terms of copying objects, while conservative pointer-finding precludes copying. We present a new framework for defining garbage collectors. When applied to generational collection, it generalizes the notion of younger/older to a partial order. It can describe traditional generational and conservative techniques, and lends itself to combining different techniques in novel ways. We study in particular two new garbage collectors inspired by this framework. Both these collectors use conservative pointer-finding. The first one is based on a rewrite of an existing trace-and-sweep collector to use one level of generation. The second one has a single parameter, which controls how objects are partitioned into generations: the value of this parameter can be changed dynamically with no overhead. We have implemented both collectors and present measurements of their performance in practice.

WYSIWIS (What You See Is What I See) is a foundational abstraction for multiuser interfaces that expresses many of the characteristics of a chalkboard in face-to-face meetings. In its strictest interpretation, it means that everyone can also see the same written information and also see where anyone else is pointing. In our attempts to build software support for collaboration in meetings, we have discovered that WYSIWIS is crucial, yet too inflexible when strictly enforced. This paper is about the design issues and choices that arose in our first generation of meeting tools based on WYSIWIS. Several examples of multiuser interfaces that start from this abstraction are presented. These tools illustrate that there are inherent conflicts between the needs of a group and the needs of individuals, since user interfaces compete for the same display space and meeting time. To help minimize the effect of these conflicts, constraints were relaxed along four key dimensions of WYSIWIS: display space, time of display, subgroup population, and congruence of view. Meeting tools must be designed to support the changing needs of information sharing during process transitions, as subgroups are formed and dissolved, as individuals shift their focus of activity, and as the group shifts from multiple parallel activities to a single focused activity and back again.

WYSIWIS (What You See Is What I See) is a foundational abstraction for multi-user interfaces that expresses many of the characteristics of a chalkboard in face-to-face meetings. In its strictest interpretation, it means that everyone can see the same written information and also where anyone else is pointing. We present several examples of multi-user interfaces that start from the WYSIWIS abstraction. In our attempts to build software support for collaboration in meetings, we have discovered that WYSIWIS is at once crucial and too inflexible in its strictest sense. WYSIWIS must be relaxed for all our software tools to better accommodate important interactions in meetings. Relaxations to WYSIWIS are characterized in terms of constraints on its four key dimensions: display space, time of display, subgroup population, and congruence of view.

Concurrent Prolog supports object-oriented programming with a clean semantics and additional programming constructs such as incomplete messages, unification, direct broadcasting, and concurrency synchronization [Shapiro 1983a]. While it provides excellent computational support, we claim it does not provide good notation for expressing the abstractions of object-oriented programming. We describe a preprocessor that remedies this problem. The resulting language, Vulcan, is then used as a behicle for exploring new variants of object-oriented programming which become possible in this framework.

Knowledge bases built in object-oriented systems use networks of interconnected objects in their representations. The mechanism described here provides a way to use such a network as a prototype by making virtual copies of it. The virtual copy is created incrementally. Values of instance variables in the virtual copy are inherited from the prototype until locally overridden in the copy, similar to inheritance of defaults between instances and classes in Loops. A virtual copy preserves the topology of the original network. Virtual copies can be made from virtual copies. Alternative implementations of virtual copies allow different tradeoffs in space and lookup time. Virtual copies can be used for building knowledge bases for design, for representing contexts in a problem solving system, and have other uses in ordinary programming.

Knowledge programming, which makes use of the explicit representation and interpretation of knowledge to create intelligent programs, requires specialized languages and tools to help programmers. Prolog, an implementation of a logic programing language, provides some of these tools; it and other languages have been argued to be the "best" way to do such knowledge programming. This paper raises questions which suggest that any single paradigm of programming (e.g., logic programming or object-oriented programming) benefits by being integrated in a single environment with other paradigms of programming. Integration of these paradigms with each other, and within a flexible, user-friendly computing environment is also necessary. Such an environment must provide source level debugging and monitoring facilities, analysis and performance tuning tools, and an extended set of user communication programs.

Automatic storage management requires that one identify storage unreachable by a user's program and return it to free status. One technique maintains a count of the references from user's programs to each cell, since a count of zero implies the storage is unreachable. Reentrant structures are self-referencing; hence no cell in them will have a count of zero, even though the entire structure is unreachable. A modification of standard reference counting can be used to manaage the deallocation of a large class of frequently used reentrant structures, including two-way and circularly linked lists. All the cells of a potentially reentrant structure are considered as part of a single group for deallocation purposes. Information associated with each cell specifies its group membership. Internal references (pointers from one cell of the group to another) are not reference counted. External references to any cell of this group are counted as references to the group as a whole. When the external reference count goes to zero, all the cells of the group can be deallocated. This paper describes several ways of specifying group membership, properties of each implementation, and properties of mutable and immutable group membership.

List structures provide a general mechanism for representing easily changed structured data, but can introduce inefficiencies in the use of space when fields of uniform size are used to contain pointers to data and to link the structure. Empirically determined regularity can be exploited to provide more space-efficient encodings without losing the flexibility inherent in list structures. The basic scheme is to provide compact pointer fields big enough to accommodate most values that occur in them and to provide “escape” mechanisms for exceptional cases. Several examples of encoding designs are presented and evaluated, including two designs currently used in Lisp machines. Alternative escape mechanisms are described, and various questions of cost and implementation are discussed. In order to extrapolate our results to larger systems than those measured, we propose a model for the generation of list pointers and we test the model against data from two programs. We show that according to our model, list structures with compact cdr fields will, as address space grows, continue to be compacted well with a fixed-width small field. Our conclusion is that with a microcodable processor, about a factor of two gain in space efficiency for list structure can be had for little or no cost in processing time.

Newer programming languages for artificial intelligence extend the class of available control regimes beyond simple hierarchical control. In so doing, a key issue is using a model that clearly exhibits the relation between modules, processes, access environments, and control environments. This paper presents a model which is applicable to diverse languages and presents a set of control primitives which provide a concise basis on which one can define almost all known regimes of control.

This paper appears in the March, 1972, issue of the Communications of the ACM. Its abstract is reproduced below.

There are two distinct (though not necessarily disjoint) types of language extension. The first is a syntactic extension, in which the class of expressions interpretable within a language is widened. The second is an extension of the functional domain in which operations not previously performable are added to the language. These extensions may be implemented by completely reprogramming the basic language processor (the compiler or interpreter), but such extensions may often be achieved at far less cost by embedding. The authors give an example of each of these two types of extensions by embedding, adding list-processing facilities to the FORTRAN language, and extending the list processing language LISP to facilitate expression and interpretation of string transformations. As an aid to those unfamiliar with list processing, there is a section which reviews this subject. Included are descriptions and explanations of list structures, the various notations used for lists, the basic processes of list processing, and the different notations (machine language, functional, and prototype) used for expressing processing of lists.