Education

• PhD in Computer Science, 2022
  University of Chicago
• Master of Science in Computer Science, 2020
  University of Chicago
• Bachelor of Science in Mechanical Engineering, 2016
  University of California, Berkeley
• Bachelor of Science in Electrical Engineering and Computer Science (EECS), 2016
  University of California, Berkeley

Publications & Talks

• [Talk] Towards ZX Calculus as a Compiler Intermediate Representation
  Talk at various research groups • August 2022
  Abstract: Fault-tolerant quantum computing will enable large-scale algorithms far beyond NISQ. However design constraints for NISQ vs. fault-tolerant are significantly different. Quantum circuits and gates...[more]

  Abstract: Fault-tolerant quantum computing will enable large-scale algorithms far beyond NISQ. However design constraints for NISQ vs. fault-tolerant are significantly different. Quantum circuits and gates map well to operations on NISQ devices but this is not the case in fault-tolerance. Leading fault-tolerant protocols such as lattice surgery do not have typical two-qubit gates. Instead the non-unitary operations "merge" and "split" are used with ancilla to execute unitary circuits. This talk is based on in-progress work and will introduce the ZX calculus, show how it could replace circuits as an intermediate representation for lattice surgery, and discuss challenges to integrate this into a compiler. [less]
• [Paper+Talk] New Abstractions for Quantum Computing
  PhD Dissertation and Defense at the University of Chicago • August 2022
  Abstract: The field of quantum computing is at an exciting time where we are building devices, running programs, and finding out what works best. As qubit technology grows and matures, we need to be ready to...[more]

  Abstract: The field of quantum computing is at an exciting time where we are building devices, running programs, and finding out what works best. As qubit technology grows and matures, we need to be ready to design and program larger quantum computer systems. An important aspect of systems design is layered abstractions to reduce complexity and guide intuition. Classical computer systems have built up many abstractions over its history including the layers of the hardware stack and programming abstractions like loops. Researchers initially ported these abstractions with little modification when designing quantum computer systems and only in recent years have some of those abstractions been broken in the name of optimization and efficiency.

  We argue that new or quantum-tailored abstractions are needed to get the most benefit out of quantum computer systems. We keep the benefits gained through breaking old abstraction by finding abstractions aligned with quantum physics and the technology. This dissertation is supported by three examples of abstractions that could become a core part of how we design and program quantum computers: third-level logical state as scratch space, memory as a third spacial dimension for quantum data, and hierarchical program structure.

  Committee Members: Fred Chong, Henry (Hank) Hoffmann, and Ken Brown [less]
  UChicago PDF arXiv
• Exploiting Long-Distance Interactions and Tolerating Atom Loss in Neutral Atom Quantum Architectures
  Jonathan M. Baker, Andrew Litteken, Casey Duckering, Henry Hoffmann, Hannes Bernien, Frederic T. Chong
  ISCA '21 • Proceedings of the 48th International Symposium on Computer Architecture • June 2021
  IEEE Micro Top Pick Honorable Mention
  Abstract: Quantum technologies currently struggle to scale beyond moderate scale prototypes and are unable to execute even reasonably sized programs due to prohibitive gate error rates or coherence times. Many...[more]

  Abstract: Quantum technologies currently struggle to scale beyond moderate scale prototypes and are unable to execute even reasonably sized programs due to prohibitive gate error rates or coherence times. Many software approaches rely on heavy compiler optimization to squeeze extra value from noisy machines but are fundamentally limited by hardware. Alone, these software approaches help to maximize the use of available hardware but cannot overcome the inherent limitations posed by the underlying technology.

  An alternative approach is to explore the use of new, though potentially less developed, technology as a path towards scalability. In this work we evaluate the advantages and disadvantages of a Neutral Atom (NA) architecture. NA systems offer several promising advantages such as long range interactions and native multiqubit gates which reduce communication overhead, overall gate count, and depth for compiled programs. Long range interactions, however, impede parallelism with restriction zones surrounding interacting qubit pairs. We extend current compiler methods to maximize the benefit of these advantages and minimize the cost.

  Furthermore, atoms in an NA device have the possibility to randomly be lost over the course of program execution which is extremely detrimental to total program execution time as atom arrays are slow to load. When the compiled program is no longer compatible with the underlying topology, we need a fast and efficient coping mechanism. We propose hardware and compiler methods to increase system resilience to atom loss dramatically reducing total computation time by circumventing complete reloads or full recompilation every cycle. [less]
  IEEE Xplore PDF arXiv Code
• [Paper+Talk] Orchestrated Trios: Compiling for Efficient Communication in Quantum Programs with 3-Qubit Gates
  Casey Duckering, Jonathan M. Baker, Andrew Litteken, Frederic T. Chong
  ASPLOS '21 • Proceedings of the 26th International Conference on Architectural Support for Programming Languages and Operating Systems • April 2021
  Abstract: Current quantum computers are especially error prone and require high levels of optimization to reduce operation counts and maximize the probability the compiled program will succeed. These...[more]

  Abstract: Current quantum computers are especially error prone and require high levels of optimization to reduce operation counts and maximize the probability the compiled program will succeed. These computers only support operations decomposed into one- and two-qubit gates and only two-qubit gates between physically connected pairs of qubits. Typical compilers first decompose operations, then route data to connected qubits. We propose a new compiler structure, Orchestrated Trios, that first decomposes to the three-qubit Toffoli, routes the inputs of the higher-level Toffoli operations to groups of nearby qubits, then finishes decomposition to hardware-supported gates.

  This significantly reduces communication overhead by giving the routing pass access to the higher-level structure of the circuit instead of discarding it. A second benefit is the ability to now select an architecture-tuned Toffoli decomposition such as the 8-CNOT Toffoli for the specific hardware qubits now known after the routing pass. We perform real experiments on IBM Johannesburg showing an average 35% decrease in two-qubit gate count and 23% increase in success rate of a single Toffoli over Qiskit. We additionally compile many near-term benchmark algorithms showing an average 344% increase in (or 4.44x) simulated success rate on the Johannesburg architecture and compare with other architecture types. [less]
  ACM Digital Library PDF arXiv Abstract+ Summary Talk Code
• Virtual Logical Qubits: A Compact Architecture for Fault-Tolerant Quantum Computing
  Jonathan M. Baker†, Casey Duckering†, David I. Schuster, Frederic T. Chong
  IEEE Micro Top Picks • April 2021
  Abstract: Fault tolerant quantum computing is required to execute many of the most promising quantum applications. In recent years, numerous error correcting codes, like the surface code, have emerged which...[more]

  Abstract: Fault tolerant quantum computing is required to execute many of the most promising quantum applications. In recent years, numerous error correcting codes, like the surface code, have emerged which are well suited for current and future limited connectivity 2D devices. We find quantum memory, particularly resonant cavities with transmon qubits arranged in a 2.5D architecture, can efficiently implement surface codes with around 20x fewer transmons via this work. We virtualize 2D memory addresses by storing the code in layers of qubit memories connected to each transmon. Distributing logical qubits across many memories has minimal impact on fault tolerance and results in substantially more efficient logical operations. Virtualized Logical Qubit (VLQ) systems can achieve fault tolerance comparable to conventional 2D transmon-only architectures while putting within reach a proof-of-concept experimental demonstration of around 10 logical qubits, requiring only 11 transmons and 9 attached cavities. [less]
  IEEE Xplore News Prev. Work
• [Paper+Talk] Virtualized Logical Qubits: A 2.5D Architecture for Error-Corrected Quantum Computing
  Casey Duckering†, Jonathan M. Baker†, David I. Schuster, Frederic T. Chong
  MICRO '20 • Proceedings of the 53rd IEEE/ACM International Symposium on Microarchitecture • October 2020
  Best Paper Runner-Up at MICRO 2020, IEEE Micro Top Pick Award
  Abstract: Current, near-term quantum devices have shown great progress in recent years culminating with a demonstration of quantum supremacy. In the medium-term, however, quantum machines will need to...[more]

  Abstract: Current, near-term quantum devices have shown great progress in recent years culminating with a demonstration of quantum supremacy. In the medium-term, however, quantum machines will need to transition to greater reliability through error correction, likely through promising techniques such as surface codes which are well suited for near-term devices with limited qubit connectivity. We discover quantum memory, particularly resonant cavities with transmon qubits arranged in a 2.5D architecture, can efficiently implement surface codes with substantial hardware savings and performance/fidelity gains. Specifically, we virtualize logical qubits by storing them in layers distributed across qubit memories connected to each transmon.

  Surprisingly, distributing each logical qubit across many memories has a minimal impact on fault tolerance and results in substantially more efficient operations. Our design permits fast transversal CNOT operations between logical qubits sharing the same physical address which are 6x faster than lattice surgery CNOTs. We develop a novel embedding which saves ~10x in transmons with another 2x from an additional optimization for compactness.

  Although Virtualized Logical Qubits (VLQ) pays a 10x penalty in serialization, advantages in the transversal CNOT and area efficiency result in performance comparable to 2D transmon-only architectures. Our simulations show fault tolerance comparable to 2D architectures while saving substantial hardware. Furthermore, VLQ can produce magic states 1.22x faster for a fixed number of transmon qubits. This is a critical benchmark for future fault-tolerant quantum computers as magic states are essential and machines will spend the majority of their resources continuously producing them. VLQ substantially reduces the hardware requirements for fault tolerance and puts within reach a proof-of-concept experimental demonstration of around 10 logical qubits, requiring only 11 transmons and 9 attached cavities in total. [less]
  IEEE Xplore PDF arXiv Lightning Talk Code
• [Talk] Quantum Circuit Optimization
  STAQ Quantum Ideas Summer School • June 2020
  Abstract: An introduction to quantum circuit optimization with a hands-on demonstration and exercises in the online circuit simulator, Quirk.[more]

  Abstract: An introduction to quantum circuit optimization with a hands-on demonstration and exercises in the online circuit simulator, Quirk. [less]
  STAQ Talk Slides Exercises
• Improved Quantum Circuits via Intermediate Qutrits
  Jonathan M. Baker, Casey Duckering, Pranav Gokhale, Natalie C. Brown, Kenneth R. Brown, Frederic T. Chong
  ACM Transactions on Quantum Computing • October 2020
  Abstract: Quantum computation is traditionally expressed in terms of quantum bits, or qubits. In this work, we instead consider three-level qutrits. Past work with qutrits has demonstrated only constant...[more]

  Abstract: Quantum computation is traditionally expressed in terms of quantum bits, or qubits. In this work, we instead consider three-level qutrits. Past work with qutrits has demonstrated only constant factor improvements, owing to the log2(3) binary-to-ternary compression factor. We present a novel technique, intermediate qutrits, to achieve sublinear depth decompositions of the Generalized Toffoli and other arithmetic circuits using no additional ancilla—a significant improvement over linear depth for the best qubit-only equivalents. For example, our Generalized Toffoli construction features a 70x improvement in two-qudit gate count over a qubit-only decomposition. This results in circuit cost reductions for important algorithms like quantum neurons, Grover search, and even Shor's algorithm. Using a previously developed simulator with near-term noise models we demonstrate for these models over 90% mean reliability (fidelity) for the Toffoli construction, versus under 30% for the qubit-only baseline. For our other constructions, such as the Incrementer, the A + B adder and the +K adder we demonstrate the power of intermediate qutrits in producing asymptotic depth improvements with no additional ancilla. Together, these results suggest qutrits offer a promising path towards scaling quantum computation. [less]
  ACM Digital Library
• Resource-Efficient Quantum Computing by Breaking Abstractions
  Yunong Shi, Pranav Gokhale, Prakash Murali, Jonathan M. Baker, Casey Duckering, [more], Yongshan Ding, Christopher Chamberland, Andrew W. Cross, David I. Schuster, Kenneth R. Brown, Margaret R. Martonosi, Diana Franklin, Frederic T. Chong
  Proceedings of the IEEE • June 2020
  Abstract: Building a quantum computer that surpasses the computational power of its classical counterpart is a great engineering challenge. Quantum software optimizations can provide an accelerated pathway to...[more]

  Abstract: Building a quantum computer that surpasses the computational power of its classical counterpart is a great engineering challenge. Quantum software optimizations can provide an accelerated pathway to the first generation of quantum computing applications that might save years of engineering effort. Current quantum software stacks follow a layered approach similar to the stack of classical computers, which was designed to manage the complexity. In this review, we point out that greater efficiency of quantum computing systems can be achieved by breaking the abstractions between these layers. We review several works along this line, including two hardware-aware compilation optimizations that break the quantum Instruction Set Architecture (ISA) abstraction and two error-correction/information-processing schemes that break the qubit abstraction. Last, we discuss several possible future directions. [less]
  IEEE Xplore PDF arXiv
• Time-Sliced Quantum Circuit Partitioning for Modular Architectures
  Jonathan M. Baker, Casey Duckering, Alexander Hoover, Frederic T. Chong
  CF '20 • Proceedings of the 17th ACM International Conference on Computing Frontiers • May 2020
  Abstract: Current quantum computer designs will not scale. To scale beyond small prototypes, quantum architectures will likely adopt a modular approach with clusters of tightly connected quantum bits and...[more]

  Abstract: Current quantum computer designs will not scale. To scale beyond small prototypes, quantum architectures will likely adopt a modular approach with clusters of tightly connected quantum bits and sparser connections between clusters. We exploit this clustering and the statically-known control flow of quantum programs to create tractable partitioning heuristics which map quantum circuits to modular physical machines one time slice at a time. Specifically, we create optimized mappings for each time slice, accounting for the cost to move data from the previous time slice and using a tunable lookahead scheme to reduce the cost to move to future time slices. We compare our approach to a traditional statically-mapped, owner-computes model. Our results show strict improvement over the static mapping baseline. We reduce the non-local communication overhead by 89.8% in the best case and by 60.9% on average. Our techniques, unlike many exact solver methods, are computationally tractable. [less]
  ACM Digital Library PDF arXiv
• Efficient Quantum Circuit Decompositions via Intermediate Qudits
  Jonathan M. Baker†, Casey Duckering†, Frederic T. Chong
  ISMVL '20 • Proceedings of the 50th International Symposium on Multiple-Valued Logic • May 2020
  Abstract: Many quantum algorithms make use of ancilla, additional qubits used to store temporary information during computation, to reduce the total execution time. Quantum computers will be...[more]

  Abstract: Many quantum algorithms make use of ancilla, additional qubits used to store temporary information during computation, to reduce the total execution time. Quantum computers will be resource-constrained for years to come so reducing ancilla requirements is crucial. In this work, we give a method to generate ancilla out of idle qubits by placing some in higher-value states, called qudits. We show how to take a circuit with many O(n) ancilla and design an ancilla-free circuit with the same asymptotic depth. Using this, we give a circuit construction for an in-place adder and a constant adder both with O(log n) depth using temporary qudits and no ancilla. [less]
  IEEE Xplore PDF arXiv
• Extending the Frontier of Quantum Computers with Qutrits
  Pranav Gokhale, Jonathan M. Baker, Casey Duckering, Natalie C. Brown, Kenneth R. Brown, Frederic T. Chong
  IEEE Micro Top Picks • April 2020
  Abstract: Current quantum computer designs will not scale. To scale beyond small prototypes, quantum architectures will likely adopt a modular approach with clusters of tightly connected quantum bits and...[more]

  Abstract: Current quantum computer designs will not scale. To scale beyond small prototypes, quantum architectures will likely adopt a modular approach with clusters of tightly connected quantum bits and sparser connections between clusters. We exploit this clustering and the statically-known control flow of quantum programs to create tractable partitioning heuristics which map quantum circuits to modular physical machines one time slice at a time. Specifically, we create optimized mappings for each time slice, accounting for the cost to move data from the previous time slice and using a tunable lookahead scheme to reduce the cost to move to future time slices. We compare our approach to a traditional statically-mapped, owner-computes model. Our results show strict improvement over the static mapping baseline. We reduce the non-local communication overhead by 89.8% in the best case and by 60.9% on average. Our techniques, unlike many exact solver methods, are computationally tractable. [less]
  IEEE Xplore
• [Talk] Virtualized Logical Qubits
  Casey Duckering, Jonathan M. Baker, David I. Schuster, Frederic T. Chong
  MS Presentation at the University of Chicago • April 2020
  Abstract: Current, near-term quantum devices have shown great progress in the last several years culminating recently with a demonstration of quantum supremacy. These devices, however, are extremely limited...[more]

  Abstract: Current, near-term quantum devices have shown great progress in the last several years culminating recently with a demonstration of quantum supremacy. These devices, however, are extremely limited with prohibitively large error rates and therefore they have relatively few applications. Many of the most anticipated quantum algorithms such as Shor's and Grover's require fault tolerant logical qubits which are built from large numbers of noisy, physical qubits and errors are corrected via quantum error correction codes such as the surface code. While current work on NISQ-era devices is important, there is simultaneously a need to develop architectures for larger scale use of systems composed of error corrected logical qubits.

  In this work, we introduce an architecture matching a recent qubit memory technology with established error correction designed without memory in mind. We provide a new method for the virtualization of error-corrected, logical qubits implemented with surface code patches. Surface codes are promising error correction codes which only require physical qubits with local, nearest-neighbor connectivity which is a common feature among current leading superconducting quantum hardware. Traditionally, surface code patches were arranged on this two-dimensional grid. Recent hardware advances have demonstrated the ability to store qubits in the resonant modes of superconducting cavities attached to transmons and interactions between qubits in the cavity are mediated via the transmon. This memory-like technology enables a new 2.5D architecture which we demonstrate allows logical qubits to be stored and can be paged in and out of memory as needed, essentially virtualizing the logical qubits.

  We demonstrate how traditional representations of surface code patches can be implemented on our new system and show how operations in the lattice-surgery-based surface code translate to our system. Specifically, our system allows for transversal application of CNOT operations between logical qubits sharing the same set of transmons (same physical address) and can use either transversal or standard lattice surgery CNOTs between logical qubits of different physical addresses. These transversal CNOTs are 6x faster than standard lattice surgery CNOTs. Our system can achieve fault tolerance comparable to conventional two-dimensional grids while saving substantial hardware. Furthermore, our architecture can produce magic states at 1.22x the baseline rate given a fixed number of transmon qubits. This is a critical benchmark for future fault-tolerant quantum computers, as magic states are essential and machines will spend the majority of their resources continuously producing them. This architecture will reduce the hardware requirements for fault tolerant quantum computing and experimentalists should consider it for early experimental demonstrations. [less]
• Decomposing Quantum Generalized Toffoli with an Arbitrary Number of Ancilla
  Jonathan M. Baker, Casey Duckering, Alexander Hoover, Frederic T. Chong
  arXiv • April 2019
  Abstract: We present a general decomposition of the Generalized Toffoli, and for completeness, the multi-target gate using an arbitrary number of clean or dirty ancilla. While prior work has shown how to...[more]

  Abstract: We present a general decomposition of the Generalized Toffoli, and for completeness, the multi-target gate using an arbitrary number of clean or dirty ancilla. While prior work has shown how to decompose the Generalized Toffoli using 0, 1, or O(n) many clean ancilla and 0, 1, and n − 2 dirty ancilla, we provide a generalized algorithm to bridge the gap, i.e. this work gives an algorithm to generate a decomposition for any number of clean or dirty ancilla. While it is hard to guarantee optimality, our decompositions guarantee a decrease in circuit depth as the number of ancilla increases. [less]
  PDF arXiv
• Asymptotic Improvements to Quantum Circuits via Qutrits
  Pranav Gokhale, Jonathan M. Baker, Casey Duckering, [more], Natalie C. Brown, Kenneth R. Brown, Frederic T. Chong
  ISCA '19 • Proceedings of the 46th International Symposium on Computer Architecture • June 2019
  IEEE Micro Top Pick Award
  Abstract: Quantum computation is traditionally expressed in terms of quantum bits, or qubits. In this work, we instead consider three-level qutrits. Past work with qutrits has demonstrated only constant...[more]

  Abstract: Quantum computation is traditionally expressed in terms of quantum bits, or qubits. In this work, we instead consider three-level qutrits. Past work with qutrits has demonstrated only constant factor improvements, owing to the log2(3) binary-to-ternary compression factor. We present a novel technique using qutrits to achieve a logarithmic depth (runtime) decomposition of the Generalized Toffoli gate using no ancilla—a significant improvement over linear depth for the best qubit-only equivalent. Our circuit construction also features a 70x improvement in two-qudit gate count over the qubit-only equivalent decomposition. This results in circuit cost reductions for important algorithms like quantum neurons and Grover search. We develop an open-source circuit simulator for qutrits, along with realistic near-term noise models which account for the cost of operating qutrits. Simulation results for these noise models indicate over 90% mean reliability (fidelity) for our circuit construction, versus under 30% for the qubit-only baseline. These results suggest that qutrits offer a promising path towards scaling quantum computation. [less]
  ACM Digital Library PDF arXiv Code
• [Poster] Improved Quantum Circuits via Qutrits
  Pranav Gokhale, Casey Duckering, Jonathan M. Baker, Frederic T. Chong
  QIP '19 • 22nd Annual Conference on Quantum Information Processing • January 2019
  Best Poster Award at QIP 2019
  Abstract: Quantum computation is traditionally expressed in terms of quantum bits, or qubits. In this work, we instead consider three-level qutrits. Past work with qutrits has demonstrated only constant factor...[more]

  Abstract: Quantum computation is traditionally expressed in terms of quantum bits, or qubits. In this work, we instead consider three-level qutrits. Past work with qutrits has demonstrated only constant factor improvements, owing to the lg(3) binary-to-ternary compression factor. We present a novel technique using qutrits to achieve a logarithmic depth (runtime) decomposition of the Generalized Toffoli gate using no ancilla–a significant improvement over linear depth for the best qubit-only equivalent. Our circuit construction also features a 70x improvement in two-qudit gate count over the qubit-only equivalent decomposition. This results in circuit cost reductions for important algorithms like quantum neurons and Grover search. We develop an open-source circuit simulator for qutrits, along with realistic near-term noise models which account for the cost of operating qutrits. Simulation results for these noise models indicate over 90% mean reliability (fidelity) for our circuit construction, versus under 30% for the qubit-only baseline. These results suggest that qutrits offer a promising path towards scaling quantum computation. [less]
  PDF

Projects & Tools

Featured

• ZX Calculator — Interactive ZX diagram rewrite tool (author and maintainer)
• EdX Notebook Grader — External Grade Server for Quantum Computer Systems Design (author)
• Cirq — Quantum computing library (contributor)
• drawsvg — Popular (350+ stars, used by 200+ projects) vector drawing and animation library (author and maintainer)
• latextools — Latex preview and conversion library (author and maintainer)
• hyperbolic — Geometric construction and drawing library (author and maintainer)
• bloch_sphere — Bloch sphere visualizations for teaching (author and maintainer)
• feynman_path — Feynman path integral visualizations for teaching (author and maintainer)
• Disentanglement — Unfinished game where you disentangle qubits through viewing their state vector (author)
• Machiavelli — Solver for the card game (author and maintainer)
• All other software projects can be found on GitHub
• Robotics and embedded system project articles can be found here

Teaching

• Co-Instructor for Quantum Computer Systems, Spring 2021 and 2022
  University of Chicago, Computer Science (CMSC-22900/32900/EdX, undergrad/grad)
• Instructor for STAQ Summer School, Summer 2020 and 2021
  Virtual lectures on fundamentals of quantum computer architecture for undergrad, grad and industry participants
• Volunteer Instructor for CompileHer Tech Capstone, April 2019
  CompileHer Tech Capstone at UChicago introducing middle school girls from Chicago to computer science topics
• Teaching Assistant for Computer Architecture, Fall 2019
  University of Chicago, Computer Architecture Class (CMSC-22200, undergrad upper-division)

Service

Paper reviewer for Journals, including PRX Quantum, TQC, IEEE Micro (2021), and TODAES (2022). Program Committee member for QCE22 (Quantum Algorithms and Applications track).

Work Experience

• QuEra Computing — Quantum System Architect, Oct. 2022–present
• Google AI Quantum — Research Intern, Summer 2018 and 2019
  2019 — Architected core support for qudits (qubits with more than two states) in Cirq.
  2018 — Designed a novel quantum circuit optimization algorithm, also contributed to Cirq.
• Alto Robotics (Warehouse Automation Robotics Startup) — Co-Founder, Apr. 2016–Oct. 2017
  Robotics design including power systems, PCB layout, and firmware of a new industrial robotics system for the warehouse.
• Stealth Startup (Radio Consumer Product) — Technology Consultant, Aug. 2016–Mar. 2017
  Product design advice and PCB design for radio technology prototypes.
• Pioneers in Engineering (Student Outreach Org.) — Project Manager, Jan. 2013–May 2016
  Led and taught a team of other students in firmware and PCB design and designed a smart-sensor real-time serial protocol for our custom robot platform. PiE is a UC Berkeley, student-run robotics competition for high school students.
• Fetch Robotics — Electrical Engineering Intern, Jan. 2016
  Troubleshot and repaired embedded firmware for robots.
• Morpho Detection — Engineering Intern, Summer 2015
  Designed and tested a prototype component for the high-speed X-ray scanning pipeline of airport baggage CT scanners.
• Cyber-Physical Cloud Computing Lab at UC Berkeley — Undergrad Researcher, Summer 2014
  Research toward more flexible and enhanced sensor fusion in quadcopters.
• Poly-PEDAL Animal Locomotion Lab at UC Berkeley — Undergrad Researcher, Aug. 2013–2014
  Rapid prototyping of low-cost robots. Mechanical strategies to flip when inverted.
• Intel — Engineering Intern, Jan. 2013 & Summer 2013
  Projects in perceptual computing and advanced user interfaces. Hardware prototype of a user interface device.
• ThinkOptics — Primary iOS Developer, Oct. 2009–Aug. 2012
  Built several iOS apps to work with the company's iPhone accessory.

Contact

Email me to connect. I'm happy to talk about anything, including research, teaching, art, tools, jobs, or freeskating. For software bug reports, please open a new issue on GitHub.

(Click to send mail) scrambled: < .@Eaccggiiiklmmnou>