Projects

Built a teaching-language compiler covering parsing, semantic checks and assembly emission; focused on modular design and correctness. Implemented an LL-style recursive-descent parser, scoped hash-table symbol table, and a linear-scan register allocator to emit NASM code.

Implemented a POSIX-like shell supporting pipelines, I/O redirection and background job control to practice process APIs.

Implemented a block-based filesystem with directories, inodes and allocation metadata to learn storage primitives. Included an inode bitmap and extent allocation and exercised the design via a FUSE-based userspace harness for functional tests.

Built a minimal threading library with cooperative scheduling, mutexes and join semantics to study concurrency building blocks. Implemented context switching using ucontext APIs and futex-style wait/notify primitives to support thread coordination.

Implemented a custom heap allocator exploring best-fit and buddy allocation to measure fragmentation costs. Used segregated free lists and instrumentation hooks to collect allocation traces and microbenchmarked allocation/free patterns.

Built a small LSM-style key–value store with memtable, SSTables and compaction to study write-optimized storage. Implemented memtable flushing, immutable SSTable formats and a background compaction thread with prefix bloom-like indexing.

Built a miniature ELF loader with symbol resolution and relocation to understand runtime linking. Parsed ELF headers, implemented GOT/PLT-like relocation handling and maintained a runtime symbol table similar to dlopen/dlsym behavior.

Prototyped a microkernel with task switching, basic syscalls and device I/O targeting embedded learning. Implemented timer-based preemption, syscall trap dispatch and UART-driven I/O for bare-metal experiments on ARM.

Built an interactive simulator of page-replacement policies (LRU, FIFO, Optimal) for OS coursework demonstrations. Feed-driven traces were replayed and fault metrics visualized using matplotlib for instructional comparison.

Simulated FCFS, Round Robin and MLFQ schedulers to compare latency and throughput trade-offs under varying loads. Discrete-event implementation used a heap-based event queue and produced traces for response-time distribution analysis.

Designed a message-passing layer unifying System V-style queues with UDP multicast for inter-host communication. Implemented framed UDP multicast with sequence numbers, ACKs and retransmit logic using select/poll I/O.

Built a stop-and-wait ARQ-style reliable transfer layer to study retransmission and ordering semantics. Implemented sequence numbering, retransmission timers with exponential backoff and simulated loss scenarios for correctness checks.

Developed a concurrent chat server using non-blocking sockets and epoll for scalable connection handling. Implemented an edge-triggered epoll loop with per-connection state machines and optional TLS handshake via OpenSSL for secure channels.

Implemented a caching HTTP proxy with request filtering and header normalization to study web transport. Used an LRU cache for GET responses and implemented chunked transfer decoding and basic cache-control semantics.

Built a recursive DNS resolver supporting A and CNAME lookups to understand hierarchical name resolution. Implemented iterative resolution with UDP/TCP fallback, TTL-based caching and basic negative caching.

Simulated TCP Reno and Cubic to visualize congestion window dynamics under loss and RTT variability. Event-driven model implemented window-update rules, RTT sampling and drop models to contrast algorithm behaviors.

Developed a packet-capture utility using raw sockets to inspect Ethernet/IP/TCP headers for educational analysis. Reconstructed simple TCP flows and exported pcap-compatible output for downstream tooling.

Built a full-stack portal for course management and grade tracking using Flask and SQLite. Structured the app with Flask blueprints, SQLAlchemy ORM and WTForms; served with gunicorn behind nginx for demos.

Built a live dashboard aggregating public COVID resources and visualizing them with D3.js. Implemented server-side polling and client-side responsive SVG charts for county-level exploration.

Built a threaded discussion platform supporting markdown, tags and nested comments using Django. Used PostgreSQL full-text search and background Celery tasks for moderation and notifications.

Created a simple collaborative-filtering recommender with a Flask API for recommendations. Implemented item-based cosine-similarity and cached results in Redis for low-latency lookups.

Developed a TF-IDF-based search interface for research abstracts with ranking and highlighting. Vectorized documents with scikit-learn and implemented simple query expansion heuristics for improved recall.

Implemented a secure voting interface with role-based auth and auditing for campus elections. Session-based auth with CSRF protection and tamper-evident logs for basic audit trails.

Applied local-linear kernel regression to estimate time-varying volatility in financial returns. Implemented plug-in bandwidth selection and validated consistency with MISE-rate heuristics using NumPy/SciPy.

Implemented a Chebyshev spectral–Galerkin solver for parabolic PDEs used in option pricing coursework. Assembled spectral differentiation matrices and employed Crank–Nicolson time stepping to study convergence.

Used bootstrap resampling to assess parameter stability in multi-factor regressions for asset pricing. Wrote resampling routines in R and compared percentile and bias-corrected intervals for robustness checks.

Applied PCA and factor analysis to macroeconomic series to extract latent drivers. Implemented standardization, eigen-decomposition and bootstrap stability checks to interpret factor loadings.

Implemented pseudo-random and stratified sampling methods to approximate multi-dimensional integrals. Included importance sampling and basic variance-reduction techniques for comparative experiments.

Developed a Gibbs sampler for posterior estimation in hierarchical linear models for coursework. Implemented conjugate updates and monitored chain mixing with basic diagnostics (trace/ACF).

Simulated discrete-time Markov chains to explore stationarity and ergodicity properties. Implemented transition matrices and verified mixing with spectral gap estimates and empirical distributions.

Implemented gradient descent, Newton and conjugate-gradient methods for unconstrained optimization experiments. Included line-search and Armijo backtracking for stable step selection and benchmarked convergence rates.

Created implementations for QR factorization, power iteration and least-squares solvers for coursework. Compared direct and iterative methods and used BLAS-backed NumPy routines where appropriate.

Generated discrete Brownian paths to study diffusion properties and random-walk convergence. Implemented Euler–Maruyama discretization and empirical checks on quadratic variation.

Implemented an anytime hierarchical k-medoids pipeline for streaming data experiments. Employed micro-cluster sketches and asynchronous insertion logic to maintain low-latency updates under arrival bursts.

Studied Hull–White and CIR affine term-structure models for pricing interest-rate derivatives. Implemented semi-analytical calibration routines and finite-difference checks for PDE-based pricing validation.

Built path-dependent Monte Carlo estimators for derivative pricing under stochastic volatility models. Used antithetic variates and control variates to reduce estimator variance and implemented parallel sampling.

Investigated medoid-based clustering stability under nonstationary stream arrivals and noise. Performed controlled experiments measuring purity and silhouette with randomized concept-drift injections.

Explored sketching methods for approximate frequency and quantile estimation on large streams. Implemented Count-Min and t-digest sketches and compared memory/accuracy trade-offs.

Analyzed stability of implicit and semi-implicit schemes for parabolic PDEs arising in financial models. Implemented Crank–Nicolson and tested L2-error convergence on benchmark problems.

Studied shrinkage and regularization techniques for covariance estimation in high dimensions. Implemented Ledoit–Wolf and banding/shrinkage estimators and evaluated them on simulated heavy-tailed data.

Implemented resampling-based routines for uniform convergence studies in regression problems. Used empirical-process approximations and bootstrapped confidence bands for function estimators.

Applied Bayesian parameter estimation to stochastic differential equation models using MCMC techniques. Implemented Metropolis–Hastings chains with tuned proposals and basic posterior predictive checks.

Explored compressed-sensing algorithms for sparse signal reconstruction using L1 regularization. Implemented ISTA/FISTA solvers and compared reconstruction error against synthetic sparse signals.

Created a parser and visualizer that converts Valgrind memory reports into summarized diagnostics and interactive graphs. Implemented trace aggregation, leak classification and simple HTML visual output for developer triage.

Built a CLI utility to aggregate commit activity, author stats and repository hotspots for maintenance insights. Used libgit2 bindings and produced time-series summaries and contributor heatmaps.

Developed a lightweight system profiler to sample CPU, memory and disk I/O metrics on Linux hosts. Collected /proc statistics and exported time-series CSVs for quick analysis and visualization.