Ryan Fox

Work Experience

Octopart (Altium) - Senior Software Engineer III, 2019 - 2020

  • Implemented a new backend API for both internal and third-party access to Octopart's vast amounts of data using Go and GraphQL.
  • Seemlessly integrated data from partners' APIs to allow for real-time updates to Octopart's dataset.
  • Set up infrastructure instrumentation for better monitoring and analysis.
  • Mentored newly graduated engineers in software design and idiomatic programming and infrastructure practices.

Upverter (Altium from 2017) - Senior Software Engineer, 2012 - 2019

  • Developed automated electronic design tools using geometry and graph algorithms in Python and JavaScript.
  • Reverse-engineered other tools' file formats to allow users to migrate their data both into and out of the Upverter ecosystem.
    • Approaches to extract data included: mapping out the binary format of files, exploiting diagnostic tools, automating user interfaces, and using built-in scripting languages.
  • Extended and integrated ngspice (an electronics simulator) and ADMS (a Verilog-A transpiler) into Upverter to allow users to verify their designs.
  • Periodically profiled our code to find memory and run-time performance optimizations.
    • On a few occasions, I worked with the authors of third-party libraries to address performance issues in their code.
  • Assured code quality through rigorous code review and by annotating the JavaScript code base with static type checking directives.
  • Mentored more than 10 engineering student interns and 3 junior employees.
  • Contributed new features, bug fixes, and performance optimizations to open-source projects:
  • Produced thorough documentation and training on Upverter's internal design after its acquistion by Altium in 2017.

Research in Motion - Embedded Software Developer, 2010 - 2012

  • Optimized QNX audio hardware drivers written in C for power consumption and audio quality.
  • Created analysis tools to find potential memory optimizations in a memory-constrained DSP, enabling advanced features which had been previously deemed impossible to fit into memory.
  • Created scripts to automatically generate C code for use in the build process.

University of Waterloo - UAV Research Assistant Co-Op, 2010

  • Configured and compiled QNX for PowerPC soft-cores synthesized on a Xilinx FPGA.
  • Researched and conducted experiments with high-speed, Gigabit Ethernet cameras.
  • Integrated the computer and camera systems into a remote-controlled air plane.
  • Developed firmware in C to read from an infrared sensor and relay the data to the main computer.

General Dynamics Canada - Electronic Specialty Engineering Co-Op, 2009

  • Maintained design schematics using Mentor Graphics' Design Architect.
  • Automated several lengthy tasks using Excel macros, AMPLE and Perl scripts, reducing completion time from 8+ hours to around 30 seconds.

Research in Motion - Conceptual Hardware Designer Co-Op, 2008

  • Drew schematics and circuit boards for new BlackBerry prototypes using Mentor Graphics Design Architect and Board Station.
  • Selected parts and designed a power supply for a LCD backlight.

Research in Motion - Software Tools Developer Co-Op, 2006 - 2007

  • Wrote and maintained a multi-threaded tool in C++ to load signed code onto several BlackBerry devices simultaneously during manufacturing.
  • Created C# libraries for use in manufacturing testting procedures and internal operating system development.
  • Created a program to parse C++ structure hierarchies and generate C++ code to produce trees representing the hierarchies.

Wired on Caffeine - Co-Founder, 2003

  • Founded and managed all aspects of an internet cafe.
  • Assembled three computer terminals for public use on a high-speed Internet connection.
  • Designed and developed a program in Visual Basic to track sales, calculate change due and record tax information.
  • Conducted sales, assisted with technical problems and interacted with customers.

University of Waterloo

  • Bachelor of Applied Science -- Honours Computer Engineering, Class of 2011

Warframe API Python Library

  • By reverse-engineering the Warframe mobile app, I was able to make a library to interact with the game's internal API.
  • The library doesn't facilitate cheating, but it can be used to view hidden data about your account, and can allow automation of some tedious tasks in the game.
  • Source: https://github.com/cephalon-sofis/warframe_api
    • (A new GitHub account was created for this project so that it wouldn't be directly associated with my in-game account.)

Power Metal Ranker

  • Two songs are presented, the user selects which they like better. The results are stored in order, and two more results are shown.
  • As the list grows, songs from within the list are strategically chosen to minimize the number of comparisons in order to place new songs in their correct positions.
  • New songs to insert are drawn from submissions to the /r/PowerMetal subreddit.
  • Source: https://github.com/rcfox/Power-Metal-Ranker
  • Demo: https://rcfox.ca/Power-Metal-Ranker/

ngspice / ADMS

  • Open-source tool for transpiling analog circuit designs written in Verilog-A into C code.
  • The C code is compiled and linked into ngspice, which can then simulate the circuit as if it were a native component.
  • Source: https://github.com/upverter/ADMS/tree/upverter

AI Aquarium

  • Experiments in writing goal-oriented aritifical intelligence for characters in a video game world.
  • AI tasks involved world exploration, resource gathering, and battles.
  • Written in Perl, C, and Scheme.
  • Demos: https://rcfox.ca/ai-aquariums/


  • Nine-day joint effort with a friend to create a 3D roguelike game using C++ and OpenGL.
  • Features a turn scheduler with non-uniform action costs, and a domain-specific language for designing in-game combat abilities.
  • Source: https://github.com/NineDayGame/NineDayGame

Application-Specific Processor Instruction Set Extensions

  • Created a system to dynamically analyze programs running in an ARM7 simulator to find common patterns of instructions executed.
  • Based on a the results, new instructions could be added to the simulator to batch the common instruction patterns into a single instruction.
  • In our target case of an edge-detection program, our system found a new instruction that increased performance by 10%.