Jared Pochtar

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


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

4.0 GPA in college classes during 11th and 12th grades
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, comprised of mostly graduate students

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

4.0 GPA in college classes the summer of 2011
Coursework: Concepts of Mathematics, Principles of Economics

Hunter College

4.0 GPA in college classes during 9th and 10th grades
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

Computer Programming

JavaScript/Node, Python/Django
C/C++, Objective-C/Cocoa
Haskell, OCaml, MIPS/ARM, Java



Founder and CEO


Krypton Project

Software Engineering Intern — Summer 2015
  • First college intern at rapidly growing venture backed startup.
  • 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 for our custom language. Used the query optimizer to detect and convert users' database queries with equality joins to hashjoins, for orders of magnitude performance gains.


Software Engineering Intern — Summer 2014
  • Wrote a program for hack week to automatically insert type annotations into Python source code using dynamic type inference with Guido van Rossum.
  • First intern on Dropbox Paper. Implemented interactions with images so behavior matches native applications, especially in edge cases involving keyboard navigation.
  • 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 Technologies

Software Engineering Intern — Winter 2013-2014

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

Software Engineering Intern — Summer 2013

Efficiently led the port of a large CoffeeScript codebase to TypeScript by designing and implementing automated tools to do the majority of the rote labor, then led the team on the remaining edge cases where nuanced understanding of the intent of the code was required because of semantics mismatches between the languages when used idiomatically. In particular, adapted the CoffeeScript compiler to emit TypeScript. 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

Research / Languages

I've always had an interest in languages — I like making tools, and what better tools to make than ones I can use everyday?

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.


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.

© Jared Pochtar