I am a graduate of the wonderful Department of Computer Science, University of Chicago. My Bachelor of Science is from Harvey Mudd College.


I am interested in functional programming language design, module systems, type inference, the applications of advanced type systems, and compilers.

My dissertation develops some of the interesting issues in program modularity. I am developing the formal semantics for a particularly powerful form of modules which is both fully transparent (i.e., propagates all type information and type actions) and higher-order (i.e., functors which map modules to modules can also map functors/modules to functors/modules). This powerful form of modules enables greater code reuse without compromising strong static type safety. I have also been exploring various implications of extending parallelism and exception safety (type and effect systems) to the program module level.

Language support for modularity is a common theme in any nontrivial language used to construct large software systems. Typed languages, in particular, present interesting design problems. Central to module system design is the imperative to enable separate compilation of large software systems and specification of interfaces to separately compilable compilation units. The richer and more powerful a core language is, the more complicated interface specification of separately compilable modules becomes. The interplay and tension between separate compilation and the simplicity of interface specifications provide a rich design space. The need for modularity is not restricted to general purpose programming languages. For example, theorem proving and model checking languages also employ module systems to improve organizational flexibility and performance by spreading out code to multiple modules and thereby limiting the size of any individual module. Popular extensions of SML such as SML/NJ and MLton support a particularly powerful module system that is higher-order and yet admits full transparency of type components that result from higher-order functor (i.e., a function from module to module) application.

Previously, I have studied methods and semantics for teaching type inference using only rewriting with Dave MacQueen and Robby Findler. While I was at Harvey Mudd, I implemented Jun Yang's UAE (Unification of Assumption Environments) type inference algorithm for the entire Core ML with Chris Stone and various others.

At the University of Chicago and TTI-C, we have an assortment of programming languages oriented activities such as PL Lunch (at TTI-C) and the HYPER (at UChicago).



During the summer of 2009, I taught the Introduction to Computer Science course (CMSC15100) at the University of Chicago. The course utilized the How to Design Programs curriculum, the Scheme language, and various custom shims for importing data from Facebook and Twitter that I implemented. In the final lab, students wrote to the Twitter API.

I have TA'ed Software Construction, Foundations of Software, Programming Languages, Networks and Distributed Systems, and the summer course Concepts of Programming.


I worked with Dave MacQueen on the SML/NJ module system and compiler.

Primarily focusing on the front-end (i.e., the elaborator), we are improving the flexibility and expressiveness of the language by implementing some of the ideas from the new semantics. I have also contributed to some of the code generation for floating point operations in the compiler/MLRISC backend code generator.

During graduate school, I built a gradient-descent-based machine learning optimizer for cycle-accurate architecture simulation. The idea was the use gradient descent to fine tune the few dozen parameters for the SimpleScalar architecture simulator. Since cycle-accurate simulation is really slow, the optimization certainly took a while before it reached steady state. I also wrote a chat server and client with peer-to-peer file transfer support using C++, pthreads, and QT.

During college, I got to work on a number of interesting projects. The longest running project were various type checkers and inferencers. This was my first introduction to higher-order typed languages such as Standard ML and OCaml, both of which I used. The target/object language being checked was usually Standard ML or Standard ML like. At Harvey Mudd, the senior capstone project is a team software project conceived by an outside customer. In my case, the project was intrusion detect by artificial immune systems (following Stephanie Forrest's work. My team extended the lightweight intrusion detection system with detectors that migrated from network node to node to improve coverage while minimizing resource consumption.

With another team, I implemented the obligatory 3D golf game and 2D shooters using OpenGL and some game development toolkit.

At one point, I was introduced to IntelliJ's IDE. It was indeed quite sophisticated with all its built-in support for refactoring. Over there, I wrote a documentation server (XHTML/CSS/JavaScript/Tomcat) and a Bluetooth OBEX-based mobile phone control driver for a Java-based voice recognition framework (purportedly a natural language voice recognition framework). I also write a separate driver that synchronized contacts with a car's onboard telematics system using the beginnings of SyncML.

I wrote a wireless link quality estimator while I was at Rooftop Communications (acquired by Nokia Networks). There were two versions, one a Java version and the other a C/GTK+ one.

One of my earlier projects was an HTML editor written in C++ and an early version of MFC. I had also dabbled with Borland's OWL windowing library at that time. I still vividly remember Babbages' carrying the latest and greatest in Borland Turbo Pascal which claimed to compile many, many thousands of lines of code per minute.

I am blogging about my adventures in branching out to fashionable software infrastructure and programming languages (with a programming language researcher's eye) and the markets.


Find out What's Opening in your neighborhood with a focus on the SF Bay Area.