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.

Brown University will purchase advanced, state-of-the-art workstations to populate a unique classroom laboratory for computer science instruction. This laboratory will use advanced software, now under development, to provide a consistent visual programming environment to undergraduates from their first, introductory programming course, through the most advanced software engineering course or independent study. This environment will significantly improve the teaching of computer science and will affect the whole undergraduate curriculum. The unique feature of the proposed environment is a set of integrated tools for program and data structure visualization. These tools will enable students to visualize concepts and the programs that embody them throughout their undergraduate experience. A simple, "read-only" version of the system BALSA, has been used at Brown successfully for four years and has already had a significant impact on their curriculum. The system envisioned, not only will provide more powerful visualization tools, including color and real-time animation of three- dimensional representations, but also will allow the student to interact with visualizations during the course of a lecture as well as during the implementation of the student's own programs.

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.

Computing has experienced two major paradigm shifts in the past 25 years: from batch computing to time-shared computing and from time-shared computing to personal computer and workstation computing. A third paradigm shift, probably as significant as the first two--the exploitation of three-dimensional visualization, visual programming, and multimedia--will be next.In this project, Brown University plans to continue to exert leadership in teaching and research by being at the forefront of efforts to make this latest paradigm accessible and useful to all. The project involves equipping the electronic classroom with the latest generation of workstations with three-dimensional graphics and multimedia capabilities, developing the necessary educational software to exploit the capabilities of this new generation, and exporting both the software and the educational materials developed with it to other institutions.The work is both a continuation and a significant extension of the past and current efforts at Brown. The current research efforts in graphics, programming environments, and program visualization will be used as a foundation for the new tools, migrating research software into the instructional environment. The curriculum will be upgraded and, where necessary, revised to introduce advanced concepts in the introductory courses and to reinforce these concepts in the latter courses.

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 instrumentation and measurement of systems is vital for them to be understood, debugged, tuned, refined, tested, validated, or made reliable. This project will investigate the principles and practice of program instrumentation. Principles include a theoretical understanding of the dynamic measurement and observation of various structures in parallel, distributed, and sequential systems, such as acyclic or cyclic graphs for representing parallel executions and families of finite automata for tracking information about variable accesses. The complexity of computing and analyzing such structures will be explored, including tradeoffs between time, space, accuracy, and completeness. The practice of instrumentation implements measurement techniques at a cost acceptable to users, using on-line algorithms to dynamically decide what to do and when it is best done and by fully exploiting the semantics of the problem at hand. Techniques will be developed, especially for debugging and programming tools, for problems whose best-known solutions are currently prohibitive because of instrumentation costs. An arsenal of practical techniques usable in many areas, all of which are based on theoretical underpinnings, will also be developed. This research will result in a deeper understanding of the cost of solving various types of instrumentation problems and an array of techniques for their solution. This project will introduce undergraduates to research by involving them in independent study seminars together with "project sets" partially specified mini-research problems which require as much work in problem formulation as solution. This project will escalate the undergraduate-outreach effort at Brown. The tools this project will produce will be suitable for use by students in their research projects.***

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.

In order to make programming easier, future software development environments will have to raise the level of abstraction at which programmers work, provide them with more and better information about their systems, and handle more of the mundane and mechanical tasks involved in programming. This project is designed to lay the foundations for the next-generation programming tools that will compose such environments. In particular, the project will consider two important tools: one to support design patterns, and another to visualize software behavior. The design patterns tool will let programmers find, create, verify, and edit instances of design patterns in their source code, thus allowing higher-level programming. The software visualizations will enable programmers to quickly define and see visualizations for specific problems that arise in program execution, thus allowing better understanding of the running program.

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.

Software is multidimensional; it has many representations besides the
program source. These include formal specifications, test suites,
documentation and even the development history. As software evolves,
these dimensions must stay consistent and reflect each other as
thoroughly as possible. In practice, however, while these are usually
consistent when first created, they tend to receive unequal attention
and therefore gradually become inconsistent. Programmers thus
typically rely on the source code to the exclusion of most other
dimensions.

This project's goal is to help programmers cope with software
evolution by viewing the dimensions of software as constraints on one
another. The project proposes a constraint representation common to
the different software dimensions. Software evolution then becomes a
process of maintaining consistency between constraints. These
constraints also help programmers identify high-level features in
their system, and generate rationales to document design decisions.

The escalating costs of software maintenance give the project
immediacy and its results high significance. It will have immediate
impact by developing tools for programmers to use. It will have
effect over the long term by employing these tools in educational
settings so future developers have a better appreciation for the
importance of maintaining the multiple dimensions of software.

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.

Computers are becoming essential in all disciplines. Researchers in the social sciences rely on the availability of large data repositories and the general availability of data over the Web. Researchers in the humanities are increasingly looking to analyze the growing number of electronic corpora. Workers in all fields are making use of new ways to publish data and of to interact with colleagues and others using electronic media. Moreover, more and more jobs and companies are relying on the understanding and processing of information. Modern companies as diverse as Google, WalMart, Amazon, and Goldman Sachs all owe their success in large part to their ability to evaluate and act on available information. It is estimated that in the next ten years, over twelve million people in the U.S. workforce will consider programming their primary job, which is far more than the current or near-term number of computer science majors. To address these needs, to better prepare students for careers involving information processing, to prepare
tomorrow?s researchers in the humanities and social sciences, and to prepare tomorrow?s workers for an information-based world, computer science needs to reach out beyond its traditional audience and even beyond the sciences. This project focuses on disciplines that have traditionally
been neglected by computer scientists, harnessing the growing revolution in applying computing to social artifacts. Second, it will result in a novel, application-driven, on-demand presentation of computing material, coming to topics like machine-learning and data-mining very early, rather than late, in the curriculum. Third, the development of a curriculum arranged in concentric rings of growing commitment, where a student who stops early will still get a meaningful education. It will provide the proper foundation for the growing use of computing and cyberinfrastructure in the humanities and social sciences. It will ultimately train such students have been relegated to with the tools to make their own non-trivial contributions to cyberinfrastructure. It will result in more women and minorities, groups traditionally underrepresented in computing, working with and using computation and cyberinfrastructure. Finally, it will enable students to wed their deep social and humanistic insights to tools that can enable them to build wonderful inventions that have the power to greatly enrich society.

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.