Ty Overby

Experience

Microsoft Redmond Software Developer 2 Autumn 2015 - now

As a developer on the Roslyn Compiler for C# and Visual Basic, I participated in language design, implemented language features, found/fixed bugs, and worked on improving the user experience for the compiler developers and users on Linux. I took the "async Main" language feature from concept to its release in C# 7.1. In order to prevent compiler performance regressions, I built a performance testing automation system which would run perf tests on every checkin (and optionally on any pull request).

As a member of an internal "Infrastructure Swat Team" I spent roughly ⅓ of my time on point for all performance investigations in the product. While conducting performance analysis, I learned how to debug from heap dumps as well as how to collect and analyze performance traces on Windows. Because of my involvement, Visual Studio was able to ship on time and with fewer perf regressions. Before switching teams internally, I successfully trained another employee to take over my position.

As a developer on the try.dot.net team, I helped build and maintain a full stack service for evaluating C# from the browser. It required frontend development for the web portal (Typescript and React/Redux), backend web servers / services in C#, and integration with many Azure services. While preparing for a major conference where our software would be demoed, I built a simulator for evaluating the reliability of our service under heavy load. This simulator discovered a flaw in our scaling algorithm which we were able to fix in time for the conference.

Google Seattle Software Developer Intern Summer 2014

As an intern on the Dart language compiler, I instrumented the compiler to produce metadata alongside a compilation. I also built an in-browser visualizer that consumed the metadata. With the metadata and visualizer, it became possible to answer questions about the compilation such as "what is the inferred type of this variable", "why was this function not tree-shaken out of the compilation", and "which functions are the most responsible for code bloat after tree shaking occurrs". The tool found many bugs in various parts of the compiler ranging from type inference to tree shaking to optimizations and emit.

Google Seattle Software Developer Intern Summer 2013

As an intern on the Google Chrome Audio/Video team, I built a diagnostics tool inside of Chrome for collecting and reporting information about the media streams that are currently live in the browser. This tool is still available and in use at chrome://media-internals/

Education

University of Washington Seattle BS in Computer Science June 2012 - May 2015

Tools

I know enough about Git to get coworkers (and myself) out of tricky situations.

Five years of using Rust and I'm still loving every day of it!

Professional experience developing, debugging, and profiling C#, Visual Basic and F#.

Over a decade of Linux (Debian and Ubuntu ) on the desktop, 9 years of OS X on a macbook, and 3 years of Windows at work for development.

Interests

Ever since I started programming, I've been interested in programming languages and how they can be made more user friendly. I've worked on countless personal language experiments and several production compilers and their IDE tooling.

I have a strong interest in functional programming and would like to spend a good chunk of my next job writing and developing tools for functional languages.

I'm a hobby carpenter and leather worker in need of a workshop!

Personal Projects

Ares III github.com/tyoverby/ares-3 Rust ??? - Present

Ares is a never-ending language experiment of mine that I've re-written from scratch multiple times. Ares is a functional language with a focus on first class control flow via delimited continuations (with named prompts). While I worked on production grade compilers (C# and VB), Ares was a nice project to come back to and toy with different IRs, different parsers, and different emit strategies.

My most recent endevor is adding an IR inbetween parsing and binding that converts the program to Continuation Passing Style. I've been reading Compiling with Continuations by Appel and I might wind up just re-implementing that book inside Ares as a way to better understand it.

Right now Ares is strongly dynamically typed, and I didn't plan on adding a static type system to it, but I've been reading about row polymorphism recently, so...

Bincode github.com/tyoverby/bincode Rust September 2014 - Present

Bincode is a Rust project for serializing and deserializing structures to and from a binary format. Because it takes advantage of some compile-time features of Rust, it can generate an encoding scheme specifically for each struct that it needs to work with! This means that it can avoid emitting structural information into the output, leading to very small serlization sizes and fast serialization and deserialization.

Bincode has been used in production by a multitude of projects including

google/tarpc: Bincode is used to serialize and deserialize networked RPC messages.
servo/webrender: Bincode records webrender API calls for record/replay-style graphics debugging.
servo/ipc-channel: Ipc-Channel uses Bincode to send structs between processes using a channel-like API.

I'm especially excited to start tuning Bincode for the Firefox/Quantum work where (to my understanding) Bincode is the format for transfering GPU commands between processes.

Implicit github.com/tyoverby/implicit-gpu Rust, TypeScript, OpenCL December 2016 - Present

Implicit is the latest iteration of a 2D CAD (Computer Aided Design) program that I've been developing for use with laser cutters and pen plotters. It features a TypeScript API where the user designs their shape in a purely functional style building shapes out of other shapes using Constructive Solid Geometry by representing these shapes as Implicit Surfaces.

Because of the nature of Implicit Surfaces, sampling the equation at millions of points is required in order to get paths for vectorization. This sampling is often the bottleneck in large drawings, so I've experimented with many optimizations in order to achieve the performance that I need. These experiments include:

Thread-Based Parallelization using the Rust parallelization library Rayon
Instruction-Level Parallelization using explicit SIMD
Compiling the Implicit Surface formulas to OpenCL and then evaluating them on the GPU
Compiling the formulas to machine code via a JIT Compiler

The interface for the CAD software is an in-browser IDE written in TypeScript and React. It has an in-browser editor with autocomplete and diagnostics, as well as a live preview of the scene that is being rendered. When launched in developer mode, the IDE comes with an integrated performance visualizer - great for finding out why an operation took longer than expected!