Jared Pochtar

http://jpochtar.me/ ⋅ jpochtar@gmail.com

Jared Pochtar

jared@pagedraw.io Github LinkedIn Medium

Pagedraw


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.

Past


Coda


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).

Dropbox


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

Palantir


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

Programming Languages Research


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.

revenge-of-the-table

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

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.

SuperMessenger

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.

JPObjectSwitch

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.

Jared Pochtar 2017