|Extension of existing software often
requires systematic and pervasive edits—programmers apply similar,
but not identical, enhancements, refactorings, and bug fixes to many
similar methods. The vision of this research is to produce
a novel example-based program transformation approach. Our key
insight is that by learning abstraction transformation from
examples, we can automate systematic edits in a flexible and
easy-to-use manner. In our evaluation of real world bug fixes, our
approach LASE found fix locations with 99% precision, 89% recall,
and applied fixes with 91% correctness. It also fixed
locations missed by human developers, correcting errors of
This project is sponsored by National Science Foundation CAREER Award CCF-1149391: Analysis and Automation of Systematic Software Modifications.
Keywords: Code Transformation; Refactoring; Static and Dynamic Analysis; Experimental Evaluation
software development, developers need to analyze past and present
software modifications made by other programmers in various tasks
such as carrying out a peer code reviews, bug investigations, and
change impact analysis. CHIME project addresses the following
fundamental questions about software modifications: (1) what is a
concise and explicit representation of a program change? (2)
how do we automatically extract the differences between two program
versions into meaningful high-level representations? (3) How can
we significantly improve developer productivity in
investigating, searching, and monitoring software modifications
made by other developers?
This CHIME project is sponsored by National Science Foundation Grant CCF-1117902: Analytical Support for Investigating Software Modifications in Collaborative Development Environment.
Keywords: Program Differencing; Code Change Analysis; Empirical Studies; Mining Software Archives; Collaborative Software Development
Software is rarely written from scratch. Refactoring is a technique that is used for cleaning up legacy code or as a preparation for bug fixes or feature additions. Modern integrated development environments now ship with built-in refactoring support to automate refactoring.
By performing survey and interviews with professional engineers
and by analyzing software version histories, we study the
characteristics of real-world refactorings. Our study finds that
real-world refactorings are not necessarily behavior preserving
and they are beyond the scope and capability of existing
refactoring engines. Real-world refactorings are often done
manually and error-prone. Developers perceive that refactoring can
be risky and they have a hard time justifying refactoring
investments due to the difficulty of assessing refactoring
benefits. Our goal is to design pragmatic techniques to help
developers have a high confidence about carrying out real world
refactoring. We are currently designing analysis algorithms that
support refactoring-aware code reviews and an approach that
monitors and assesses the impact of real world refactoring.
The nature of systems that intertwine the cyber and the physical demands completely new approaches to developing robust, reliable, and verified software, hardware, and physical components jointly. In this project, we aim to make fundamental advances by creating a new assertion-driven approach for developing and debugging cyber-physical systems. As opposed to traditional uses of assertions in software engineering, our approach is unique in that we use mathematical models of physical phenomena to guide creation of assertions, to identify inconsistent or infeasible assertions, and to localize potential causes for CPS failures. Our goal is to produce methods and tools that facilitate the active use of physical models, which have existed for centuries, for verifying cyber-physical systems.This BRACE project is sponsored by National Science Foundation Grant CNS-1239498 CPS: Synergy: Physically-Informed Assertions for CPS Development and Debugging.
|It has been long believed that
duplicated code fragments indicate poor software quality and
factoring out the commonality among them improves software quality;
thus, previous studies focused on measuring the percentage of code
clones and interpreted a large (or increasing) number as an
indicator for poor quality. On the other hand, we investigated how
and why duplicated code is actually created and maintained using two
empirical analyses. we used an edit capture and replay approach to
gather insights into copy and paste programming practices. To extend
this type of change-centric analysis to programs without edit logs,
we developed a clone genealogy analysis that tracks individual
clones over multiple versions. By focusing on how code clones
actually evolve, we found that clones are not inherently bad and
that we need better support for managing clones.
Keywords: Code Duplication; Software Forking; Software Reuse