CurveFS lazily fetches remote files on first access, introducing latency from network I/O and local writes. I extended the warmup subsystem with three new interfaces: preserving existing job file lists on subsequent adds, canceling in-flight jobs and their downstream tasks, and listing all active warmup jobs per filesystem. These additions give operators direct observability and control over the pre-fetch lifecycle.

The chart above shows off-role parity rising sharply in the targeted region immediately after rollout. The core problem was that the existing algorithm permitted asymmetric role confidence between opponents, pairing one player's off-role against another's main position and creating a perceivable disadvantage.

I redesigned the matching logic to enforce parity by grouping players into role-confidence tiers before pairing them. To manage the queue-time tradeoff, I ran offline simulations against 2M+ historical matches using Python and Databricks, iterating until the parity gain justified the latency cost. The service ran on Java and Spring.

The feature surfaces position scarcity to players during champion select. What appeared to be a straightforward UI change required careful distributed systems work: the scarcity signal is derived from state spread across parties, lobbies, and matchmaking services on separate servers, so inconsistent views between lobby members would undermine the feature's usefulness.

I stored the shared state in a Redis-backed cache with periodic source refresh, ensuring all clients in a lobby see a consistent snapshot. The client layer used Ember.js and C++; the backend used Java and Spring.

The platform has two components: a React + Node.js dashboard for visualizing historical metrics and configuring targets, and a monitoring daemon containerized with Docker and orchestrated as a k8s Job. The daemon runs continuously, collecting Lighthouse scores and Web Vitals across hundreds of Houzz pages and persisting results to MongoDB for trend analysis.

I extended the existing C++ and C# wizard to support Linux sandbox creation alongside the existing Windows flow. The feature automates VM import, package installation, and environment hardening via Shell Script, replacing what had been a manual process. Adding Linux coverage meaningfully expanded the malware detection surface; Linux VMs now account for over 34% of active sandboxes.

I owned the preprocessing stage of the malware analysis pipeline, where incoming file samples are triaged before scanning. One key addition was EGG-format decompression support, a Korean archive format that the system had not previously handled. I refactored an open-source C++ EGG library and integrated it into the existing pipeline without disrupting the surrounding flow.

Internship capstone at China Unicom. The task was real-time customer counting from surveillance video; I fine-tuned a Mask-RCNN model and achieved measurable accuracy improvements over the baseline. To support ongoing training data collection, I also built a web-based annotation tool that lets operators label frames and export ground truth in JSON format.

Processed 1TB of raw Twitter data using Spark and Scala for ETL, loading into a MySQL backend.

To sustain 25K+ RPS under a tight budget, I applied layered optimizations: read-heavy schema design, database parameter tuning, horizontal scaling behind a Jooby load balancer, and read replicas with sharding. Bottlenecks were identified via AWS CloudWatch. In the final phase, the service was migrated to AWS managed services to reduce operational overhead.

The system ingests a continuous stream of ride-request and driver-location update events via Kafka, processes them through a Samza topology, and matches each request to the nearest available driver in real time. End-to-end throughput reaches 20K RPS.

The chatbot helps users log and track daily expenditures through natural-language input, using Word2Vec embeddings to handle paraphrase variation in user messages. A Vue.js frontend visualizes spending patterns over time. The team won “Best Team” at FinTech Hackathon Taiwan 2017.

Fine-tuned a VGG19 model on a multi-label chest X-ray dataset for disease classification, then applied Grad-CAM to generate localization heatmaps, treating high-attention regions as lesion candidates. The dataset had severe class imbalance, which I addressed through oversampling, class-weighted loss, and data augmentation.

The frontend is a React + Redux SPA communicating via Axios; real-time notifications and direct messaging run over Django Channels with WebSocket reconnection handling. The REST API is backed by Django REST Framework and MySQL. Deployed on GCP behind Nginx.

The app targets users in disaster scenarios and supports real-time public, private, and group messaging, status announcements, and resource search. A hard course constraint prohibited using any frontend framework, so we built our own component model and state management layer from scratch, applying several structural design patterns throughout.

Built for the NTU GMBA administrative office to replace manual data entry workflows. The app manages student background and academic performance records, with an interactive chart layer; for example, filtering by age cohort to generate career-outcome breakdowns.

Packaged as an Electron desktop app so staff can run it without any environment setup. The office reported an 80% reduction in data retrieval time after adoption.

The app reimagines gift-giving through AR product previews, a blockchain-backed gifting ledger, and on-device object detection. My responsibilities spanned multiple screens and the data pipeline wiring between them in Swift. The product launched on the App Store and was accepted into the VentureBridge Summer Cohort in 2022.

A Java-based translator that converts a subset of C (expressions, control flow, and functions) into x86 assembly. Built as the capstone for the System Programming course.

A Vue.js mobile web client for the CNode community forum API. The main engineering focus was smooth, native-feeling navigation: inter-page sliding transitions were implemented in pure CSS and JavaScript without any animation library.

A browser-based Texas Hold'em game implementing full hand evaluation, betting rounds, and multi-player state management. Built as a hands-on study of Vue.js reactivity and component design.

A 2048-style game for practicing binary, octal, and hexadecimal conversion. Built entirely in vanilla JS, with no libraries or build tools, as a focused exercise in DOM manipulation and game loop design.