In this paper, we propose a method to help users avoid bugs in GUI applications. In particular, users would use the application normally and report bugs that they encounter to prevent anyone -- including themselves -- from encountering those bugs again. When a user attempts an action that has led to problems in the past, he/she will receive a warning and will be given the opportunity to abort the action -- thus avoiding the bug altogether and keeping the application stable. Of course, bugs should be fixed eventually by the application developers, but our approach allows application users to collaboratively help each other avoid bugs -- thus making the application more usable in the meantime. We demonstrate this approach using our "Stabilizer" prototype. We also include a preliminary evaluation of the Stabilizer's bug prediction.

We propose an approach to design recovery of real-time graphical applications - such as flight simulators and games - that uses video to link lower-level code events with their higher-level graphical manifestations. Such a link can be used for both top-down and bottom-up design recovery. Top-down, one can identify an interesting visual event in the video and then see which lower-level code event(s) are responsible for it. Bottom-up, one can explain code of interest by seeing the sorts of high-level visual events in the video to which that code corresponds. The link between low-level code events and high-level visual events can be established by inspection or through an automated technique. As an example of the latter, clicking on a falling creature in the video would yield code specific to the falling creature - excluding irrelevant code from other walking/climbing creatures at that same moment in the video. We shall demonstrate by example how our design recovery method sheds light on the design of real-time graphical applications.

Nowadays, the majority of productivity applications are interactive and graphical in nature. In this demonstration, we explore the possibility of taking advantage of these two characteristics in a design recovery tool. Specifically, the fact that an application is interactive means that we can identify distinct execution bursts corresponding closely to "actions" performed by the user. The fact that the application is graphical means that we can describe those actions visually from a fragment of the application display itself. Combining these two ideas, we obtain an explicit mapping from high-level actions performed by a user (similar to use case scenarios/specification fragments) to their low-level implementation. This mapping can be used for design recovery of interactive graphical applications. We demonstrate our approach using L/sub Y/X, a scientific word processor.

Nowadays, the majority of productivity applications are interactive and graphical in nature. In this paper, we explore the possibility of taking advantage of these two characteristics in a design recovery tool. Specifically, the fact that an application is interactive means that we can identify distinct execution bursts corresponding closely to "actions" performed by the user The fact that the application is graphical means that we can describe those actions visually from a fragment of the application display itself. Combining these two ideas, we obtain an explicit mapping from high-level actions performed by a user (similar to use case scenarios/specification fragments) to their low-level implementation. This mapping can be used for design recovery of interactive graphical applications. We demonstrate our approach using L/sub Y/X, a scientific word processor.

Nowadays, applications are typically written using an object-oriented GUI framework. In this paper we explore the possibility of using the GUI of such applications to guide browsing and search of their source code. Such a tool would be helpful for software maintenance and reuse, particularly when the application source is unfamiliar. Intuitively, we would expect the task of browsing and searching source code of an application written using a GUI framework to be easier than one that doesn't because the GUI framework imposes a structure on the application. Generally, the GUI framework is in control and makes calls into the application code to handle various events --- thus providing fundamental entry points into the application code, namely the callbacks. Of course, this is a property of frameworks in general but GUI frameworks have one additional advantage: the GUI is visible to the end-user and contains text messages describing what the application can do. Thus we have an explicit connection between an informal specification fragment visible in the GUI and its precise entry point to the implementation in the source. We demonstrate our approach, which takes advantage of this connection, on KDE applications written using the KDE GUI framework.

Developers learn to use a software library not just from its documentation but also from toy examples and existing real-life application code (e.g. by using grep). The CodeWeb tool takes this simple idea further by a deeper analysis of a large collection of applications to see what characteristic usage of the library is like. We demonstrate the tool by showing how the KDE core libraries are used in real-life KDE applications (KDE is a graphical desktop environment for UNIX). Moreover, we look at a recently-developed feature that helps software developers port an application from an old version of a library to a new one.

CVSSearch is a tool that searches for fragments of source code by using CVS comments. CVS is a version control system that is widely used in the open source community. Our search tool takes advantage of the fact that a CVS comment typically describes the lines of code involved in the commit and this description will typically hold for many future versions. In other words, CVSSearch allows one to better search the most recent version of the code by looking at previous versions to better understand the current version. In this paper we describe our algorithm for mapping CVS comments to the corresponding source code, present a search tool based on this technique, and discuss preliminary feedback.

In this paper, we show how data mining can be used to discover library reuse patterns in existing applications. Specifically, we consider the problem of discovering library classes and member functions that are typically reused in combination by application classes. This paper improves upon our earlier research using “association rules” [8] by taking into account the inheritance hierarchy using “generalized association rules”. This turns out to be a non-trivial but worthwhile endeavor.

Comparing and contrasting a set of software libraries is useful for reuse related activities such as selecting a library from among several candidates or porting an application from one library to another.The current state of the art in assessing libraries relies on qualitative methods.To reduce costs and/or assess a large collection of libraries, automation is necessary.Although there are tools that help a developer examine an individual library in terms of architecture, style, etc., we know of no tools that help the developer directly compare several libraries.With existing tools, the user must manually integrate the knowledge learned about each library.Automation to help developers directly compare and contrast libraries requires matching of similar components (such as classes and functions) across libraries.This is different than the traditional component retrieval problem in which components are returned that best match a user's query.Rather, we need to find those components that are similar across the libraries under consideration.In this paper, we show how this kind of matching can be done.

In this paper, we show how data mining can be used to discover library reuse patterns in user-selected applications. This can be helpful in building and debugging applications that use a particular library by observing how other developers have used that library in their applications. Specifically, we consider the problem of discovering association rules that identify library components that are often reused in combination by application components. For example, such a rule might tell us that application classes that inherit from a particular library class often override certain member functions. By querying and/or browsing such association rules, a developer can discover patterns for reusing library components. We illustrate the approach using our tool, CodeWeb, by demonstrating characteristic ways in which applications reuse components in the ET++ application framework.

The authors present a tool-based approach that examines how example programs reuse a particular library. The approach can facilitate reuse by: (1) guiding the developer towards important library classes of general utility; (2) guiding the developer towards library classes particularly useful for a specific application domain; and (3) providing access to the relevant source code in each example for further inspection. The approach is supported by CodeWeb, a reuse tool they have built for C++ and Java libraries.