I am a software engineer at Google, working on programming tools. I recently completed my Ph.D. in the Department of Computer Science at Tufts University. My advisor was Sam Guyer, and I was part of the RedLine Research Group.
I am interested in modern language runtimes, such as the Java Virtual Machine. These runtimes are immensely complicated, providing advanced services such as JIT compilation, dynamic optimization, garbage collection, concurrency management, and dynamic classloading. These features improve programmer productivity at the expense of transparency; because the JVM can transform the programmer's code in unexpected ways, it becomes very difficult to predict the performance and correctness properties of the program. In addition, these features encourage the creation of ever-larger programs, making it increasingly difficult for any one person to understand a large project.
My research focuses on providing tools to help programmers better understand their programs. One of my projects leverages the garbage collector in a Java virtual machine to check programmer-provided heap assertions at low cost. Another project provides a visualization tool that can display the contents of the heap in a running Java program. This tool uses a novel summarization algorithm to reduce the complexity of the heap graph, and it provides an interactive interface that allows the user to explore the heap graph from a bird's-eye view down to an individual object and its field values.
Please wait while my tweets load
For my publications, please see this list.
error-prone is a Java static analysis tool in the vein of FindBugs. It looks for bug patterns in Java source code and reports errors to the user along with suggested fixes. It is implemented on top of the OpenJDK javac compiler, making it easy to integrate with build systems such as Ant and Maven and ensuring that it handles all valid Java language constructs. error-prone is used for all Java compilations at Google, and we use the suggested fix mechanism to automatically repair existing bugs before we turn on a new bug check. Our SCAM 2012 paper describes error-prone along with two other static analysis tools in use at Google.
Strobe is a system that allows heavyweight assertions, such as heap assertions or contract checks, to be checked asynchronously while the program continues to execute. Our technique guarantees that asynchronous evaluation always produces the same result as synchronous evaluation, even if the program concurrently modifies the program state. The checking threads evaluate each assertion on a consistent snapshot of the program state as it existed at the moment the assertion started. Strobe provides tolerable overheads—often in the range of 10% to 40% over no checking at all—even for heavyweight assertions that would otherwise result in crushing slowdowns. In addition, as additional cores are added, Strobe scales almost perfectly over synchronous checking in most cases.
Heapviz is a tool for visualizing and exploring snapshots of the heap obtained from running Java programs. Unlike existing tools, such as traditional debuggers, Heapviz presents a global view of the program state as a graph, together with powerful interactive capabilities for navigating it. Our tool employs several key techniques that help manage the scale of the data. First, we reduce the size and complexity of the graph by using algorithms inspired by static shape analysis to aggregate the nodes that make up a data structure. Second, we introduce a dominator-based layout scheme that emphasizes hierarchical containment and ownership relations. Finally, the interactive interface allows the user to expand and contract regions of the heap to modulate data structure detail, inspect individual objects and field values, and search for objects based on type or connectivity.
DeAL is a programming language for heap assertions that are efficiently evaluated during garbage collection time. DeAL is a rich, declarative, logic-based language whose programs are guaranteed to be executable with good whole-heap locality, i.e., within a single traversal over every live object on the heap and a finite neighborhood around each object. As a result, evaluating DeAL programs incurs negligible cost: for simple assertion checking at each garbage collection, the end-to-end execution slowdown is below 2%.
GC Assertions is a system interface that programmers can use to check for errors, such as data structure invariant violations, and to diagnose performance problems, such as memory leaks. GC assertions are checked by the garbage collector, which is in a unique position to gather information and answer questions about the lifetime and connectivity of objects in the heap. By piggybacking on existing garbage collector computations, our system is able to check heap properties with very low overhead -- around 3% of total execution time -- low enough for use in a deployed setting.
I have been a teaching assistant for the following courses while at Tufts:
- Computer Security (Spring 2006)
- Computer Architecture (Fall 2005)
- Theory of Computation (Summer 2005)
- Senior Software Engineering Project (Spring 2005)
- Readings in Component-Based Software Engineering (Spring 2005)
- Introduction to Programming with Components (Fall 2004)
- RedLine Research Group: The systems research group at Tufts.
- DaCapo Research Group: A larger research group that we are a part of. Focuses on performance issues in object-oriented languages.
- DaCapo Benchmarks: A set of Java benchmarks produced by the DaCapo group.
- Jikes RVM: An open source Java virtual machine that I use in my research.
I am a slow, but somewhat serious runner. I ran the Boston Marathon in 2009 and 2010 with the Tufts President's Marathon Challenge team and the 2010 Philadelphia Marathon with friends. I have also run two half marathons, two 200-mile relay races, and many shorter races. Most recently, I captained the 9th place team (out of 150) for the inaugural Reach the Beach Massachusetts 200-mile relay race.