nix-typst-resume/resumes/full/main.en_US.md

• Computer Science Fast Track Program (Systems Track)
• Collegium V Honors Program, National Merit Scholars Program

• AP Computer Science (Perfect Score), AP Scholar with Distinction, National Merit Finalist

• Assist with foam party operations.

• Trace GNU Core Utilities using a Valgrind tool by modifying the test suite.
• Add features to a graph visualization platform designed for viewing system events.

• Taught JavaScript to middle school students with other instructors.

• Implemented API endpoints for data operations, multifactor authentication, and document conversion.
• Rewrote a book-viewing web UI to support document viewing, sharing, and annotation.
• Automated updates of email templates in an SQL database using PowerShell scripts.
• Documented all activities through Jira and GitHub pull requests.

• Oversaw server upgrades and ensured smooth transitions for running programs.
• Developed a C# program to fetch song lyrics and metadata from an API for integration with the main product.
• Automated builds for a server application with Docker.

• Rapidly cooked orders including sandwiches and fried goods.
• Restocked and cleaned the kitchen as needed.
• Coordinated tasks with other team members to ensure teamwork efficiency.

• Recorded orders and took payments.
• Cooked french fries. Prepared drinks and frozen goods.
• Cleaned the kitchen as needed.
• Coordinated tasks with other team members to ensure teamwork efficiency.

• Quickly initialize a development environment with a lightweight text editor, syntax checking, grammar checking, formatting on save, and linting on commit.
• Expose per-project toggles to enable languages, specify project settings, and add words to the project's dictionary.
• Abstract the complexities of generating interdependent configurations behind a user-friendly API.
• Separate complex feature implementations into Nix flake-parts modules.

• Extend the GNU Core Utilities test suite to trace the programs using a Valgrind tool.

• Added label customization options to the system event visualization platform.
• Improved development workflows by adding formatter support and shared libraries.
• Documented bugs and to-do items on GitLab and in-file comments.

• Manage many résumés by moving shared components to a central collection of modules. Each résumé picks and customizes its own set of modules. Updating one module will update data across all résumés that use the module.
• Ensure consistent formatting by printing components through reusable Typst functions.
• Automate dependency and workspace management to prepare all tools needed to update the résumés, including a lightweight text editor, previewer, and grammar checker. Lock versions of all tools using Nix Flakes to ensure consistency across different setups. Configure build steps for seamless integration with my NixOS-based web server.
• Enable multilingual support through linguify.

• Manage device configurations through a set of configuration files.
• Group configurations of related programs into modules. Each device chooses which modules to use. Updating a module shared between devices updates settings on both machines.
• Lock program versions using Nix Flakes, improving consistency and allowing rollbacks.

• Contain my files, tasks, projects, passwords, and other data on a self-managed server machine.
• Host websites publicly using a VPN running on Hetzner to work around apartment network limitations.
• Orchestrate program configurations through Docker Compose and NixOS. Automate deployment of DNS settings and Hetzner configurations using Terraform integrations.
• Simplify deployment and use of separate operating systems through the Proxmox hypervisor.

• Duplicates key-value pairs across three servers to tolerate up to two failures, using an architecture based on the one in Amazon Dynamo. Servers connect cyclically, and three adjacent servers store data assigned to a certain hash value, two of which allow writing. When one server fails, the neighboring servers will connect to each other until the server recovers. Upon recovery, the server receives and applies the missed transactions.
• Demonstrated total ordering of transactions, even under a high load. A coordinator node spawns servers and simulated clients on different machines. A REPL interface interprets commands to add data, show data, and simulate failures and recoveries.
• Responds to queries asynchronously using the Tokio runtime to boost performance.
• Translates raw TCP data to Rust objects using Serde to ensure type safety.

• Analyzed vulnerable C programs using GDB, Radare2, and other tools. Exploited them with pwntools using buffer overflow, return-oriented programming, shellcode injection, and other techniques.

• Implemented causally ordered delivery of messages sent between nodes in Rust using the protocol described by Raynal and Schiper in “The causal ordering abstraction and a simple way to implement it.”
• Later, implemented totally ordered delivery of messages using a sequencer-based implementation based on the “Causal ABCAST Protocol” described by Birman in “Lightweight causal and atomic group multicast.”
• Wrote reports with diagrams of the program architecture using LaTeX with TikZ.

• Learned basic theoretical database concepts. Created a basic Twitter clone using PHP, MariaDB, Tailwind CSS, Nix, and devenv.
• Wrote a report using LaTeX and TikZ containing diagrams and tables for ER, database schema, system architecture, interface requirements, data dictionary, business rules, 3NF normalization, database initialization code, setup instructions, and screenshots.

• Designed an arithmetic logic unit (ALU) with a group using Verilog and Python.
• Implemented ALU functions as circuits in a lab environment with a group.

• Reads a list of jobs and outputs the result of scheduling them using First Come First Serve (FCFS) and Round-Robin (RR).

• Simulated doctor visits using semaphores to ensure they happen with mutual exclusion.

• Simulates a CPU and memory in C using threads and pipes. The program loads a file with instructions into the memory and executes them.

• Wrote programs demonstrating signals, sockets, semaphores, threads, pipes, and other functions.

• Learned MIPS assembly basics. Wrote a basic Tetris clone.

• Stores and displays scores for high school sports games. Provides a panel for coaches to submit updates.
• Uses cookie-based user authentication and secure password storage practices.
• Automated deployment using Dokku with GitLab CI/CD.

• Enables basic Git functions on Zip archives. Designed to synchronize .ev3 files for FIRST LEGO League between different computers and allow modifications on separate programs.

• Lead an effort to give unhoused populations access to food and household products.

• Help leaders and other volunteers run biweekly efforts to give those struggling financially access to food, clothes, and household products.

• Submitted over 3000 contributions through Street Complete.

• Led the group's coordination of music-related events as President, Vice-President, and Secretary.
• Improved meeting efficiency by enforcing Robert's Rules of Order.

• Performed in marching band, pep band, and concert band as a trombonist.
• Performed three times in the Boise State University (BSU) All-Star Honor Band and once in the BSU Blue Thunder High School Honor Marching Band.

• Programmed an Android-based robot to navigate around a field and move objects to score points.
• Detected object placement at the beginning of the match using EasyOpenCV.

• Programmed a LEGO robot to autonomously navigate a board and complete challenges. Improved precision to <1 cm variation per meter using sensor feedback and mechanical design techniques.
• Created functions to translate real-world distances to motor rotations. Designed a menu to quickly run match and sensor calibration programs.
• Wrote a utility to synchronize robot programs between computers by extracting them to a format compatible with Git.
• Helped the team receive many awards, including the state championship, regional championships, and state programming awards.