The Resume of 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.

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.

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.

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.

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.

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.

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.

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.

Education

Projects

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

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

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