Steven P. Reiss


My research covers a broad swath of software engineering, but concentrates on developing practical solutions that scale for the real problems programmers have.  Much of this work has involved integrated development environments and other programming tools.  Many of these tools and enviroments have used software visualization in various ways.  More recently, we have been looking at how new technologies such as code search, automatic bug repair, and program modeling can be used to assist the programmer.  My current and recent research projects are listed below.  If you are interested in working on any of these, I maintain a list of potential student projects (Brown internal only) and you can contact me via email.  

Integrated Development Environments and Tools

We have a long history of developing programming environments and the accompanying tools and techniques. Our recent efforts center around the Code Bubbles environment. Code Bubbles is an effort to provide a better, working-set centric, user interface for programming. It lets the user easily view the variety of software artifacts that are relevant to their current task at the same time on the same screen. It provides powerful and efficient navigation facilities and a variety of software visualizations. Recent work within the environment has looked at automatically correcting problems as the user edits, implmenting a live programming facility for real Java programs, an abstract-interpretation based flow analysis for security checking that updates as the user types, and a quick-fix facility for correcting semantic errors while debugging. See also the Code Bubbles web pages.

Applications of Code Search

Our work in this area attempts to provide practical interfaces to large code repositories such as GitHub that are capable of returning useful code that meets the programmer's needs.  While the searches are inherently keyword-based (due to the underlying search engines), we provide filters that restrict the output based on the semantics the programmer specifies.  Our initial effort, S6, used test cases for the semantics specification of functions.  Later efforts used sketches for finding user interfaces.  We are currently working on retrieiving larger  blocks of code using a variety of semantics.

Practical Automatic Bug Repair

Using our experience in code search and environments, we have been looking at automatic bug repair.  Our efforts to date have looked into doing fault localization and then using code search to find code that is similar to that of the fault.  The differences between the retrieved code and the buggy code are then used to suggest patches which are then validated using the test suite.  Our current work looks at integrating automatic bug repair into a development environment and using alternative ways of checking correctness.              

Internet of Things

Using our experience teaching the real time and embedded software course, we have started working on software engineering for the Internet of Things.  Our efforts here have concentrated on developing user interfaces for controlling multiple devices.  This can be seen in our status update which is done automatically based on a set of sensors and a set of rules.

Performance Analysis

Understanding and predicting the performance of applications can be important.  We have developed a variety of tools for this purpose, both stand alone and integrated into our development environments.  Our most recent efforts looked at getting information from a single sample run of a system, building a system model, and then predicting the system's behavior under different circumstances such as additional processors, different sized thread pools, or different disk models.       

Software Visualization

We have a long history of software visualization and incorporating visualization tools into our development environments.  Our original efforts concentrated on understanding the structure of software systems. We then switched to the more difficult problem of understanding the dynamics of complex systems, first after the fact (using traces), and then while the system is running.  While we continue to produce software visualizations and visual interfaces to software tools, we no longer consider ourselves working actively in the area.  We have concluded that getting the right data (and getting it efficiently) is more important that the actual visualization.  Moreover, there is a mismatch between the general visualizations that the tools in this area produce and the very specific problems that programmers have where visualizations could be useful.                    

Last updated: September 22, 2022