Jared Pochtar

http://jpochtar.me/ ⋅ [email protected]

Jared Pochtar

I write code
Twitter Medium LinkedIn Github HN

Recent Projects

Exploring and debugging programs with "Execution Records"

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.


Software Engineering Intern — Summer 2015
  • First college intern.
  • Optimized performance of in-browser database-like system.
  • Integrated performance profiling infrastructure, enabling monitoring of performance so the team could get insight into our code's speed and optimize for it. Included work across the software stack from integrating with graphing tool to digging into C++ v8 internals to fix a bug in the v8 profiler.
  • Designed and implemented query optimizer stage for formula language compiler.
  • Added pattern matching on equijoins to the optimizer, making this common operation O(n+m) instead of O(nm).


Software Engineering Intern — Summer 2014
  • First intern on Dropbox Paper. Implemented interactions with images so behavior matches native applications, especially in edge cases involving keyboard navigation.
  • Made a codemod, pinfer.py, which inserts type annotations into existing Python source code. Worked with Python creator Guido van Rossum.
  • Designed and implemented an architecture and policy for coordination of syncing documents where we have several different sync mechanisms to choose from, but have correctness invariants to maintain regarding which ones we can run given the state of the document and other factors.
  • Worked across the whole stack, writing Python, JavaScript, Objective-C, C++, and HTML/CSS/LESS


Software Engineering Intern — Winter 2013-2014

Designed and implemented Eclipse plugins to unify the development build system into Grunt.

Software Engineering Intern — Summer 2013

Automated the port of a CoffeeScript codebase to TypeScript by forking the CoffeeScript compiler to emit TypeScript instead of JavaScript. The port was originally planned to be done by hand, which would have cost a 20+ person team at least a week of dedicated time. Led the team on the remaining edge cases of semantics mismatches between the languages when used idiomatically. Also created interactive seating chart web app for hack week.

60East Technologies

Software Engineering Intern — Summer 2012

Built JIT compiler for SQL-like filter engine for low-latency PubSub system

Harvard College

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

CS50 Teaching Fellow Fall 2013

Taught section of class, graded homeworks, and held office hours

Hunter College High School

Class of 2013
The below college work was completed while in high school

Columbia University

Took college classes while in 11th and 12th grade
Coursework: Advanced Topics in Programming Languages and Compilers (Graduate course), Advanced Software Engineering, Programming Languages and Translators

Teaching Assistant Fall 2012 and Spring 2013

Held office hours and graded homeworks and tests for Programming Languages and Translators

Graduate-level researcher Spring 2012 - Spring 2013

Research in compiling functional intermediate representations to hardware in collaboration with Professor Stephen Edwards, culminating in "Compiling Away Recursion for Hardware."

Carnegie Mellon University

Took college classes the summer of 2011, between 10th and 11th grade
Coursework: Concepts of Mathematics, Principles of Economics

Hunter College

Took college classes while in 9th and 10th grade
Coursework: Computer Architecture III, Computer Architecture II, Software Analysis and Design II

Teaching Assistant Fall 2010

Lectured and graded college students for Software Analysis and Design I

School Projects

Research Paper: Compiling Away Recursion for Hardware

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.

The P3 Compiler: Compiling Python to C++ to remove overhead

as the final project for COMS6998 Advanced Topics in Programming Languages and Compilers with Professor Alfred Aho

Project Home and Source Code (GitHub)

Paper (pdf)

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.

Janky hardware

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.