I am a lecturer in Cornell's computer science department.
I'm interested in the process of programming, and in tools and techniques
that can help programmers design software that is correct, secure, and
I worked towards a Ph.D. at Cornell University until 2013, under the
guidance of Andrew Myers.
I received a BA in mathematics and a BS in computer science from the
University of Rochester in 2003. I also received an MA in mathematics
from the University of Rochester in 2004.
My Ph.D. research focused on building decentralized distributed systems
that guarantee strong security properties. I am a lead developer of
programming language and runtime system that use information flow
analysis to protect users' information, even in the presence of partially
trusted code running on a partially trusted platform.
You can find my CV here.
Over the past several years I have been the instructor or co-instructor
of the following courses:
- Discrete structures
(cs 2800, fa13,
- Formal proofs, logic, set theory, combinatorics, probability, graphs,
finite automata and regular languages.
- Functional programming and data structures
- Functional and concurrent programming, writing and using
specifications, modular programming and data abstraction, reasoning
about program correctness, reasoning about system performance, useful
and efficient data structures.
- Operating systems
(cs 4410, su14,
- Hardware support for operating systems, concurrent programming and
synchronization, memory management, filesystems, networking.
- Design and analysis of algorithms
(cs 4820, su13)
- greedy algorithms, dynamic programming, divide and conquer, np
completeness, undecidability, proofs of correctness, asyptotic
- Object Oriented Programming and Data Stuctures
(cs 2110, su06,
- Java, object oriented programming, design patterns, introductory data
structures and algorithms, GUI programming.
- Warranties for Faster Strong Consistency (NSDI 2014)
- We present a new mechanism, warranties, to enable building distributed
systems with linearizable transactions. A warranty is a time-limited
assertion about one or more distributed objects. These assertions
generalize optimistic concurrency control, improving throughput
because clients holding warranties need not communicate to verify the
warranty's assertion. Updates that might cause an active warranty to
become false are delayed until the warranty expires, trading write
latency for read latency. For workloads biased toward reads,
warranties improve scalability and system throughput. Warranties can
be expressed using language-level computations, and they integrate
harmoniously into the programming model as a form of memoization.
Experiments with some nontrivial programs demonstrate that warranties
enable high performance despite the simple programming model.
- Sharing Mobile Code Securely With Information Flow Control (Oakland 2012).
- We introduce a new architecture for secure mobile code, with which
developers can securely use, publish, and share mobile code across
trust domains. This architecture enables new kinds of distributed
applications, and makes it easier to securely reuse and evolve code
from untrusted providers.
- Fabric: A Platform for Secure Distributed Computation and Storage (SOSP 2009).
- Fabric is a new system and language for building secure distributed
information systems. It is a decentralized system that allows
heterogeneous network nodes to securely share both information and
computation resources despite mutual distrust.
When I'm not working I'm often playing the piano, playing board games,
watching classic movies, hiking or camping, or engaging in political
discussions. I also have a few unfinished programming projects that I
poke at every now and again:
— A monadic OCaml library for animating and comparing
— An Android app for recording lectures.
— A Java library for generic algebraic operations.
— A tangrams game featuring an innovative drag-and-drop
— A word game.