ZijunYang

Implemented backend components for profiles, followers, homepages, and timelines. The project includes a cached timeline path and database-retry support alongside heterogeneous-storage integration.

A Vue 3 frontend and Django backend for playing One Night Werewolf with custom house rules. Uses SQLite for storage and HTTP polling for game state, with room creation, night actions, role reveal, and voting.

Implemented MySQL and MongoDB tasks alongside Java application data access. The project includes relational schema/data-loading work and document-database queries within the cloud storage coursework.

Implemented caching components and Redis-based locking within the database coursework. The code includes Redis, Memcached, RedisLock, and reservation-application components.

Developed an online platform for the board game "The Resistance: Avalon" using Vue+Django+SQLite, completing the full development and deployment process including server+domain+website.

Implemented cloud service deployment and an autoscaling controller, using EC2, load balancing, and CloudWatch metrics. The repository also includes heartbeat and request-metric collection for the service.

Containerized the services with Docker and defined Kubernetes deployments, services, and ingress through Helm. The project includes Redis-backed chat and deployment configurations for GCP and Azure.

Implemented graph processing with Spark RDDs and DataFrames, including follower statistics, graph counts, and PageRank. Additional Scala work computes topic-sensitive PageRank and recommendations.

A Rust DNS-tunnel client and server supporting short messages and reliable, ordered longer communication, with a documented authoritative DNS deployment.

Implemented buffer pool management and B+ tree indexing, plus query executors including hash joins. Built MVCC transaction handling with timestamps, undo-log version chains, visibility/reconstruction logic, commit and abort processing, transaction validation, and watermark-based garbage collection.

Coursework covering CUDA tensor operations, automatic differentiation, Transformers, attention and normalization kernels, data/pipeline parallelism, and training/inference with DeepSpeed and SGLang.

Reimplemented from scratch the Textual Inversion algorithm on a pretrained Latent Diffusion Model (LDM), enabling personalization of text-to-image models with only a few example images. Extended multi-concept embedding fine-tuning to support concept composition and factorized learning, improving convergence speed and image quality. Implemented multi-concept embedding manager, modified diffusion model interfaces to support variable-length learned token sequences, and optimized text encoder components to handle multi-token inputs. Quantitative evaluation shows the method outperforms baseline in image-to-image similarity, with CMMD metrics improving from 3.741 to 2.519 on cat statue concept and from 2.822 to 1.852 on clock concept after 5000 steps.

Designed and implemented a GPU-accelerated night-sky star trail video rendering system that converts large sequences of fixed-camera night-sky frames into star-trail time-lapse videos. Developed multiple rendering algorithms including MAX, LINEAR and LINEARAPPROX, with LINEARAPPROX achieving 7.4x speedup through mathematical approximation. Built a complete pipelined CUDA implementation integrating hardware-accelerated video codecs, zero-copy memory transfers, and buffer pool management to eliminate per-frame allocation overhead. The final system achieves 433x speedup over CPU baseline, processing 4K 15-second video in 2.6 seconds on AWS g4dn.xlarge instance.

Designed a multithreaded high-performance simulator to analyze LEO satellite routing under direct sunlight, solar superstorms, high workload, and hardware degradation. Published at IWQoS 2025: “How Resilient are They? Robustness Analysis of LEO Satellite Routing”.

Led algorithm design and programming implementation, designing optimized adaptive bitrate algorithm building upon BBA-0, dynamically adjusting video quality based on buffer occupancy and network throughput prediction within DASH framework. Designed intelligent buffer management strategy and bitrate switching mechanism, maximizing average bitrate while ensuring low time-to-first-frame and zero rebuffering, achieving 1st place in 4 out of 12 test scenarios, particularly in stable high-bandwidth conditions.

Implemented reliable transport protocol CMU-TCP from scratch, building complete three-way handshake, sliding window, RTT estimation, and timeout retransmission mechanisms over UDP. Implemented TCP Reno congestion control algorithm, including slow start, congestion avoidance, fast retransmit and fast recovery, along with receiver-window-based flow control. Verified implementation correctness through Wireshark packet analysis and performance testing, successfully observing TCP sawtooth congestion window patterns.

Designed and implemented parallel VLSI wire routing system using OpenMP (shared memory) and MPI (distributed memory), optimizing wire placement in 2D grids via simulated annealing to minimize overlap cost. Implemented two parallelization strategies: within-wires parallelism (exploring different paths) and across-wires parallelism (processing multiple wires simultaneously), employing dynamic scheduling, batch processing optimization, and fine-grained locking. Achieved 7x speedup on 8 threads (GHC cluster) and 22x speedup on 64 threads (PSC cluster) through iterative performance analysis and optimization, addressing bottlenecks including load imbalance, cache misses, and synchronization overhead.

Deployed Mixnet virtual network cluster across 8 EC2 servers, implementing Spanning Tree Protocol to automatically detect and defend against network loops, supporting multiple topologies including line, ring, binary tree, and fully-connected. Designed and implemented network topology management module, achieving dynamic routing convergence through control message exchange. Verified algorithm performance across different topologies through experiments, optimizing routing selection strategies to mitigate latency impact from network diameter.

Parallel computing coursework covering CUDA rendering, parallel scan, and SAXPY, with an accompanying implementation report.

Designed and implemented an Android document management application integrating computer vision, OCR, and large language models for intelligent document parsing and management. Led project management and full-stack development, focusing on end-to-end security protocol design (hybrid RSA/AES encryption) employing privacy-first architecture with client-side encryption and secure communication, ensuring user document privacy and security during transmission, storage and processing, with sensitive document data never exposed as plaintext on the server side. Implemented frontend interface using Jetpack Compose and backend services using Flask, supporting geometric correction, image enhancement, and intelligent information extraction.

Designed and implemented a sharded key-value storage system partitioning key space across multiple Paxos replica groups. Implemented shard master service managing replica group configurations and shard-to-group assignments. Handled shard reconfiguration through Paxos group coordination, ensuring data consistency during shard movements.

Implemented a fault-tolerant key-value storage service based on Paxos consensus protocol, managing replication without a central view server. Designed PaxosRSM library and KVPaxos servers ensuring client requests execute in the same order. Achieved multi-replica consistency through Paxos protocol, operating correctly even when some nodes are unavailable or during network partitions.

Designed and implemented a fault-tolerant key-value storage service based on primary/backup replication, using a view service to manage primary and backup node identities. Implemented Primary/Backup replication protocol ensuring system continues to operate when primary or backup nodes fail. Implemented node availability monitoring through view service, enabling fault detection and automatic failover mechanisms.

Defined and implemented the speculative-decoding framework, including the main event loop, predictor/auditor/anchor orchestration, and synchronization. Developed a pseudo-demo to evaluate the framework without full model computation, conducted runtime sensitivity analysis and replication result evaluation, and contributed these analyses to the team’s final paper.

Developed core CV algorithms for converting webcam signals to heart rate signals, optimizing signal processing based on bandpass filtering and Fast Fourier Transform (FFT) with further refinements for heart rate signal characteristics. Implemented both fingertip and forehead detection modes, effectively handling lighting variations and motion artifacts to improve detection accuracy and robustness. Built Web UI interface providing online real-time heart rate monitoring, supporting user interaction and result visualization.

Implemented Linux-like inode-based file system, designing fs_inode and fs_direntry core data structures, supporting hierarchical directory tree, file type differentiation, and user-based permission control. Implemented disk block management system maintaining free block queue and sequential allocation strategy, handling block allocation, deallocation, and disk space reclamation for files and directories. Designed and implemented complete file system operation set including path resolution, directory traversal, file creation/deletion, read/write and extension, ensuring data consistency under concurrent access through hand-over-hand locking order.

Implemented virtual memory manager supporting demand paging and page replacement, handling both swap-backed and file-backed memory pages. Designed and implemented Clock page replacement algorithm tracking page access states through reference and dirty bits, achieving efficient page eviction and write-back strategy. Supported shared memory mechanism with multiple virtual pages mapping to the same physical page, using hash table to manage pageID-to-shared-pages mapping, handling complex page fault scenarios.

Designed and implemented DNS server and variable bitrate video streaming and load balancing based on DNS. Replicated iperf. Replicated TCP protocol based on UDP protocol. Designed and implemented network layer soft router and link layer soft switch.

Designed and implemented a MapReduce framework and a search engine based on this framework and PageRank and TF-IDF. Replicated Instagram, supporting feed, comments, likes, follows and other functions.

Implemented user-level thread library from scratch using Linux ucontext facilities for context switching, supporting complete thread lifecycle management including creation, scheduling, synchronization, and cleanup. Implemented FIFO ready queue and preemptive time-slice scheduling, supporting multi-CPU execution and inter-processor interrupt coordination. Designed mutex and condition variable synchronization primitives, using atomic operations and RAII patterns to ensure thread safety, avoid deadlocks, and prevent memory leaks.

Designed and implemented an AB number guessing game algorithm based on greedy information entropy reduction maximization, 30% more efficient than skilled human players. A bot that can guess your number with an average of 5.3 steps and at most 7 steps.