Tiark Rompf
Purdue University, Department of Computer Science
Home | Research | Blog | Publications | Talks | Group | Teaching | Service
Projects
- LMS (Lightweight Modular Staging): runtime code generation and embedded compilers - abstraction without regret!
- Rhyme: an expressive data-centric query language for nested data structures
- Flare: native query compilation for Spark and TensorFlow
- Lantern: an expressive and performant deep learning framework
- Delite: a compiler and runtime framework for compiled embedded DSLs.
- Lancet: surgical precision JIT compilers.
- Scala-Virtualized: redefining built-in language features as library calls
- DOT: mechanized foundations for Scala and similar languages
- Reachability Types: bringing features of Rust to higher-level languages
Research
Most of my work revolves around Lightweight Modular Staging (LMS), a platform and methodology for integrating runtime code generation into high-level programs and especially for building embedded compilers for domain specific languages (DSLs). In the early days, I helped build Delite, a compiler framework jointly developed with Kunle Olukotun's group at the Stanford Pervasive Parallelism Lab. At Oracle Labs (2012-2014) I started Project Lancet, which aims to turn JIT compilers into precision tools in future JVM generations. More recently, I have been applying LMS to speed up data processing and query engines. A key recent work in this direction is Flare, an accelerator back-end for Apache Spark that achieves order of magnitude speedups by compiling SQL and data frame queries to native code.
This whole area is seeing a surge of interest with the proliferation of AI systems based on computation graphs and automatic differentiation. Our project Lantern is a new take on deep learning frameworks based on LMS and delimited continuations, combining the benefits of TensorFlow and PyTorch. I am also interested in applying deep learning techniques to formal reasoning, in particular casting symbolic problems like program synthesis and proof search as gameplay in the style of AlphaGo.
As a member of the Scala team from 2008 to 2014 (lead by Martin Odersky at EPFL), my contributions to Scala include delimited continuations, efficient immutable data structures (Set, Map, Vector) and speedups in the Scala compiler (type checking, implicit search, bytecode generation; up to 3x for certain projects). I also started the Scala-Virtualized research branch. More recently I helped formalize parts of Scala's type system in the DOT calculus, leading to the first mechanized soundness proof of DOT.
My group and I have proposed a notion of Reachability Types, which promise to bring the benefits of Rust-style tracking of lifetimes and sharing to higher-level languages that make pervasive use of type-level and functional abstraction.
I received an MS in computer science from University of Lübeck (2008) and a PhD from EPFL (2012). Before my PhD I co-founded two startups and lead software projects ranging from CAD software for kitesurfing equipment to hospital systems for electronic anesthesia records, image processing for OCT workstations, and therapeutic games.