Founder and CEO
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.
Project for Programming Languages and Translators
Revenge-of-the-table is a language designed to ease the use and manipulation of relational databases by allowing the programmer to view them in the object-oriented paradigm. This is accomplished by compiling La Mesa code into Java code, with the appropriate SQL API calls, that will automatically translate object-oriented data structures into tables that can be stored in the database. Similarly, the language will be able to query the database in a more natural way by allowing programmers to search for objects that meet certain criteria rather than manually querying across numerous tables to find a desired data point. This will allow programmers to forget the implementation details for storing their data in a relational database and permit them to focus on doing interesting things with the data.
Ast-pp generates code for printing types defined in that OCaml file. In Haskell, the type system permits a polymorphic function for converting objects to strings. However in OCaml, this is not possible. OCaml should, in my opinion, provide some built in facility, whether through automatic code generation or language-level mechanism, to print data structures, as this is essential for debugging programs. Ast-pp remedies this omission by generating the code programmers would otherwise spend time writing to print data structures. I wrote it to accelerate my work on revenge-of-the-table.
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.