Daqing Hou

Using SCL to specify and check design intent in source code

Software developers often fail to respect the intentions of designers due to missing or ignored documentation of design intent. SCL (Structural Constraint Language) addresses this problem by enabling designers to formalize and confirm compliance with design intent. The designer expresses his intent as constraints on the program model using the SCL language. The SCL conformance checking tool examines developer code to confirm that the code honors these constraints. This paper presents the design of the SCL language and its checker, a set of practical examples of applying SCL, and our experience with using it both in an industrial setting and on open-source software

CReN: a tool for tracking copy-and-paste code clones and renaming identifiers consistently in the IDE

Programmers often copy and paste code so that they can reuse the existing code to complete a similar task. Many times, modifications to the newly pasted code include renaming all instances of an identifier, such as a variable name, consistently throughout the fragment. When these modifications are done manually, undetected inconsistencies and errors can result in the code, for example, a single instance can be missed and mistakenly not renamed. To help programmers avoid making this type of copy-paste error, we created a tool, named CReN, to provide tracking and identifier renaming support within copy-and-paste clones in an integrated development environment (IDE). CReN tracks the code clones involved when copying and pasting occurs in the IDE and infers a set of rules based on the relationships between the identifiers in these code fragments. These rules capture the programmers intentions, for example, that a particular group of identifiers should be renamed consistently together. Programmers can also provide feedback to improve the accuracy of the inferred rules by specifying that a particular instance of an identifier is to be renamed separately. We introduce our CReN tool, which is implemented as an Eclipse plug-in in Java.

An evaluation of the strategies of sorting, filtering, and grouping API methods for Code Completion

Code Completion is one of the most popular IDE features for accessing APIs, freeing programmers from remembering specific details about an API and reducing keystrokes. We propose three ways to enhance the current code-completion systems to work more effectively with large APIs. First, we propose two methods for sorting APIs, by type hierarchy and by use count, and show that their use significantly reduces the number of API proposals a user must navigate while using Code Completion. Second, we show that context-specific filtering of inappropriate proposals can also reduce the number of proposals a user must navigate. Third, we propose to group API proposals by their functional roles, which can help maintain a well-ordered, meaningful list of API proposals in the presence of dynamic reordering. These functionalities are grouped into a research prototype, BCC (Better Code Completion). We evaluated fourteen configurations of BCC by simulating Code Completion nearly three million times on nine open-source Java projects that utilize AWT/Swing.

What can programmer questions tell us about frameworks

In order to make frameworks easier to use we need to better understand the difficulties that programmers have with them. The questions that programmers ask give clues to the quality of design, documentation, and programmer practice. We describe the method and results of a study on the Java Swing framework. We collected and analyzed a sample of 300 newsgroup questions asked about two Swing components (JButton and JTree), and classified the questions according to the design features of the components. This process revealed key insights that can improve a frameworks design, its tutorials, and programmer practice.

CnP: Towards an environment for the proactive management of copy-and-paste programming

Programmers copy and paste code for many reasons. Regardless of the specific reasons, similar code fragments (clones) are introduced into software systems. Like other software artifacts, clones may require attention and effort from programmers so that they can be understood, and correctly adapted and evolved. More specifically, when understanding and maintaining clones, programmers need to know where the clones are. Programmers also need to compare and contrast code clones in order to figure out how they correspond and differ. Finally, they also need to edit or remove clones. In addition to what clone detection-based tools can offer, more automated support is needed to better assist programmers in these activities. In this paper, we introduce a toolkit CnP that is aimed to support and manage clones proactively as they are created and evolved. We describe the initial features and the design decisions taken in CnP. We also discuss possible future design extensions.

Shared research dataset to support development of keystroke authentication

Keystroke authentication can help significantly improve computer security by hardening passwords or offering active, continuous authentication. Over the years, many keystroke authentication algorithms have been reported to produce promising results. However, these results are tested on proprietary datasets with varying numbers of subjects and amounts of text, making it difficult to compare and improve the state of art. We describe a new dataset that we have developed with the goal to serve as a shared common testbed to enable future improvements. The new dataset includes keystroke data for short pass-phrases, fixed text (transcription of long proses), and free text. It also includes video of a subjects facial expression and hand movement during the data collection sessions, allowing for a deeper understanding of why an algorithm works the way it does, for example, by finding out whether a subject is a touchtypist or not. As a baseline for benchmarking, we also include the results of replicating two existing algorithms using the new dataset.

CSCC: Simple, Efficient, Context Sensitive Code Completion

Code Completion helps developers learn APIs and frees them from remembering every detail. In this paper, we describe a novel technique called CSCC (Context Sensitive Code Completion) for improving the performance of API method call completion. CSCC is context sensitive in that it uses new sources of information as the context of a target method call. CSCC indexes method calls in code examples by their contexts. To recommend completion proposals, CSCC ranks candidate methods by the similarities between their contexts and the context of the target call. Evaluation using a set of subject systems and five popular state of-the-art techniques suggests that CSCC performs better than existing type or example-based code completion systems. We also investigate how the different contextual elements of the target call benefit CSCC.

Exploring the Intent behind API Evolution: A Case Study

Reuse has significantly improved software productivity and quality. An application interacts with a reused system through its Application Programming Interfaces (API). To make the life of the application developer easier, it is desirable for the API to be both sufficiently powerful and stable. Unfortunately, in reality APIs inevitably change, to be more powerful or to remove design flaws. This may create additional work for the application developer to adapt to the changed API. Thus, to counter the negative impacts of API evolution, we need to study how and why APIs are evolved. To that end, we performed a detailed analysis of the evolution of a production API. In particular, we categorized the changes to the API according to its domain semantics and design intent. We discussed the implications of our findings for both API designers and application developers.

Extracting problematic API features from forum discussions

Software engineering activities often produce large amounts of unstructured data. Useful information can be extracted from such data to facilitate software development activities, such as bug reports management and documentation provision. Online forums, in particular, contain extensive valuable information that can aid in software development. However, no work has been done to extract problematic API features from online forums. In this paper, we investigate ways to extract problematic API features that are discussed as a source of difficulty in each thread, using natural language processing and sentiment analysis techniques. Based on a preliminary manual analysis of the content of a discussion thread and a categorization of the role of each sentence therein, we decide to focus on a negative sentiment sentence and its close neighbors as a unit for extracting API features. We evaluate a set of candidate solutions by comparing tool-extracted problematic API design features with manually produced golden test data. Our best solution yields a precision of 89%. We have also investigated three potential applications for our feature extraction solution: (i) highlighting the negative sentence and its neighbors to help illustrate the main API feature; (ii) searching helpful online information using the extracted API feature as a query; (iii) summarizing the problematic features to reveal the “hot topics” in a forum.

Towards a better code completion system by API grouping, filtering, and popularity-based ranking

Nowadays, programmers spend much of their workday dealing with code libraries and frameworks that are bloated with APIs. One common way of interacting with APIs is through Code Completion inside the code editor. By default, Code Completion presents in a popup pane, in alphabetical order or by relevance, all accessible members available in the apparent type and supertypes of a receiver expression. This default behavior for Code Completion should and can be further improved because (1) not all public methods are APIs and presenting non-API public members to a programmer is misleading, (2) certain APIs are meant to be accessible only in some limited contexts but not others, (3) the alphabetical order separates otherwise logically related APIs, making it hard to see their connection and to work with, and (4) commonly used APIs are often presented long after much less used APIs due to suboptimal API sorting strategies. BCC (Better Code Completion) addresses these problems by enhancing Code Completion so that programmers can control how specific API elements should be sorted, filtered, and grouped. We report our preliminary validation results from testing BCC with Java projects that make use of the AWT/Swing APIs. For one large project, the BCC approach reduces by over ninety percent the total number of APIs that a programmer would have to scroll through using Eclipses Code Completion before settling on the desired ones.