To experiment with visualizations of program behavior (ie. make omniscient debuggers), it would be useful to have an easy to use datastructure representing a recording of a program. This project explores a representation that falls out of a lisp-style minimal language. It turns out to be quite natural, and embeds neat properties of programs. For example, it makes obvious that stack traces are really paths from the root to a leaf in a function call tree. One imagines program execution as a DFS of this function call tree, where the call "stack" is the frontier set. A natural visualization of this call tree turns out to be a flame graph. It also makes obvious that all dataflow into a function comes from either arguments or closure captures.
Founder/CEO — 2016-2018
Pagedraw is a platform for productionizing Sketch designs into React code. You import a Sketch file, mark in Pagedraw how it should resize and reflow, then we generate React JSX and CSS you can wire into your backend.
Pagedraw writes code like I would write by hand. It's just JSX and CSS, no special libraries or frameworks required. You can drop React components made in Pagedraw into an existing React app alongside your handwritten React components, and you can use your existing React component libraries in Pagedraw.
Pagedraw takes care of the most tedious coding so you can get back to the good stuff. Pagedraw generated code is guaranteed to work correctly and in all browsers, which means less code in your codebase over which you have to worry about correctness and safety.
Designed and implemented Eclipse plugins to unify the development build system into Grunt.
Built JIT compiler for SQL-like filter engine for low-latency PubSub system
Class of 2017
Coursework: Systems Programming, Operating Systems, Digital Platforms, Design of Usable Interactve Systems, Intro Electrical Engineering, Performance Engineering of Software Systems (MIT), Data Structures and Algorithms, Systems Security, Computer Vision, Machine Learning, Corporate Financial Accounting (MIT), Intro to Distributed Computing
Taught section of class, graded homeworks, and held office hours
Held office hours and graded homeworks and tests for Programming Languages and Translators
Research in compiling functional intermediate representations to hardware in collaboration with Professor Stephen Edwards, culminating in "Compiling Away Recursion for Hardware."
Lectured and graded college students for Software Analysis and Design I
with research advisor Professor Stephen Edwards
To provide a superior way of coding, compiling, and optimizing parallel algorithms, we are developing techniques for synthesizing hardware from functional specifications. Recursion, fundamental to functional languages, does not translate naturally to hardware, but tail recursion is iteration and easily implemented as a finite-state machine. In this paper, we show how to translate general recursion into tail recursion with an explicit stack that can be implemented in hardware. We give examples, describe the algorithm, and argue for its correctness. We also present experimental results that demonstrate the method is effective.
We aim to compile and optimize any Python code faithfully. To do this, we make one critical assumption: that we can assume that we have the entire code, and that no new code can be loaded at runtime. Without this assumption, we could optimize very little as runtime-loaded code could modify the program in ways which the compiler would need to prove impossible in order to make certain optimizations. With this assumption, we can use whole code analysis to prove facts about the source code which allow us to perform certain overhead-removing optimizations. Thus, we hope to compile most common-case Python code to native C++ mechanisms for maximal performance, and leverage CPython as a fallback to maintain semantic equivalency with CPython. Currently, P3 yields a 2.7x speedup over CPython.
In Objective-C, you can only call an overridden implementation of a method from an immediate subclass of that method's class. This works well to provide encapsulation, and based on the way super is handled, a super method implementation cannot be called from any but the immediate superclass (inheritance notwithstanding). This is a good thing, as it would break large bits of encapsulation if subclasses could call arbitrary super implementations, or worse, if other objects could call super implementations of methods on foreign objects.
In C, and thus Objective-C, a switch statement only works with integers, and the case labels all need to be constant. Strings seem like a natural thing to switch on, especially for command line interfaces. Unfortunately, they cannot be reduced to integer constants, so we cannot use them. Now that we have blocks in the language, we can create a dictionary where we associate any object, such as an NSString, with a block, and call the selected block after a simple dictionary lookup.
I seem to like making the jankiest possible hardware. There's something too modernist about technology we buy in a store, with the polished metal, plastic, and glass casing. It's just transistors connected by conductors, mounted on whatever. Tin foil and cardboard are satisfyingly brutalist materials for electronics. Here are two very old projects from when I was in school (8th grade and sophomore year, respectively) made out of literal duct tape and tin foil.