Debugging is costly. Automated program repair (APR) holds the promise of reducing its cost by automatically fixing errors. However, current techniques are not easily applicable in a realistic debugging scenario because they assume a high-quality test suite and frequent program re-execution, have low repair efficiency, and only handle a limited set of errors. To improve the practicality of APR for debugging, we propose ROSE, an interactive repair framework that is able to suggest quick and effective repairs of semantic errors while debugging in an Integrated Development Environment (IDE). ROSE allows an easy integration of existing APR patch generators and can do program repair without assuming the existence of a test suite and without requiring program re-execution. It works in conjunction with an IDE debugger and assumes a debugger stopping point where a problem symptom is observed. ROSE asks the developer to quickly describe the symptom. Then it uses the stopping point, the identified symptom, and the current environment to identify potentially faulty lines, uses a variety of APR techniques to suggest repairs at those lines, and validates those repairs without re-executing the program. Finally, it presents the results so the developer can examine, select, and make the appropriate repair. ROSE uses novel approaches to achieve effective fault localization and patch validation without a test suite or program re-execution. For fault localization, ROSE builds on a fast abstract interpretation-based flow analysis to compute a static backward slice approximating the real dynamic slice while taking into account the symptom and the current execution. For patch validation without re-running the program, ROSE generates simulated traces based on a live-programming system for both the original and repaired executions and compares the traces with respect to the problem symptoms to infer patch correctness. We implemented a prototype of ROSE that works in an Eclipse-based IDE and evaluated its potency and utility with an effectiveness study and a user study. We found that ROSE’s fault localization and validation are highly effective and a ROSE-based tool using existing APR patch generators generated correct repair suggestions for many errors in only seconds. Moreover, the user study demonstrated that ROSE was helpful for debugging and developers liked to use it.

We introduce a tool within the Code Bubbles development environment that allows for continuous execution as the programmer edits. The tool, SEEDE, shows both the intermediate and final results of execution in terms of variables, control and data flow, output, and graphics. These results are updated as the user edits. The tool can be used to help the user write new code or to find and fix bugs. The tool is explicitly designed to let the user quickly explore the execution of a method along with all the code it invokes, possibly while writing or modifying the code. The user can start continuous execution either at a breakpoint or for a test case. This paper describes the tool, its implementation, and its user interface. It presents an initial user study of the tool demonstrating its potential utility.

A typical automatic program repair technique that uses a test suite as the correct criterion can produce a patched program that is test-suite-overfitted, or overfitting, which passes the test suite but does not actually repair the bug. In this paper, we propose DiffTGen which identifies a patched program to be overfitting by first generating new test inputs that uncover semantic differences between the original faulty program and the patched program, then testing the patched program based on the semantic differences, and finally generating test cases. Such a test case could be added to the original test suite to make it stronger and could prevent the repair technique from generating a similar overfitting patch again. We evaluated DiffTGen on 89 patches generated by four automatic repair techniques for Java with 79 of them being likely to be overfitting and incorrect. DiffTGen identifies in total 39 (49.4%) overfitting patches and yields the corresponding test cases. We further show that an automatic repair technique, if configured with DiffTGen, could avoid yielding overfitting patches and potentially produce correct ones.

We present our automated program repair technique ssFix which leverages existing code (from a code database) that is syntax-related to the context of a bug to produce patches for its repair. Given a faulty program and a fault-exposing test suite, ssFix does fault localization to identify suspicious statements that are likely to be faulty. For each such statement, ssFix identifies a code chunk (or target chunk) including the statement and its local context. ssFix works on the target chunk to produce patches. To do so, it first performs syntactic code search to find candidate code chunks that are syntax-related, i.e., structurally similar and conceptually related, to the target chunk from a code database (or codebase) consisting of the local faulty program and an external code repository. ssFix assumes the correct fix to be contained in the candidate chunks, and it leverages each candidate chunk to produce patches for the target chunk. To do so, ssFix translates the candidate chunk by unifying the names used in the candidate chunk with those in the target chunk; matches the chunk components (expressions and statements) between the translated candidate chunk and the target chunk; and produces patches for the target chunk based on the syntactic differences that exist between the matched components and in the unmatched components. ssFix finally validates the patched programs generated against the test suite and reports the first one that passes the test suite. We evaluated ssFix on 357 bugs in the Defects4J bug dataset. Our results show that ssFix successfully repaired 20 bugs with valid patches generated and that it outperformed five other repair techniques for Java.

In many common scenarios, programmers need to implement functionality that is already provided by some third party library. This paper presents a tool called Hunter that facilitates code reuse by finding relevant methods in large code bases and automatically synthesizing any necessary wrapper code. Since Hunter internally uses advanced program synthesis technology, it can automatically reuse existing methods even when code adaptation is necessary. We have implemented Hunter as an Eclipse plug-in and evaluate it by (a) comparing it against S6, a state-of-the-art code reuse tool, and (b) performing a user study. Our evaluation shows that Hunter compares favorably with S6 and increases programmer productivity.

Testing and testing code are critical to maintaining modern, evolving systems. Yet generating a good set of relevant test cases that covers what is important remains a difficult task. We propose a new approach to generating test cases through the use of code search. Open source repositories have made an enormous amount of code available. These contain unit tests for a wide variety of programs where the programmer has often given substantial thought to what should be tested, what is important to test, and how to test it. Our approach is to extract the relevant tests from on-line repositories and use these as the basis for test cases for user code.

We demonstrate a tool for browsing large software repositories such as Github or Source Forge using all the facilities one normally associates with an integrated development environment. The tool integrates code search engines with the Code Bubbles development environment. It lets the user perform and compare multiple searches, investigate and explore the results that are returned, expand searches as necessary, and eventually export appropriate results.

User interface design and coding can be complex and messy. We describe a system that uses code search to simplify and automate the generation of such code. We start with a simple sketch of the desired interface along with a set of keywords describing the application context. We then use existing code search engines to find results based on the keywords. We look for potential Java-based user interface solutions within those results and apply a series of code transformations to the solutions to generate derivative solutions, aiming to get solutions that constitute only the user interface and that will compile and run. We run the resultant solutions and compare the generated interfaces to the user's sketches. Finally, we let programmers interact with the matched solutions and return the running code for the solutions they choose. The system can be used not only for generating initial user interface code for an application, but also for exploring alternative interfaces and for looking at the user interfaces in a code repository.

The behavior of multithreaded programs is often difficult to understand and predict. Synchronization operations and limited computational resources combine to produce complex non-linear dependencies between a program's configuration parameters and its performance. Performance models are used to understand these dependencies. Such models are complex, and constructing them requires a solid understanding of the program's behavior. As a result, building models of complex applications manually is extremely time-consuming and error-prone. In this paper we demonstrate that such models can be built automatically.

We present an approach for building performance models of multithreaded programs automatically. We use a combination of static and a dynamic analyses of a single representative run of the program to build its model. The model can predict performance of the program under a variety of configurations. This paper outlines how we construct the model and demonstrates how the resultant models accurately predict the performance %and resource utilization of complex multithreaded programs.

Programmers spend considerable time debugging their systems. They add logging statements and use debuggers to run their systems in a controlled environment all in an attempt to understand what is happening as their program executes. Our hypothesis is that visualization tools can significantly improve the debugging process. A wide variety of tools have been developed for visualizing and understanding the dynamics of program execution. These tools can provide lots of information about executions. However, most tools are not designed to be used with a debugger. What is needed are tools that can work while the programmer is debugging a system and that provide the information the programmer needs to understand and assist the debugging process. We have started to develop such tools within the context of the Code Bubbles development environment. However, there is much room for improvement and we call upon the software visualization community to think about and develop practical tools that will improve the debugging process.

ABSTRACT Code Bubbles is an attempt to redefine the user interface for an integrated programming environment. As it represents a whole new user interface, implementing it as a plug‐in is inherently difficult. We get around this difficulty by combining two different plug‐in architectures, a standard one based on registrations and callbacks and a message‐based one that puts the plug‐in at arm's length and defines a narrower two‐way interface. This paper describes both how we have implemented Code Bubbles as a plug‐in to Eclipse and how Code Bubbles itself is implemented as a set of plug‐ins representing the different aspects of the environment, using both traditional and message‐based plug‐in architectures as appropriate. It also shows how the resultant architecture is flexible enough to support collaboration, different back ends, and a cloud‐based environment. Copyright © 2013 John Wiley & Sons, Ltd.

We consider the problem of understanding locking behavior in large Java programs using a combination of data collection, data analysis, and visualization. Our technique starts by collecting partial information about all locks used in the program. It then analyzes this information to determine sets of locks with common behaviors and to determine, for each set of locks, how that lock is used, e.g. if it is used as a mutex, semaphore, read-write lock, etc. The result of the analysis is then presented to the user who can select specific locks for full analysis during a subsequent run. Visualizing locking information is particularly difficult since the time scale of a lock can be ten or more orders of magnitude different from the time scale of the overall run and locks can be used millions of times. We provide different visualizations and visualization techniques for this purpose. First, we analyze either the partial or full traces and identify patterns of how each lock is used and display just those patterns along with their frequency. Second, we provide a thread-centric view of locking that supports fish-eye views at the microsecond level as well as time compression. Third, we provide a lock-centric view that is based on the specific type of lock to show its particular behavior.

Code Bubbles is an integrated development environment that concentrates on the user experience. The environment is very visual and includes a number of different visualizations, both static and dynamic. We will demonstrate the environment and the various visualizations on a realistic scenario based on our current work.

At ICSE 2010, the Code Bubbles team from Brown University and the Code Canvas team from Microsoft Research presented similar ideas for new user experiences for an integrated development environment. Since then, the two teams formed a collaboration, along with the Microsoft Visual Studio team, to release Debugger Canvas, an industrial version of the Code Bubbles paradigm. With Debugger Canvas, a programmer debugs her code as a collection of code bubbles, annotated with call paths and variable values, on a two-dimensional pan-and-zoom surface. In this experience report, we describe new user interface ideas, describe the rationale behind our design choices, evaluate the performance overhead of the new design, and provide user feedback based on lab participants, post-release usage data, and a user survey and interviews. We conclude that the code bubbles paradigm does scale to existing customer code bases, is best implemented as a mode in the existing user experience rather than a replacement, and is most useful when the user has a long or complex call paths, a large or unfamiliar code base, or complex control patterns, like factories or dynamic linking.

Our original work on the Code Bubbles environment demonstrated that a working-set based framework for software development showed promise. We have spent the past several years extending the underlying concepts into a fully-functional system. In our demonstration, we will show the current Code Bubbles environment for Java, how it works, how it can be used, and why we prefer it over more traditional programming environments. We will also show how we have extended the framework to enhance software development tasks such as complex debugging, testing, and collaboration. This paper describes the features we will demonstrate.

Predicting the performance of a computer program facilitates its efficient design, deployment, and problem detection. However, predicting performance of multithreaded programs is complicated by complex locking behavior and concurrent usage of computational resources. Existing performance models either require running the program in many different configurations or impose restrictions on the types of programs that can be modeled. This paper presents our approach towards building performance models that do not require vast amounts of training data. Our models are built using a combination of queuing networks and probabilistic call graphs. All necessary information is collected using static and dynamic analyses of a single run of the program. In our experiments these models were able to accurately predict performance of different types of multithreaded programs and detected those configurations that result in the programs' high performance.

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.

Today's integrated development environments (IDEs) are hampered by their dependence on files and file-based editing. We propose a novel user interface that is based on collections of lightweight editable fragments, called bubbles, which when grouped together form concurrently visible working sets. In this paper we describe the design of a prototype IDE user interface for Java based on working sets. A quantitative evaluation shows that developers could expect to view a sizeable number of functions concurrently with relatively few UI operations. A qualitative user evaluation with 23 professional developers indicates a high level of excitement, interest, and potential benefits and uses.

Today's integrated development environments (IDEs) are hampered by their dependence on files and file-based editing. We propose a novel user interface that is based on collections of lightweight editable fragments, called bubbles, which when grouped together form concurrently visible working sets. We describe the design of a prototype IDE user interface for Java based on working sets.

Many of the problems that occur in long-running systems involve the way that the system uses memory. We have developed a framework for extracting and building a model of the heap from a running Java system. Such a model is only useful if programmers can extract from it the information they need to understand, find, and eventually fix memory-related problems in their system. We demonstrate the tool in action, showing how it works dynamically on running processes and how it is designed to address a variety of specific memory issues.

Modern systems, particularly servers, involve multiple threads dealing with multiple incoming transactions using either implicit or explicit internal tasks. Understanding the inherently complex behavior of such systems can be quite difficult. We present a framework that offers a visualization of this behavior in system-specific terms in real time. The framework is unique in that it uses a combination of program analyses to minimize the work the user needs to do to construct the visualization.

Our goal is to use the vast repositories of available open source code to generate specific functions or classes that meet a user's 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.

Our goal is to use the vast repositories of available open source code to generate specific functions or classes that meet a user's 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 using a simple, Web-based interface. 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.

Many of the problems that occur in long-running systems involve the way that the system uses memory. We have developed a framework for extracting and building a model of the heap from a running Java system. Such a model is only useful if the programmer can extract from it the information they need to understand, find, and eventually fix memory-related problems in their system. We propose to demonstrate the tool in action, showing how it works dynamically on running processes and how it is designed to address a variety of specific memory issues.

Complex applications today involve multiple processes, multiple threads of control, distributed processing, thread pools, event handling, messages. The behaviors and misbehaviors of these nondeterministic, message-based systems are difficult to capture and understand. The typical approach is to trace the behavior of the systems and track how the different incoming messages are processed throughout the system. While messages between processes can be captured automatically at the network or library level, tracing the message processing within a system, which is often more complex and error-prone, requires the programmer to manually instrument the code by identifying the different message handlers, thread states, processing stages, and shared queues accurately and completely. In this paper we show how dynamic analysis can be used to automatically identify the transactions, stages and shared queues in Java programs as a prelude to trace-based comprehension.

Many programming tools require information to be associated with source locations. Current tools do this in different ways with different degrees of effectiveness. This paper is an investigation into the various approaches to maintaining source locations. It is based on an experiment that attempts to track a variety of locations over the evolution of a source file. The results demonstrate that relatively simple techniques can be very effective.

We describe an automated approach to finding code fragments that are unusual and hence might represent potential problems. Many potential problems in programs arise in code that is uncommon either because it represents rarely used constructs and hence is unfamiliar to the programmer, or because it represents a mistyping or other error that still happens to be legal code, albeit not very common. We present an approach that first finds what is "unusual" by reading a corpus of code and building a library of common patterns. The approach can then take any existing program and check if it contains any unusual patterns. We have run the system using a large corpus and have identified problems in a number of sample projects with otherwise working code.

Coding style is an important aspect of software development. We present a system that uses machine learning to deduce the coding style from a corpus of code and then applies this knowledge to convert arbitrary code to the learned style. We use a broad definition of coding style that includes spacing, indentation, naming, ordering, and equivalent programming constructs. The result provides a more flexible and powerful approach to code stylizing than current techniques.

Software is multidimensional, but the tools that support it are not. This lack of tool support causes the software artifacts representing different dimensions to evolve independently and to become inconsistent over time. In order to properly support the evolution of software, one must ensure that the different dimensions evolve concurrently. We have built a software development tool, CLIME that uses constraints implemented as database queries to ensure just this. Our approach makes the tool responsible for detecting inconsistencies between software design, specifications, documentation, source code, test cases, and other artifacts without requiring any of these to be a primary representation. The tool works incrementally as the software evolves, without imposing a particular methodology or process. It includes a front end that lets the user explore and fix current inconsistencies. This paper describes the basis for CLIME, the techniques underlying the tool, the interface provided to the programmer, the incremental maintenance of constraints between these artifacts, and our experiences

Dynamic software visualization is designed to provide programmers with insights as to what the program is doing. Most current visualizations either use program traces to show information about prior runs, slow the program down substantially, show only minimal information, or force the programmer to indicate when to turn visualizations on or off. We have developed a dynamic Java visualizer that provides a statement-level view of a Java program in action with low enough overhead so that it can be used almost all the time by programmers to understand what their program is doing while it is doing it.

We have built a software development tool, CLIME, that uses constraints implemented as database queries to ensure the consistency of the different artifacts of software development. This approach makes the environment responsible for detecting inconsistencies between software design, specifications, documentation, source code, and test cases without requiring any of these to be a primary representation. The tool works incrementally as the software is written and evolves without imposing a particular methodology or process. It includes a front end that lets the user explore and fix current inconsistencies. This paper describes the techniques underlying the tool, concentrating on the user interface and the incremental maintenance of constraints between these artifacts.

This paper describes a component model where the overall semantics of a component is included in the interface definition. Such a model is necessary for future computing where programs will run at Internet-scales and will employ a combination of web services, grid technologies, peer-to-peer sharing, autonomic capabilities, and open source implementations. The component model is based on packages and supports static and dynamic objects, interfaces, structures, and exceptions. The interface definitions provide a practical approach to defining functional semantics and include appropriate extensions to provide semantics for security, privacy, recovery, and costs. The component model has been implemented in a prototype framework and demonstrated in an Internet-scale example.

We present Arithmetic Program Paths, a novel, efficient way to compress program control-flow traces that reduces program bit traces to less than a fifth of their original size while being fast and memory efficient. In addition, our method supports online, selective tracing and compression of individual conditionals, trading off memory usage and compression rate. We achieve these properties by recording only the directions taken by conditional statements during program execution, and using arithmetic coding for compression. We provide the arithmetic coder with a probability distribution for each conditional that we obtain using branch prediction techniques. We implemented the technique and experimented on several SPEC 2000 programs. Our method matches the compression rate of state-of-the-art tools while being an order of magnitude faster.

What are people currently looking at in their Web browser? Do the patterns of pages change over time? Are changes periodic or just related to current events or other factors? We are developing a tool that attempts to provide insight into these and other questions. The tool sits on top of an Internet-scale programming backbone supports large numbers of simultaneous users. The tool itself provides a unique category-based visualization of browsing history and includes the necessary code to obtain the raw data.

Many software testing and automated debugging tools rely on structural coverage techniques. Such tools implicitly assume a relation between individual control-flow choices made in conditional statements during a program run and the outcome of the run. In this paper, we develop the notion of elided choices that, viewed in isolation, have no impact on the outcome of the program. We call the conditionals that make such choices elided conditionals. We develop an experimental framework for discovering elided conditionals. From looking at three programs of varying complexity under this framework, we discovered that elided conditionals do occur, sometimes with alarming frequency. We discuss the impact of elided conditionals on various forms of dynamic analysis and suggest future work that would extend elision to general expressions.

Dynamic software visualization should provide a programmer with insights as to what the program is doing. Most current dynamic visualizations either use program traces to show information about prior runs, slow the program down substantially, show only minimal information, or force the programmer to indicate when to turn visualizations on or off. We have developed a dynamic Java visualizer that provides a view of a program in action with low enough overhead that it can be used almost all the time by programmers to understand what their program is doing while it is doing it.

We are building a software development environment that uses constraints to ensure the consistency of the different artifacts associated with software. This approach to software development makes the environment responsible for detecting most inconsistencies between software design, specifications, documentation, source code, and test cases. The environment provides facilities to ensure that these various dimensions remain consistent as the software is written and evolves. The environment works with the wide variety of artifacts typically associated with a large software system. It handles both the static and dynamic aspects of software. Moreover, it works incrementally so that consistency information is readily available to the developer as the system changes. The demonstration will show this environment and its capabilities.

We present a method for performing fault localization using similar program spectra. Our method assumes the existence of a faulty run and a larger number of correct runs. It then selects according to a distance criterion the correct run that most resembles the faulty run, compares the spectra corresponding to these two runs, and produces a report of "suspicious" parts of the program. Our method is widely applicable because it does not require any knowledge of the program input and no more information from the user than a classification of the runs as either "correct" or "faulty". To experimentally validate the viability of the method, we implemented it in a tool, Whither, using basic block profiling spectra. We experimented with two different similarity measures and the Siemens suite of 132 programs with injected bugs. To measure the success of the tool, we developed a generic method for establishing the quality of a report. The method is based on the way an "ideal user" would navigate the program using the report to save effort during debugging. The best results obtained were, on average, above 50%, meaning that our ideal user would avoid looking half of the program.

Software is multidimensional but the tools that support it are not. The lack of tool support causes the software artifacts representing different dimensions to evolve independently and inconsistently. In order to support the evolution of multidimensional software, an environment must ensure that the different dimensions evolve concurrently. This can be accomplished through an integration framework that maintains consistency of the different dimensions as they evolve. We have built a prototype of such a mechanism by setting up and maintaining constraints among artifacts representing the different software dimensions. This paper describes that prototype and our experiences with it to date.

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.

BLOOM is a system for doing software understanding through visualization. It provides facilities for static and dynamic data collection. It offers a wide range of data anal?yses. It includes a visual query language for specifying what information should be visualized. All these are used in con?junction with a back end that supports a variety of 2D and 3D visualization strategies.

The Desert software engineering environment is a suite of tools developed to enhance programmer productivity through increased tool integration. It introduces an inexpensive form of data integration to provide additional tool capabilities and information sharing among tools, uses a common editor to give high-quality semantic feedback and to integrate different types of software artifacts, and builds virtual files on demand to address specific tasks. All this is done in an open and extensible environment capable of handling large software systems.

While software visualization has been widely used for navigation, its use for understanding has been much more limited. Software visualizations are expensive to develop, require large amounts of information that is often difficult to collect, and even then, are good only at addressing the specific task for which they were developed. Our work on software visualization in the Desert environment is aimed at making software visualization a viable approach to understanding. We do this by providing ready access to a variety of information about the system at hand, a range of high-quality, high-density visualizations, and a simple interface that lets the programmer rapidly create new software visualizations for understanding problems as they arise. In this paper we describe the approach we have taken.

Article Free Access Share on Stretching the rubber sheet: a metaphor for viewing large layouts on small screens Authors: Manojit Sarkar Department of Computer Science, Brown University, Providence, RI Department of Computer Science, Brown University, Providence, RIView Profile , Scott S. Snibbe Department of Computer Science, Brown University, Providence, RI Department of Computer Science, Brown University, Providence, RIView Profile , Oren J. Tversky Department of Computer Science, Brown University, Providence, RI Department of Computer Science, Brown University, Providence, RIView Profile , Steven P. Reiss Department of Computer Science, Brown University, Providence, RI Department of Computer Science, Brown University, Providence, RIView Profile Authors Info & Claims UIST '93: Proceedings of the 6th annual ACM symposium on User interface software and technologyDecember 1993 Pages 81–91https://doi.org/10.1145/168642.168650Published:01 December 1993Publication History 160citation1,270DownloadsMetricsTotal Citations160Total Downloads1,270Last 12 Months59Last 6 weeks11 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

It is explained how inheritance and dynamic binding make object-oriented programs difficult to maintain, and a concrete example of the problems that arise is given. It is shown that the difficulty lies in the fact that conventional tools are poorly suited for work with object-oriented languages, and it is argued that semantics-based tools are essential for effective maintenance of object-oriented programs. A system developed for working with C++ programs is described. It comprises a relational database system for information about programs and an interactive database interface integrated with a text editor. The authors describe the system architecture, detail the database relations, provide informal evidence on the system's effectiveness, and compare it to other research with similar goals.>

The authors explain how inheritance and dynamic binding make object-oriented programs difficult to maintain, and give a concrete example of the problems that arise. They show that the difficulty lies in the fact that conventional tools are poorly suited for work with object-oriented languages, and argue that semantics-based tools are essential for effective maintenance of object-oriented programs. The authors describe a system developed for working with C++ programs. This system comprises a relational database system for information about programs, and an interactive database interface integrated with a text editor. They describe the system architecture, detail the database relations, provide informal evidence on the system's effectiveness, and compare it to other research with similar goals.>

A canonical program representation, semantic program graphs (SPGs), is described, and it is shown how SPGs can act as the foundation for multiparadigm software development environments. Using SPGs as the basis for program representation allows developers to see different views of programs that correspond to different ways of thinking about them, and it allows editors to be created so that the underlying program can be edited using any of the paradigms. As the sole program representation, SPGs also facilitate communication between paradigms: changes made in one view can be immediately reflected in all other views.>

GELO is a package that supports the interactive graphical display of software systems. Its features include built-in panning and zooming, abstraction of objects too small to see, pick correlation, windowing, and scroll bars. GELO creates a hierarchy of graphical objects that correspond to the components of the structure being displayed. Five flavors of graphical objects are supported, including those for simple structures, tiled layouts, and graph-based layouts. This framework is powerful enough to handle a wide variety of graphical visualizations, and it is general enough that new object flavors can be smoothly integrated in the future.

This paper describes a system for automatically producing complete compiler front ends from simple, nonprocedural specifications of the source language. This system is based on a detailed model of a compiler front end that is presented first. The system itself is then described using a Pascal subset as an example. This work was part of a larger project aimed at producing complete compilers in a similar fashion.

This paper describes the PECAN family of program development systems. PECAN supports multiple views of the user's 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.

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 confidentiality of the original data, while providing microdata with accurate statistics. Methods for achieving such transformations are considered and analyzed through simulation.

Compiler symbol processing has become complex as programming languages have evolved.In this paper we describe a comprehensive model of symbol processing, and a system that uses this model to generate the symbol processing portions of a compiler from simple specifications.The model supports a variety of entities with different types of names.It includes a detailed view of scoping.It provides a simple picture of the complex mapping from a source token to a specific entity.The model is illustrated with examples from Ada.The system is divided into two parts.The first takes a nonprocedural description of the semantics of symbols in the language and produces a symbol table module for a compiler for that language.The second supports a simple symbol processing language that allows the easy connection of syntax and semantic processing to the symbol module.

Article Free Access Share on Non-reversible privacy transformations Authors: Steven P. Reiss Brown University, Providence, RI Brown University, Providence, RIView Profile , Mark J. Post Brown University, Providence, RI Brown University, Providence, RIView Profile , Tore Dalenius Brown University, Providence, RI Brown University, Providence, RIView Profile Authors Info & Claims PODS '82: Proceedings of the 1st ACM SIGACT-SIGMOD symposium on Principles of database systemsMarch 1982 Pages 139–146https://doi.org/10.1145/588111.588134Online:29 March 1982Publication History 14citation288DownloadsMetricsTotal Citations14Total Downloads288Last 12 Months7Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

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.

Security ~s considered m the context of an abstract model of a database where queries revolving the mean or medmn of a pnvdeged field are allowed For this model, the method of lumtmg the number and types of quenes that can be asked of such a database is constdered as a means for providmg statistical access whale insuring that no mdlwdual data are compromised The resultant questions are primarily combinatorial m nature and are mterestmg m themselves KEY WORDS AND PHRASES statistical database, data security,