Refereed conference and journal papers
Artificial intelligence is enjoying an extended renaissance due to numerous successes of machine learning in many application areas. However, developing effective machine learning techniques is insufficient: one must also build and maintain machine learning systems that use these techniques in order to solve real business problems. These machine learning systems are necessarily complex and present myriad engineering challenges. We introduce the intelligent applications concept, which characterizes the structure and responsibilities of contemporary machine learning systems. Finally, we argue that Kubernetes is well-suited to taming the complexity of machine learning systems for the same reasons it has tamed the complexity of conventional distributed applications: declarative deployments, improved observability, and a single management interface for all application components.
We present a lightweight type-and-effect system for Java programs that features two major innovations over extant object-oriented effects systems: initialization effects, which are writes to an object’s state while it is being constructed, and quiescing fields, which are fields that are never written after an object is constructed. We also present a novel taxonomy of degrees of method purity in object-oriented programs, which characterizes methods whose effects are confined to their receiver object. Finally, we find significant amounts of mostly-functional behavior in realistic Java programs: in the benchmarks we analyzed, between 48–53% of declared fields were identifiable as quiescing and between 24–78% of dynamic field reads were from quiescing fields.
We present a lightweight type-and-effect system for Java programs that features two major innovations over extant object-oriented effects systems: initialization effects, which are writes to an object's state while it is being constructed, and quiescing fields, which are fields that are never written after an object is constructed. We also present a novel taxonomy of degrees of method purity in object-oriented programs, which characterizes methods whose effects are confined to their receiver object. Finally, we find significant amounts of mostly-functional behavior in realistic Java programs: in the benchmarks we analyzed, between 48—53% of declared fields were identifiable as quiescing and between 24—78% of dynamic field reads were from quiescing fields.
Static analyses provide the semantic foundation for tools ranging from optimizing compilers to refactoring browsers and advanced debuggers. Unfortunately, developing new analysis specifications and implementations is often difficult and error-prone. Since analysis specifications are generally written in a declarative style, logic programming presents an attractive model for producing executable specifications of analyses. However, prior work on using logic programming for program analysis has focused exclusively on solving constraints derived from program texts by an external preprocessor. In this paper, we present DIMPLE, an analysis framework for Java bytecodes implemented in the Yap Prolog system. DIMPLE provides both a representation of Java bytecodes in a database of relations and a declarative domain-specific language for specifying new analyses as queries over this database. DIMPLE thus enables researchers to use logic programming for every step of the analysis development process, from specification to prototype to implementation. We demonstrate that our approach facilitates rapid prototyping of new program analyses and produces executable analysis implementations that are speed-competitive with specialized analysis toolkits.
Doctoral dissertation
Multicore and multithreaded processors are ubiquitous. Applications in several domains, such as internet servers, scientific simulations, and high-end media creation tools, are generally capable of exploiting the concurrent contexts presented by these processors. However, the vast majority of client applications present sequential workloads that will not directly benefit from parallel hardware. In order for such applications to achieve high performance on such processors, they must be reimplemented as parallel applications.
Unfortunately, writing parallel software in mainstream programming languages is notoriously difficult. The thesis of this dissertation is that real-world client applications exhibit implicit thread-level parallelism because methods on distinct objects are often independent. We show that it is possible to identify this object-level parallelism statically via efficient, novel type-based program analyses to identify methods that are good candidates for safe parallel execution. In addition, we demonstrate that many methods that can be safely executed through object-level parallelism are substantial enough to constitute realistic parallel tasks.