Relevant Degree Programs
Graduate Student Supervision
Doctoral Student Supervision (Jan 2008 - Nov 2019)
Because software so often behaves unexpectedly or fails only in production environments, several recent tools from both industry and academia record data about execution for the benefit of post-hoc analysis. Debugging on these data instead of a live program is much more difficult, however, because the semantic abstractions provided by the programming language are no longer available. Many post-hoc analysis tools process this data through additional reflection-based code or domain-specific query languages, but do not recover the expressive power of the original programming language.This thesis proposes the concept of time-travel programming, which we define as simulating the execution of additional code in the same programming language as if it were present in the past environment of recorded data. Furthermore, we show that the aspect-oriented programming (AOP) paradigm provides a natural mechanism for specifying this additional execution, and allows us to reuse established semantics and implementations. We provide evidence of this technique’s flexibility, feasibility and effectiveness through two implementations: one an interpreter for an extremely simple AOP language in the style of a core calculus, and one for the AspectJ programming language. We evaluate flexibility via applying the implementations to multiple execution recording formats, feasibility by showing the AspectJ implementation is performant enough for post-hoc analysis, and effectiveness by demonstrating that evaluating new and existing aspects retroactively can be used to address common post-hoc analysis tasks.
Traditional AspectJ implementations use a VM-external implementation approach based on JBC instrumentation. These approaches pose an inherent penalty in both steady state performance as well as startup or recompilation performance. We present a map of the design space for AspectJ implementations with potential advantages and disadvantages to evaluate the coverage of the space by related work to identify unexplored possibilities.We propose an architecture for AspectJ implementations which supports both VM-internal and VM-external implementations. VM-internal implementations of our architecture fit naturally into existing JVMs, are straight forward to implement and support all known AspectJ optimizations as well as maintaining efficient startup performance. However, because our architecture also supports VM-external implementations, it is both backward and forward compatible.Additionally, we present a suite of benchmarks designed to evaluate AspectJ implementations. This suite contains macro and micro benchmarks designed to measure the steady state, startup, and overall performance of an implementation.To demonstrate the viability of our architecture, we present one primary implementation, ajvm, in the Jikes Research Virtual Machine (RVM), and several secondary partial implementations in the Jikes RVM and a second JVM, J9.We use our proposed benchmark suite to produce an analysis that confirms our claims that VM-integrated AspectJ implementations can support known and proposed steady state and startup optimizations. Furthermore, they overcome inherent performance penalties associated with VM-external implementations.
We introduce a class of program editors that present a program using a rich set of transformations; we call these kinds of editors composable presentation editors. Proper use of these kinds of editors appears to lead to more expressive programs-programs whose structure are aligned with the problem they are trying to solve. By default, the composable presentation editor presents program elements textually as concrete syntax and enables typical editor commands on the program. Metadata on program elements control how the transformations are applied. Customized metadata can re-order, pictorialize, collapse, duplicate, or expand the displayed form of program elements and can additionally alter the available editor commands. We have developed a set of presentation techniques to be used by presentation designers (i.e., the programmers who design how a program is presented in the editor. These techniques relate to well-understood programming language design, editor design, and programming best-practices techniques including scoping, higher order functions, refactoring, prettyprinting, naming conventions, syntax highlighting, and text hovers. We introduce two implementations of composable presentation editors and a number of examples showing how programs can be made more expressive when presentation techniques are properly used. The first implementation is the ETMOP, an open editor, where a metaobject protocol is provided that allows language and editor designers to customize the way program elements are displayed. These customizations are called presenta- tion extensions and the corresponding presentation extension protocol acts in a way similar to the way that syntax macros extend the syntax of a language. The second implementation is Embedded CAL, a closed editor that uses these presentation techniques to embed one language (CAL) inside a host language (Java) through the use of presentation techniques, without changing the syntax or compiler of either language.
Master's Student Supervision (2010 - 2018)
In  and , Golbeck implemented AspectJ Virtual Machine, an in-VM, lazy aspect weaver to improve the startup performance of applications containing aspects. In this work, it was important to clearly show an improvement of performance over earlier aspect weavers at startup. However, the lack of large applications using aspects and the complexity of startup benchmarking make such performance evaluation difficult. This thesis examines these challenges and presents our approach to application startup benchmarking. Using this approach, it clearly identifies previously unknown performance differences between aspect-aware Virtual Machine (VM) implementations.