Myoungkyu Song

Interactive code review for systematic changes

Developers often inspect a diff patch during peer code reviews. Diff patches show low-level program differences per file without summarizing systematic changes -- similar, related changes to multiple contexts. We present Critics, an interactive approach for inspecting systematic changes. When a developer specifies code change within a diff patch, Critics allows developers to customize the change template by iteratively generalizing change content and context. By matching a generalized template against the codebase, it summarizes similar changes and detects potential mistakes. We evaluated Critics using two methods. First, we conducted a user study at Salesforce.com, where professional engineers used Critics to investigate diff patches authored by their own team. After using Critics, all six participants indicated that they would like Critics to be integrated into their current code review environment. This also attests to the fact that Critics scales to an industry-scale project and can be easily adopted by professional engineers. Second, we conducted a user study where twelve participants reviewed diff patches using Critics and Eclipse diff. The results show that human subjects using Critics answer questions about systematic changes 47.3% more correctly with 31.9% saving in time during code review tasks, in comparison to the baseline use of Eclipse diff. These results show that Critics should improve developer productivity in inspecting systematic changes during peer code reviews.

Metadata invariants: checking and inferring metadata coding conventions

As the prevailing programming model of enterprise applications is becoming more declarative, programmers are spending an increasing amount of their time and efforts writing and maintaining metadata, such as XML or annotations. Although metadata is a cornerstone of modern software, automatic bug finding tools cannot ensure that metadata maintains its correctness during refactoring and enhancement. To address this shortcoming, this paper presents metadata invariants, a new abstraction that codifies various naming and typing relationships between metadata and the main source code of a program. We reify this abstraction as a domain-specific language. We also introduce algorithms to infer likely metadata invariants and to apply them to check metadata correctness in the presence of program evolution. We demonstrate how metadata invariant checking can help ensure that metadata remains consistent and correct during program evolution; it finds metadata-related inconsistencies and recommends how they should be corrected. Similar to static bug finding tools, a metadata invariant checker identifies metadata-related bugs as a program is being refactored and enhanced. Because metadata is omnipresent in modern software applications, our approach can help ensure the overall consistency and correctness of software as it evolves.

Reusable enterprise metadata with pattern-based structural expressions

An essential part of modern enterprise software development is metadata. Mainstream metadata formats, including XML deployment descriptors and Java 5 annotations, suffer from a number of limitations that complicate the development and maintenance of enterprise applications. Their key problem is that they make it impossible to reuse metadata specifications not only across different applications but even across smaller program constructs such as classes or methods. To provide better enterprise metadata, we present pattern-based structural expressions (PBSE), a novel metadata representation that offers conciseness and maintainability advantages and is reusable. To apply PBSE to enterprise applications, we translate PBSE specifications to Java annotations, with annotating classes automatically as an intermediate build step. We demonstrate the advantages of the new metadata format by assessing its conciseness and reusability, as compared to XML and annotations, in the task of expressing metadata of J2EE reference applications and a mid-size, commercial, enterprise application.

Enhancing source-level programming tools with an awareness of transparent program transformations

Programs written in managed languages are compiled to a platform-independent intermediate representation, such as Java bytecode. The relative high level of Java bytecode has engendered a widespread practice of changing the bytecode directly, without modifying the maintained version of the source code. This practice, called bytecode engineering or enhancement, has become indispensable in introducing various concerns, including persistence, distribution, and security, transparently. For example, transparent persistence architectures help avoid the entanglement of business and persistence logic in the source code by changing the bytecode directly to synchronize objects with stable storage. With functionality added directly at the bytecode level, the source code reflects only partial semantics of the program. Specifically, the programmer can neither ascertain the programs runtime behavior by browsing its source code, nor map the runtime behavior back to the original source code. This paper presents an approach that improves the utility of source-level programming tools by providing enhancement specifications written in a domain-specific language. By interpreting the specifications, a source-level programming tool can gain an awareness of the bytecode enhancements and improve its precision and usability. We demonstrate the applicability of our approach by making a source code editor and a symbolic debugger enhancements-aware.

RefDistiller: a refactoring aware code review tool for inspecting manual refactoring edits

Manual refactoring edits are error prone, as refactoring requires developers to coordinate related transformations and understand the complex inter-relationship between affected types, methods, and variables. We present RefDistiller, a refactoring-aware code review tool that can help developers detect potential behavioral changes in manual refactoring edits. It first detects the types and locations of refactoring edits by comparing two program versions. Based on the reconstructed refactoring information, it then detects potential anomalies in refactoring edits using two techniques: (1) a template-based checker for detecting missing edits and (2) a refactoring separator for detecting extra edits that may change a programs behavior. By helping developers be aware of deviations from pure refactoring edits, RefDistiller can help developers have high confidence about the correctness of manual refactoring edits. RefDistiller is available as an Eclipse plug-in at https://sites.google.com/site/refdistiller/ and its demonstration video is available at http://youtu.be/0Iseoc5HRpU.

Reusing non-functional concerns across languages

Emerging languages are often source-to-source compiled to mainstream ones, which offer standardized, fine-tuned implementations of non-functional concerns (NFCs)-including persistence, security, transactions, and testing. Because these NFCs are specified through metadata such as XML configuration files, compiling an emerging language to a mainstream one does not include NFC implementations. Unable to access the mainstream languages NFC implementations, emerging language programmers waste development effort reimplementing NFCs. In this paper, we present a novel approach to reusing NFC implementations across languages by automatically translating metadata. To add an NFC to an emerging language program, the programmer declares metadata, which is then translated to reuse the specified NFC implementation in the source-to-source compiled mainstream target language program. By automatically translating metadata, our approach eliminates the need to reimplement NFCs in the emerging language. As a validation, we add unit testing and transparent persistence to X10 by reusing implementations of these NFCs in Java and C++, the X10 backend compilation targets. The reused persistence NFC is efficient and scalable, making it possible to checkpoint and migrate processes, as demonstrated through experiments with third-party X10 programs. These results indicate that our approach can effectively reuse NFC implementations across languages, thus saving development effort.

Dynamic Software Updates for Accelerating Scientific Discovery

Distributed parallel applications often run for hours or even days before arriving to a result. In the case of such long-running programs, the initial requirements could change after the program has started executing. To shorten the time it takes to arrive to a result when running a distributed computationally-intensive application, this paper proposes leveraging the power and flexibility of dynamic software updates. In particular, to enable flexible dynamic software updates, we introduce a novel binary rewriting approach that is more efficient than the existing techniques. While ensuring greater flexibility in enhancing a running program for new requirements, our binary rewriting technique incurs only negligible performance overhead. We validate our approach via a case study of dynamically changing a parallel scientific simulation.

Reusing metadata across components, applications, and languages

Among the well-known means to increase programmer productivity and decrease development effort is systematic software reuse. Although large scale reuse remains an elusive goal, programmers have been successfully reusing individual software artifacts, including components, libraries, and specifications. One software artifact that is not amenable to reuse is metadata, which has become an essential part of modern software development. Specifically, mainstream metadata formats, including XML and Java 5 annotations, are not amenable to systematic reuse. As a result, software that uses metadata cannot fully reap the benefits traditionally associated with systematic reuse. To address this lack of metadata reusability, this article presents Pattern-Based Structural Expressions (PBSE), a new metadata format that is not only reusable, but also offers conciseness and maintainability advantages. PBSE can be reused both across individual program components and across entire applications. In addition, PBSE make it possible to reuse metadata-expressed functionality across languages. In particular, we show how implementations of non-functional concerns (commonly expressed through metadata) in existing languages can be reused in emerging languages via automated metadata translation. Because metadata constitutes an intrinsic part of modern software applications, the ability to systematically reuse metadata is essential for improving programmer productivity and decreasing development effort. We discuss the advantages and shortcomings of mainstream metadata formats.We present a metadata format that is reusable across applications and languages.We present an approach to reuse non-functional concerns during cross-compilation.We present a DSL for declaratively expressing differences between metadata formats.We enable the X10 language to reuse persistence and unit testing in Java and C++.

Tool Support for Managing Clone Refactorings to Facilitate Code Review in Evolving Software

Developers often perform copy-and-paste activities. This practice causes the similar code fragment (aka code clones) to be scattered throughout a code base. Refactoring for clone removal is beneficial, preventing clones from having negative effects on software quality, such as hidden bug propagation and unintentional inconsistent changes. However, recent research has provided evidence that factoring out clones is not always to reduce the risk of introducing defects, and it is often difficult or impossible to remove clones using standard refactoring techniques. To investigate which or how clones can be refactored, developers typically spend a significant amount of their time managing individual clone instances or clone groups scattered across a large code base. To address the problem, this paper presents a technique for managing clone refactorings, Pattern-based clone Refactoring Inspection (PRI), using refactoring pattern templates. By matching the refactoring pattern templates against a code base, it summarizes refactoring changes of clones, and detects the clone instances not consistently factored out as potential anomalies. PRI also provides novel visualization user interfaces specifically designed for inspecting clone refactorings. In the evaluation, PRI analyzes clone instances in six open source projects. It identifies clone refactorings with 94.1% accuracy and detects inconsistent refactorings with 98.4% accuracy. Our results show that PRI should help developers effectively inspect evolving clones and correctly apply refactorings to clone groups.

Refactoring Inspection Support for Manual Refactoring Edits

Refactoring is commonly performed manually, supported by regression testing, which serves as a safety net to provide confidence on the edits performed. However, inadequate test suites may prevent developers from initiating or performing refactorings. We propose RefDistiller, a static analysis approach to support the inspection of manual refactorings. It combines two techniques. First, it applies predefined templates to identify potential missed edits during manual refactoring. Second, it leverages an automated refactoring engine to identify extra edits that might be incorrect. RefDistiller also helps determine the root cause of detected anomalies. In our evaluation, RefDistiller identifies 97 percent of seeded anomalies, of which 24 percent are not detected by generated test suites. Compared to running existing regression test suites, it detects 22 times more anomalies, with 94 percent precision on average. In a study with 15 professional developers, the participants inspected problematic refactorings with RefDistiller versus testing only. With RefDistiller, participants located 90 percent of the seeded anomalies, while they located only 13 percent with testing. The results show RefDistiller can help check the correctness of manual refactorings.