Past Projects Repository

A collection of projects I've worked on in the past

Welcome to my portfolio repository! This repository contains a collection of projects I was involved in that showcase my skills in software development, problem-solving, and creativity. Each project includes its source code, setup instructions and a brief description.

Ryan's AI Job Application Tailor

🔗 GitHub Repository: (https://github.com/MoltoRubato/JobApplicationTailor)
🔗 Live Demo: (https://job-application-tailor.vercel.app)

Overview

A smart web application that helps job seekers create tailored cover letters and CV bullet points using AI. Simply upload your resume, paste a job description, and get personalized application materials in seconds. Built as a way to experiment with AI APIs and explore wrapping them into a real project.

Key Features

• Resume Upload: Support for .txt and .pdf file formats
• Job Description Input: Paste any job description to tailor your application
• AI-Generated Content: Creates custom cover letters and CV bullet points using GPT-4.1
• Application History: Track your previous applications
• Responsive Design: Works seamlessly across desktop and mobile devices

Technologies Used

• Frontend: React.js with Vite, Tailwind CSS, Lucide React
• Backend: Node.js, Express.js
• AI Integration: GitHub AI API (GPT-4.1)
• Deployment: Vercel

---

My Personal Website - Interactive Portfolio

🔗 GitHub Repository: (https://github.com/MoltoRubato/MyWebsite)
🔗 Live Website: (https://ryanhuang.work)

Overview

My pixel-art style interactive portfolio website featuring a 2D game environment where visitors can explore and learn about my projects, background, and contact information. Navigate through a cozy room and interact with NPCs representing different sections.

Key Features

• Interactive 2D Environment: Navigate through a cozy room using WASD or arrow keys
• Character Interactions: Meet NPCs representing different sections (Projects, About, Contact)
• Interactive Elements: Pet animals, play music on a gramophone
• Responsive Design: Clean modal system for content display
• Pixel Art Aesthetic: Custom sprites and animations throughout

Technologies Used

• Frontend: HTML5, CSS3, JavaScript (ES6+)
• Graphics: HTML5 Canvas API for 2D rendering
• Audio: Web Audio API for background music
• Assets: Custom pixel art sprites and animations

---

Droning On - Drone-Based Parcel Delivery Simulation

🔗 GitHub Repository: (https://github.com/MoltoRubato/Drone_delivery_system)

Overview

A drone-based parcel delivery simulation system developed for Delivering Solutions Inc. (DS). It models the behavior of a fleet of delivery drones operating from a dispatch center to suburban homes, simulating parcel deliveries in compliance with Australian Government regulations.

Key Features

• Drone Movement & Navigation: Drones fly exclusively over mapped roads for safety, moving step-by-step along linked structures
• Parcel Delivery Workflow: Drones cycle through defined states from dispatch to delivery and return
• Parcel Types: Distinguishes fragile and heavy parcels, affecting drone speed and delivery priority
• Contention Management: Dispatch center manages access requests with priority-based resolution
• Priority Access System: Grants location access based on parcel type and drone position
• Simulation Time-Stepping: Discrete time-step operations with detailed logging and statistics

Technologies Used

• Java 11+
• Gradle
• State Machine Design Pattern
• Linked Data Structures

---

Pinochle Game

🔗 GitHub Repository: (https://github.com/MoltoRubato/Pinochle)

Overview

A digital implementation of the classic Pinochle card game developed for CardCraft Studio, Melbourne. This project improves upon the original version's design and maintainability issues while preserving the original gameplay experience.

Key Features

• Two-Player Gameplay: Human player vs. computer player with GUI interface
• Full Pinochle Support: Standard melds, scoring, bidding, and trick-taking mechanics
• Smart Computer Player: Improved bidding strategy and trick-taking with card memory
• Cut-Throat Mode: Includes stockpile card draw phase and card discarding
• Auto-Play Mode: Configurable testing mode with different player types
• Extendable Design: Modular architecture for future enhancements

Technologies Used

• Java 11+
• JGameGrid Library
• Gradle Build System
• GUI Interface

---

Virtual Memory Manager

🔗 GitHub Repository: (https://github.com/MoltoRubato/Memory_manager)

Overview

A C program that simulates a virtual memory management system with TLB (Translation Lookaside Buffer) and page table for address translation, implementing FIFO page replacement and LRU TLB replacement algorithms.

Key Features

• Address Translation: Converts logical addresses to physical addresses using TLB and page table lookups
• Memory Configuration: 4MB logical space, 1MB physical space, 4KB page/frame size
• FIFO Page Replacement: First-In-First-Out algorithm for page eviction when memory is full
• TLB Integration: 32-entry Translation Lookaside Buffer with LRU replacement policy
• Multiple Tasks: Four progressive implementations from basic parsing to full TLB integration

Technologies Used

• C Programming Language
• GCC Compiler
• Make Build System
• Memory Management Algorithms

---

htproxy - HTTP/1.1 Web Proxy

🔗 GitHub Repository: (https://github.com/MoltoRubato/Web_proxy)

Overview

A simple caching web proxy for HTTP/1.1 requests written in C, implementing intelligent caching strategies and HTTP compliance. Features multi-stage development from basic proxying to full HTTP-compliant caching.

Key Features

• Basic Proxying: Forwards HTTP GET requests to origin servers with IPv4/IPv6 support
• LRU Caching: Least Recently Used cache with 10 entries and intelligent eviction
• HTTP Compliance: Respects Cache-Control headers and HTTP caching directives
• Cache Expiration: Implements max-age directive support with automatic stale entry handling
• Detailed Logging: Comprehensive request/response logging for debugging and monitoring

Technologies Used

• C Programming Language
• POSIX Sockets
• HTTP/1.1 Protocol
• GCC Compiler

---

Cyclops Crashout

🔗 GitHub Repository: (https://github.com/MoltoRubato/CyclopsCrashout)
🔗 Itch.io Page: (https://moltorubato.itch.io/cyclops-crashout)

Overview

Cyclops Crashout is a two-player fighting game where a wandering knight faces off against a monstrous Cyclops warrior in an epic duel for survival.

Gameplay Features

• Objective: Defeat your opponent in a one-on-one battle of strength and strategy.
• Combat System: Precise timing and movement to outplay your opponent.
• Visual Style: Retro pixel-art with gritty, fantasy aesthetics.
• Audio Design: Fully self-made SFX and original soundtrack to enhance the atmosphere.
• Winning Condition: Deplete your opponent's health bar to claim victory.

Technologies Used

• Unity
• C#

---

ShadowTaxi

🔗 GitHub Repository: (https://github.com/MoltoRubato/ShadowTaxi)

Overview

ShadowTaxi is a survival-based game where players navigate the challenges of being a taxi driver during an economic crisis. Manage resources, avoid hazards, and deliver passengers safely to achieve a target score before time runs out.

Gameplay Features

• Objective: Earn 500 points within 15,000 frames by completing trips and collecting coins.
• Core Mechanics:
  • Drive using arrow keys, pick up passengers, and deliver them to designated flags.
  • Collect coins to increase trip earnings.
• Hazards: Enemy vehicles damage the taxi, driver, and passengers on collision.
• Health System: If the driver, passengers, or taxi lose all health, the game ends.
• Taxi Replacement: A new taxi spawns if the current one is destroyed. The driver must board it before it leaves.
• Winning: Reach 500 points before time runs out.
• Losing: Time expires, health depletes, or a new taxi leaves without the driver.

Technologies Used

• Java
• BAGEL (Java Game Engine Package)

---

Chessformer Puzzle Solver

🔗 GitHub Repository: (https://github.com/MoltoRubato/Chessformer-Puzzle-Solver)

Overview

Chessformer Puzzle Solver finds the shortest path to solve Chessformer puzzles using an optimized search algorithm with hash-based duplication detection.

Features

• Objective: Solve puzzles efficiently by finding the shortest path.
• Core Mechanics:
  • Execute ./chessformer <map> to play manually.
  • Run ./chessformer -s <map> play_solution to solve and animate the solution.
• AI Solver:
  • Expands and evaluates possible moves.
  • Detects duplicate states to avoid redundant calculations.
• Output: Generates solution.txt with:
  • Expanded & generated nodes.
  • Duplicated nodes.
  • Solution length & efficiency metrics.

Technologies Used

• C

---

Bookstore Data Processing & Recommendation System

🔗 GitHub Repository: (https://github.com/MoltoRubato/Book-data-recommendation)

Overview

This project involves analyzing datasets containing information about books, users, and their reviews from an online bookstore. The goal is to extract actionable insights that can help the bookstore managers make decisions about future book acquisitions and recommendations.

Datasets

1. Main Datasets:

   • BX-Books.csv: Details of 18,185 books, including ISBN, title, author, year of publication, and publisher.
   • BX-Users.csv: Information about 48,299 users (ID, city, state, country, age).
   • BX-Ratings.csv: User ratings of books (user ID, ISBN, rating).

2. Recommendation Datasets:

   • BX-NewBooks.csv: Information on 8,924 new books.
   • BX-NewBooks-Users.csv: Information on 8,520 users with existing rating histories.
   • BX-NewBooks-Ratings.csv: Actual ratings for new books.

Key Tasks

1. Data Preprocessing: Apply at least three preprocessing techniques, such as data imputation, scaling, encoding, or text processing.
2. Machine Learning Implementation: Use at least two supervised/unsupervised models to answer your research question. Alternatively, implement a recommendation system.
3. Insights and Evaluation: Interpret and analyze results to derive meaningful insights and evaluate the models’ performance.

Tools used

• Python
• pandas, numpy, re, matplotlib, sklearn, seaborn, nltk

Methods used

• Data Cleaning
• Fuzzy Matching
• KNN Imputation
• Encoding
• Feature Selection using Mutual Information
• Cross Validation
• Supervised Data Modeling (Decision Trees, K Nearest Neighbours)

---

Dictionary with Linked List and Patricia Tree

🔗 GitHub Repository: (https://github.com/MoltoRubato/Patricia-Tree-Dictionary)

Overview

This project involves implementing a dictionary in C using two data structures: a linked list and a Patricia (radix) tree. The dictionary supports search functionality, including handling exact matches, similar matches, and no-match scenarios, with a focus on efficiency and complexity analysis.

Features

1. Linked List Dictionary

   • Stores data records as a linked list.
   • Counts binary, string comparisons, and node accesses during search operations.
   • Outputs metrics for key lookups.

2. Patricia Tree Dictionary

   • Implements a radix tree for efficient key lookup.
   • Includes spellchecking functionality to suggest the closest match based on edit distance.
   • Records metrics such as comparisons and node accesses during queries.

3. Complexity Analysis

   • Compares time and memory complexities of the linked list and Patricia tree implementations.
   • Analyzes theoretical and practical efficiency across various test cases.

Implementation Highlights

• Modular Design: Separate .c and .h files for dictionary operations.
• Space-Efficient Storage: Optimized memory allocation for strings.
• Single File Read: Input data is processed in one pass.
• Comparison Metrics: Tracks binary, string, and node comparison counts.

Tools used

• Programming Language: Written in C with modular design principles.

---

Suburb Dictionary Manager

🔗 GitHub Repository: (https://github.com/MoltoRubato/Suburb-Dictionary-Manager)

Overview

This project implements a dictionary using a linked list to store and manage information about Australian suburbs. The dictionary supports data lookup and deletion by keys. It processes a structured dataset and provides efficient tools to manipulate and extract data.

Features:

Data Structure

• Linked List Implementation: Stores each suburb record as a node in a linked list.

Operations

1. Search Tool:

   • Finds all records matching a key (suburb name).
   • Outputs matching records to a specified file.
   • Displays the number of matches found.

2. Removal Tool:

   • Deletes all records matching a key (suburb name).
   • Outputs remaining records to a new CSV file.
   • Displays the number of records deleted.

Data Format

• Reads from CSV files with 10 fields including suburb codes, names, geographic coordinates, and administrative divisions.
• Handles special cases like strings with commas and ensures data is stored efficiently.

Implementation Details

• Programming Language: Written in C with modular design principles.
• File Processing:
  • Reads input data once for efficiency.
  • Outputs data preserving the order from the input file.
• Space-Efficient Strings: Dynamically allocates memory for strings to minimize space usage.
• Multiple Dictionaries: Designed to support multiple dictionaries.

---

Smart Home App Design Project

🔗 GitHub Repository: (https://github.com/MoltoRubato/Smart-Home-App-Design)

Overview

This project explores the design of a smart home app aimed at users who frequently travel or leave their homes unoccupied. The app focuses on providing seamless home security and maintenance functionalities, ensuring users can monitor and manage their homes remotely. The project is based on user research and iterative design processes.

1. Motivations and Background Report

• Discusses the rationale for the app, highlighting the need for home security and maintenance solutions for frequent travelers.
• Outlines background research, including surveys, interviews, and participatory design methods, that informed the app's concept.

2. Design Report

• Details the design process, including system requirements, personas, and use cases.
• Includes wireframe prototypes and descriptions of app features.
• Covers design decisions made based on user feedback and usability considerations.

3. Personal Report

• Reflects on individual team members' contributions and findings.
• Summarizes insights gained during the project, including challenges and lessons learned.

Key Features of the App

• Security Features: Access to live camera feeds, emergency notifications, and remote control of smart devices.
• Maintenance Features: Tools for managing plants, pets, and other household systems requiring upkeep.
• User-Friendly Design: Intuitive navigation, FAQ section, and support for users with varying technical expertise.

Tools used

• Figma, Miro

---

Sound Design Concept for NASA: Eyes on Exoplanets

🔗 GitHub Repository: (https://github.com/MoltoRubato/NASA_Sound_Design_Project)

Overview

This project proposes a sound design to accompany NASA’s interactive 3D web application, "Eyes on Exoplanets", to enhance user immersion. The soundscape aligns with the tranquil and expansive nature of space, creating a hypnotic, introspective atmosphere.

Key Features

• Genre: Space Ambient
  • Smooth tones, layered textures, and lack of consistent beats to complement the vastness of the universe.
• Key: G Major
  • Chosen for its tranquil and harmonious qualities.
• Dynamic Soundscape:
  • Varies based on zoom level: "Planet," "Planetary System," or "Universe."
  • Interactive sound layers change density and complexity as users explore.

Components

1. Bass

   • Planet: Dark Glide Bass
   • Planetary System: Crystal Spheres
   • Universe: Morning Meditation, augmented with recorded fan sounds for a deep oscillating drone.

2. Melody

   • Melody #1: Final Twilight, Crystalline Structures, and Stratosphere for an ethereal effect.
   • Melody #2: Beyond Deep Skies, Cinematic Suspense, and Dusty Strings for a dispersed, harmonious tone.

3. Effects

   • Air Bells: Resonate like twinkling stars.
   • Shifting Panels: Dynamic synthesizer tones to illustrate the universe's fluidity.

Technical Details

• Software: GarageBand
  • Public sound library and recorded samples are used.
• Volume & Panning:
  • Oscillating automations for a sense of motion and evolution.

---

Taxi Trip Data Analysis Assignment

🔗 GitHub Repository: (https://github.com/MoltoRubato/Taxi-Trip-Data-Analysis)

Overview

This project analyses taxi trip data using Python's pandas, matplotlib, and re libraries. The dataset used consists of taxi trips data from January, stored in a CSV file, and the goal is to extract insights, visualize patterns, and evaluate data quality.

Tasks Overview

Task 1: Loading Data and Adding a Column

• Objective: Load the trips_january.csv file into a pandas DataFrame, compute the duration of each trip, and add this as a new column trip_duration. Output the number of records and the mean trip duration in a JSON file.

Task 2: Data Quality

• Objective: Identify abnormal trip distances (values not in the range [0.1, 17.3]) and compute their percentage.

Task 3: Data Visualization using Boxplots

• Objective: Create two boxplots comparing trip fares for the morning (07:00 - 11:00) and afternoon (12:00 - 15:00) periods. Output a PNG file of the boxplots.

Task 4: Days of the Week Behaviour

• Objective: Add a column isWeekend to the DataFrame to mark weekends (1) and weekdays (0), then calculate the percentage of weekend trips.

Task 5: Hourly Behaviour

• Objective: Add a column hour indicating the hour the trip started, then generate two histograms showing the frequency of taxi trips over the hours of the day, one for weekends and one for weekdays.

Task 6: Scatter Plot

• Objective: Compute and plot a scatter plot showing the mean trip distance vs. the mean total amount for each day of the week. Each day should be plotted in a different color.

Task 7: Pie Chart

• Objective: Create a pie chart representing the mean trip duration for each day of the week, with percentage values and day labels.

Tools used

• Python
• pandas, re, matplotlib

---

DBS_Modeling

🔗 GitHub Repository: (https://github.com/MoltoRubato/EV-database-modelling)

Overview

This project is a MySQL-based relational database design for an electric vehicle (EV) charging station system. The system manages information about charging stations, electric vehicles, charging events, and associated facilities such as cafés or restaurants. The database supports querying for various business requirements like tracking charging station ownership, electric vehicle usage, and facility-related discount coupons.

Key Features

• Charging Stations: Stores information about charging stations, including address, operating hours, and associated outlets. Each outlet has unique charging rates and costs for peak and off-peak hours.
• Electric Vehicles: Tracks EVs by VIN, manufacturer, model, battery capacity, and the company that manufactures them.
• Charging Events: Records each charging event, including which outlet was used, start and end times, and any discount coupons applied.
• Facilities: Manages facilities (like cafés or restaurants) that may be associated with charging stations, including discount coupons for charging events.
• Companies: Tracks companies manufacturing EVs, their CEOs, and their involvement in owning charging stations.

Models

• Conceptual Model: Designed using Chen's notation, representing the business entities and their relationships.
• Physical Model: Implemented in MySQL Workbench using Crow’s Foot notation, providing the detailed database schema.

Business Requirements

The database supports various queries including:

• Ownership tracking for companies like Tesla.
• Finding charging stations with specific facilities (e.g., cafés).
• Calculating total income from charging outlets.
• Managing charging event details and associated discounts.

Tools Used

• MySQL Workbench for database modeling.

---

Conference Track-r SQL Assignment

🔗 GitHub Repository: (https://github.com/MoltoRubato/Conference-Track-r-SQL)

Overview

Conference Track-r is a platform designed to track academic conferences, paper submissions, and researcher activities. It manages data about conferences, tracks, sessions, researchers, and papers, including submissions, reviews, presentations, and author-supervisor relationships.

Key Features

• Conferences: Tracks event details such as location, dates, and session organization.
• Tracks: Each conference has multiple tracks with paper submission guidelines.
• Sessions: Each track contains sessions for paper presentations, with time allocated for each paper.
• Researchers: Manages researcher data, including their supervision relationships and attended conferences.
• Papers: Tracks paper submissions, their review outcomes, and assigned sessions for presentation.

Database Model

The system uses an ER model to define relationships between conferences, tracks, researchers, papers, and sessions. The schema supports complex queries about researcher activities, paper submissions, and conference statistics.

Task

Write SQL queries to solve 10 questions, each focusing on different aspects of the system, such as:

• Counting attended researchers for each conference.
• Identifying the researcher with the most "unique" conferences attended.
• Analyzing paper acceptance and rejection statistics.
• Finding relationships between researchers and their influences.

Technologies

• SQL

---

C_assignment: Data Processing and Analysis in C

🔗 GitHub Repository: (https://github.com/MoltoRubato/C_assignment2)

Overview

This project is part of the COMP20005 Introduction to Numerical Computation course. The goal is to implement a generic program in C capable of reading and processing CSV files containing numerical data, while performing various data analysis tasks such as computing averages, generating graphs, and performing statistical calculations.

Features

• Use of arrays of structs in C.
• Apply engineering processes for assembling and testing a non-trivial program.
• Process and manipulate datasets stored in CSV format.

Background

The program will handle CSV files with numerical data, where the first line contains column headers and subsequent lines contain numerical values. The task involves developing commands that compute averages, generate graphs, and perform correlation analysis.

Task Stages:

Stage 1 – Column Averages

Implement a command to compute the average, max, and min of the values in a specified column. Output should be formatted to two decimal places.

Stage 2 – Graphing Distributions

Develop a command to generate a histogram-like graph of values in a specified column, divided into 20 equal regions. The graph should be scaled using a factor to ensure no row exceeds 50 stars.

Stage 3 – More Functionality

1. Category Averages (Command c): Compute averages of a column based on categories defined in another column.
2. Kendall's Tau Correlation (Command k): Calculate the Kendall’s tau correlation coefficient between two columns.

Technologies

• C

---

C_Assignment: International Lecturing Olympics Scoring System

🔗 GitHub Repository: (https://github.com/MoltoRubato/C_assignment1)

Overview

This program processes lecturer class scores and calculates per-class and per-lecturer adjusted average scores. The program then ranks lecturers based on their average scores and determines the top three medalists (gold, silver, and bronze).

Features

• Use of loops, if statements, functions, and arrays
• Implementation of score aggregation and sorting algorithms

Task Description

• Input consists of multiple lines with a lecturer's identifier followed by student scores.
• For each class, discard the two lowest scores, sum the remaining, and compute the adjusted average.
• For each lecturer, discard the two lowest per-class scores, sum the rest, and compute the overall average.
• Rank lecturers by their overall average score, determining the gold, silver, and bronze winners.

Stages

1. Reading the Data: Parse the input, filter invalid classes, and compute per-class adjusted scores.
2. Aggregate by Lecturer: Compute per-lecturer average scores.
3. Rank the Lecturers: Sort and determine medalists, handling ties in scores.

Technologies

• C

---

FOC_Project - Gnome Hat Color Analysis

🔗 GitHub Repository: (https://github.com/MoltoRubato/FOC_Project2)

Overview

This project addresses a logical puzzle involving gnomes in a fairyland who can see each other's hat colors but not their own. Observations (evidences) about hat colors are analyzed to deduce consistent conclusions or identify contradictions. The challenge spans four interconnected questions, each building on the previous.

Problem Setup

• Hat Colors: Encoded as 1 (white) and 0 (black).
• Evidence: A list of tuples containing:
  • A pair of gnome IDs.
  • The number of white hats observed on them (0, 1, 2).

Key Features

1. Contradiction Detection: Identify whether evidences are consistent or contain contradictions.
2. Graph Representation: Model gnome pairs with differing hat colors as a graph.
3. Reasoning with Graphs: Traverse the graph to deduce hat colors using depth-first search (DFS).

Technologies

• Python

---

FOC Questions Repository

🔗 GitHub Repository: (https://github.com/MoltoRubato/FOC_Project1)

Overview

This repository contains solutions to four data science questions focused on time series analysis and wastewater management, inspired by real-world applications.

Questions Covered

1. Pump Operations: Determine how many times a wastewater pump operates given inflow data and tank capacity.
2. Flow Volatility: Measure the volatility of inflows to optimize wastewater treatment efficiency.
3. Next Flow Prediction: Predict the next inflow value using time series similarity.
4. Load Balancing: Minimize volatility in combined wastewater inflows by delaying flows.

Technologies

• Python

---

The Depth Within

🔗 GitHub Repository: (https://github.com/MoltoRubato/the_depth_within)

Overview

The Depth Within is a top-down combat and puzzle game built using HTML and JavaScript.
Players must navigate a dangerous dungeon, solving puzzles and battling enemies while managing their health, represented by the brightness of the screen.

Features

• Diverse Challenges: A variety of puzzle and combat rooms for engaging gameplay.
• Dynamic Health System: Health is visually represented by the screen's brightness, mimicking the light from the torch.
• Immersive Experience: Complementary effects and background music enhance the game environment.

Technologies Used

• Programming Languages: HTML, JavaScript
• Tools: GarageBand, Adobe Illustrator, Photoshop

---

---

---

How to Navigate

Each project has its own directory containing:

• Source code
• README with setup instructions

Feel free to explore and reach out if you have questions or feedback!

---

Contact

Ryan Huang
GitHub: github.com/MoltoRubato
LinkedIn: linkedin.com/in/Ryan_Huang