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, and on implmenting a live programming facility for real Java programs. See also the Code Bubbles web pages.
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.
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.
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.
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.
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.