Steven P. Reiss

Connecting tools using message passing in the Field environment

An overview is given of the Field environment, which was developed to show that highly integrated, interactive environments like those on PCs can be implemented on workstations and can be used for classical-language and large-scale programming. Field connects tools with selective broadcasting, which follows the Unix philosophy of letting independent tools cooperate through simple conventions, demonstrating that this simple approach is feasible and desirable. Field achieves its goals by providing a consistent graphical front end and a simple integration framework that lets existing and new Unix tools cooperate. The front end is based on a tool set called the Brown workstation environment. The framework combines selective broadcasting with an annotation editor that provides consistent access to the source code in multiple contexts and with a set of specialized interactive analysis tools. Fields integration framework and message facility are described.<<ETX>>

PECAN: Program Development Systems that Support Multiple Views

This paper describes the PECAN family of program development systems. PECAN supports multiple views of the users program. The views can be representations of the program or of the corresponding semantics. The primary program view is a syntax-directed editor. The current semantic views include expression trees, data type diagrams, flow graphs, and the symbol table. PECAN is designed to make effective use of powerful personal machines with high-resolution graphics displays and is currently implemented on APOLLO workstations.

Stretching the rubber sheet: a metaphor for viewing large layouts on small screens

We propose the metaphor of rubber sheet stretching for viewing large and complex layouts within small display areas. Imagine the original 2D layout on a rubber sheet. Users can select and enlarge different areas of the sheet by holding and stretching it with a set of special tools called handles. As the user stretches an area, a greater level of detail is displayed there. The technique has some additional desirable features such as areas specified as arbitrary closed polygons, multiple regions of interest, and uniform scaling inside the stretched regions.

Data-swapping: A technique for disclosure control☆

Abstract This paper describes data-swapping as an approach to disclosure control for statistical databases. Data-swapping is a data transformation technique where the underlying statistics of the data are preserved. It can be used as a basis for microdata release or to justify the release of tabulations.

Semantics-based code search

Our goal is to use the vast repositories of available open source code to generate specific functions or classes that meet a users specifications. The key words here are specifications and generate. We let users specify what they are looking for as precisely as possible using keywords, class or method signatures, test cases, contracts, and security constraints. Our system then uses an open set of program transformations to map retrieved code into what the user asked for. This approach is implemented in a prototype system for Java with a web interface.

Encoding program executions

Dynamic analysis is based on collecting data as the program runs. However, raw traces tend to be too voluminous and too unstructured to be used directly for visualization and understanding. We address this problem in two phases: the first phase selects subsets of the data and then compacts it, while the second phase encodes the data in an attempt to infer its structure. Our major compaction/selection techniques include gprof-style N-depth call sequences, selection based on class, compaction based on time intervals, and encoding the whole execution as a directed acyclic graph. Our structure inference techniques include run-length encoding, context free grammar encoding, and the building of finite state automata.

Graphical program development with PECAN program development systems

This paper describes the users view of the PECAN family of program development systems. PECAN is a program development system generator for algebraic programming languages. The program development systems it produces support multiple views of the users program, its semantics, and its execution. The program views include a syntax-directed editor, a declaration editor, and a structured flow graph editor. The semantic views include expression trees, data type diagrams, flow graphs, and the symbol table. Execution views show the program in action and the stack contents as the program executes. PECAN is designed to make effective use of powerful personal machines with high-resolution graphics displays and is currently implemented on APOLLO workstations.

Practical data-swapping: the first steps

The problem of statistical database confidentiality in releasing microdata is addressed through the use of approximate data-swapping. Here a portion of the microdata is replaced with a database that has been selected with approximately the same statistics. The result guarantees the confidentialityof the original data, while providing microdata with accurate statistics. Methods for achieving such transformations are considered and analyzed through simulation.

The specification of visual language syntax

Visual programming languages use pictures as programs. One approach to building a visual programming environment is to parameterize a generic environment with a language specification. We describe a mechanism for specifying visual languages that can be used as the basis of a language-independent visual programming environment. Our mechanism is a new type of grammar, called a picture layout grammar. We show how this type of grammar can describe the two-dimensional syntax of a visual language and give an example of its use. A picture layout grammar permits the syntactic structure of visual program to be recovered by parsing. The parsing ability provides the basis of our visual programming environment.

Code bubbles: a working set-based interface for code understanding and maintenance

Developers spend significant time reading and navigating code fragments spread across multiple locations. The file-based nature of contemporary IDEs makes it prohibitively difficult to create and maintain a simultaneous view of such fragments. We propose a novel user interface metaphor for code understanding based on collections of lightweight, editable fragments called bubbles, which form concurrently visible working sets. We present the results of a qualitative usability evaluation, and the results of a quantitative study which indicates Code Bubbles significantly improved code understanding time, while reducing navigation interactions over a widely-used IDE, for two controlled tasks.