Search

Software developers must often replace existing components in their systems to adapt to evolving environments or tooling. While traditional code search systems are effective at retrieving components with related functionality, it is much more challenging to retrieve components that can be used to directly replace existing functionality, as replacements must account for more fundamental program properties such as type compatibility. To address this problem, I built ClassFinder, a system which given a query class Q, and a search corpus S, returns a ranked subset of classes that can replace Q and its functionality. The tool has shown promising results and is able to find replacement classes from a search corpus containing ~600 thousand open source Java classes. More details on ClassFinder will be available soon!

Analyze

Analyzing third party code imported by a program for software bugs, memory bloats, execution bottle necks, security threats is important. It enables the developer to understand if their program may have accidentally imported defects and enables them to address the defect. I have worked on building analyses, that can expose concurrency bugs in third party libraries. Concurrency bugs can be immensely disruptive and can cause unexpected program behaviors such as deadlocks, atomicity violations, data races, program crashes etc in multi-threaded programs. In some cases, these bugs have manifested in safety critical systems costing human lives. A multi-threaded program may accidentally import a concurrency bug by accessing a third party library that contains such defects. In such cases, the program will need additional synchronization mechanisms to avoid these bugs, which requires a clear understanding of the bugs present in the library. Concrete tests that expose the defects in the library are useful to understand the defects. I built a suite of tools that can synthesize multi-threaded tests that expose various concurrency defects. Check out Omen+ (OOPSLA'14), Narada (PLDI'15), Intruder (FSE'15) and Minion (OOPSLA'16) for more details.

Replace

Manually updating the application to use a different library can be cumbersome and error prone. For example, even when library versions are updated, backward compatibility is not always maintained. Ensuring that the behavior of the application is unchanged can become non-trivial because an existing class in the library can differ from the chosen replacement class in the new library across multiple dimensions – internal data representation, signatures of the provided interfaces, or the underlying functionality offered by these interfaces. This motivates the need for a technique that can synthesize an adapter class for a given replacement class so that the synthesized class is equivalent to the existing class. I built MASK (POPL'20) to address this challenge. Mask employs static analysis, constraint solving and sketch based synthesis to construct adapter class, given the original class O and replacement R.