Steven Reiss, Ph.D. - US grants

Mentally retarded people are vulnerable to a wide range of emotional disorders, which are often unidentified or not responded to with appropriate services. In recent years, the problem has become worse as a result of deinstitutionalization of the mentally retarded. Today there are many more mentally retarded people with emotional disorders living in community-based facilities than was the case in the past. These people are requesting services at community mental health centers that are poorly prepared to serve mentally retarded people. Additionally, operators of large state institutions are finding that severe mental illness is a major reason why some mentally retarded people cannot leave the institution. This has led to the creation of costly units for the "dually diagnosed" in state mental health hospitals. One problem in meeting the growing demand for mental health services for mentally retarded people is a lack of knowledge. There has been so little research that scientists are still in the early stages of trying to develop valid measures, valid clinical assessment techniques, and appropriate therapies. The need to increase the supply of mental health services for mentally retarded people implies a need for a long term commitment to research on this topic. Funds are requested to convene the first scientific meeting on the mental health aspects of mental retardation. An exceptionally distinguished group of 55 invited scientists and scholars have committed to participate ;in the proposed conference. The specific aims of the conference are to provide researchers with an opportunity to meet one another and exchange ideas; to summarize past research on the mental health aspects of mental retardation; to suggest priorities for future research; to identify and try to resolve methodological issues; to suggest ethical standards for research; and to stimulate graduate and medical student interest in the topic.

The goal of this project is the development of compiler optimization techniques for high-level languages. The primary programming languages used today (C, Fortran and Pascal) are not very high-level. A large portion of the effort in writing software in these languages is devoted to hand-tuning the individual application to the target machine, a process that is both costly and error-prone. Higher-level languages that abstract away many of the implementation details have been developed but are not yet in widespread use. In spite of the benefits that higher-level languages promise, history suggests that they will not come into general use until programs written in them perform as well or better than those in existing low- level languages. Optimization of object-oriented programming languages, one class of high-level languages, is the major concern of this proposal. Object-oriented programming introduces two types of inefficiencies. First, many more subroutine calls are required than in normal programming methodologies. Second, these subroutines are typically more general than the code necessary to implement the function in line. Optimization of object-oriented programs primarily involves tailoring instances of subroutines to the context in which they are invoked. Automatic tailoring requires much more powerful analysis and transformation techniques than are generally available today. Developing analysis and transformation techniques to do the tailoring of these programmer-constructed abstractions is the main focus of this project.

This project involves the development of practical programming tools in an integrated and open framework. Tools that support modern programming must deal with large systems, multiple programmers, multiple languages, a mixture of existing and new code, and multiple processes and threads. The work combines a variety of tools in an open, extensible, and powerful setting using control integration and a simple form of data integration based on fragments. Fragments are semantically significant portions of a program artifact: definitions or scopes in a source file, sections of documentation file, rules in a configuration description, etc. The approach to integration identifies such fragments and keeps references to them in a simple and small central database. This information is augmented with the data necessary to identify fragments using database queries, essentially usedef chains and small amounts of tool-specific information. In addition to fragment and control integration, the environment provids common facilities for defining and managing the files and contexts that make up a project, and a common editor for all software artifacts. The project manager serves as a front end for managing version control, configuration management, and multiple programmers. The common editor provides high quality typography along with support for hypertext links and graphics. On top of this environmental framework, this project investigates the development and utility of a variety of programming tools. The research extends visualization tools using a 3D visualization package developed under a previous NSF grant. A single front end would allow the programmer to specify both what information (from a variety of sources) should be visualized and how it should be presented for each particular application. Experiments measure the ffectiveness of visualizations for understanding both the static structure and the dynamic behavior of complex systems. A third set of tools involves editing. The project would extend an existing editor to allow programmers to view the system as a single electronic document with dynamic and static links connecting the various software artifacts. These links would be defined either by built-in queries (e.g. go to the definition of a name), by user-defined queries, or by static links.

The impact of this work will be threefold. The immediate result will be a prototype system for using software visualization for understanding. Educationally, the work will expose students to visualization as a means of understanding and get them interested and involved in working on the difficult problems inherent in visualization and understanding. Finally, the broader impact of this project will be to establish foundations for future software visualization and understanding efforts by solving some of the basic problems in these areas.

This research addresses the problem of adding data management facilities to inherently autonomous, distributed information sources such as those that occur in the web. Here, by data management, is meant the allocation and structuring of resources to provide more responsive access to data for applications. In this kind of environment, data management must be superimposed through an independently controlled service that exists between the data sources and the applications. This is facilitated through the introduction of architecture based on data centers, a collection of machines that prestage and distribute data for its clients. Client applications submit profiles describing their overall data needs, and the data center gathers data and organizes it on behalf of their clients in order to provide efficient data access. This research explores systems issues and techniques for the design and operation of data centers. This includes the management of large numbers of profiles, heuristics for balancing the needs of large numbers of users against the available resources of the data center, and the efficient processing of future client data needs against the data that is managed by the data center.

0613162
Steven P. Reiss
Brown University

Designing the Undesignable

Software design involves designing the undesignable. It differs from other forms of design in that software design is expected to meet a set of constraints that changes dynamically and faster than the software can adapt.
Moreover, future trends in software development will force developers to design systems that are out of their control. This research investigates whether a component model that includes the semantics of a component as part of its interface can address these problems of software design. Semantics is used here in the broad sense to include the functionality of the component, security and privacy constraints imposed on or by the component, a recovery model, and an economic model for choosing components. The research involves exploring ways of defining and checking such semantic specifications against component implementations and the use of such specifications as a new design metaphor. If successful, this approach promises to let developers control software design and get a handle on many of the problems that plague the evolution of modern software.

Computer software has become highly complex, with many applications now in the millions of lines of code, and program features often spread across many files and directories. As a result of this, software engineers today spend a significant amount of time struggling with navigating through all of this code as they add new features to complex applications . This research project will develop a new user interface for programmers called Code Bubbles that visualizes the many pieces of code they need to work with and reference on the screen simultaneously, along with the interrelationships between these code fragments. Providing such a "working set" of all the relevant code fragments on one screen marks a radical departure from the way software development environments work today, where programmers can only see or work with a few locations in the code at a time and have to rely either on memory or on continuous navigation between files to examine their working set. Preliminary user studies with software developers using an early version of Code Bubbles indicate that the approach has the potential to revolutionize the way programmers think about software development and lead to more efficient and more robust applications, and to lower development costs.

Code Bubbles is based on a user interface design that facilitates the simultaneous viewing and manipulation of the fine-grained fragments of information needed to perform tasks. Unlike conventional Interactive Development Environments, which are grounded upon the notion of viewing code at the granularity of a file, Code Bubbles displays fragments of code, documentation, and other artifacts as small bubbles which avoid occlusion by pushing each other out of the way across a large virtual display. Text is automatically reflowed within bubbles for maximum efficiency in using screen space, and "chrome", i.e., controls for manipulating a bubble, is kept to a minimum, again to preserve space for content. This project will apply the Code Bubbles concept to a wide range of programming artifacts including scripting, debugging, code review, and collaboration. An iterative design process will be used that involves professional developers as well as students giving feedback on visualization and user interface designs throughout the design process. The experiments to be conducted as part of the evaluation plan will include longitudinal studies in which developers "take home" the Code Bubbles system and use it on their projects and then give feedback and participate in regular interviews. A version of Code Bubbles will be implemented for educational purposes (high school through college) and will be integrated into Computer Science courses at Brown University and the University of Central Florida. Finally, Code Bubbles will be distributed freely, as open source, so that software developers can begin using it and also contribute their own features.