About Me

I’m a Chemical Physics major with a minor in Applied Computational Science at Tufts University, where I use molecular simulations to explore the hidden rules of complex systems. Whether I’m building high-performance code for scientific research, automating data workflows in industry, or leading communications for a CubeSat mission, I thrive at the intersection of curiosity, computation, and practical impact. My work is driven by a systems-thinking mindset—connecting theory, code, and real-world results to solve challenging problems and make research reproducible, reliable, and accessible.

As Communications & Ground Station Lead for the Tufts CubeSat Team (SEDS), I'm researching ground-station hardware and uplink/downlink protocols in preparation for our upcoming satellite mission.

During my internship at Entegris, I developed a suite of VBA macros to automate data processing, analysis, and reporting—making the task over 1200% more efficient.

This portfolio highlights my work in Python, C++, VBA, and modern web technologies (HTML, CSS, JavaScript), showcasing projects that blend scientific research, automation, and interactive experiences.

Outside of academics and tech, I'm passionate about rock climbing and squash, which challenge me both physically and mentally.

Project Overview

This project is a high-performance simulation engine that prices financial options and analyzes their risk. It was built to explore how complex financial instruments behave under real-world uncertainty, making sophisticated quantitative analysis accessible and intuitive. The entire system is automated—from fetching live market data to generating insightful visualizations—creating a seamless, production-ready tool for financial modeling.

---

Key Features

• Live Market Data: Integrates with Yahoo Finance to pull real-time stock data, ensuring simulations are grounded in current market conditions.
• High-Speed Computing: Uses Numba's just-in-time (JIT) compilation to accelerate calculations, enabling large-scale experiments without the long wait times.
• In-Depth Risk Analysis: Models and visualizes key risk metrics ("the Greeks") to provide a deeper understanding of how option values respond to market changes.
• End-to-End Automation: The workflow is fully automated, from data ingestion to continuous integration with GitHub Actions, ensuring reliability and reproducibility.
• Clear Visual Storytelling: Generates intuitive plots that distill complex financial data into easy-to-understand insights, such as profit/loss distributions and risk sensitivities.

---

Technical Skills

• Python: Scientific computing (NumPy, Pandas), data visualization (Matplotlib), and automation.
• Performance Optimization: Just-in-time (JIT) compilation with Numba for high-speed calculations.
• Software Engineering: Object-oriented design, automated testing (Pytest), and CI/CD with GitHub Actions.
• Reproducibility: Environment management with Conda and containerization with Docker to ensure consistent results.

---

Technical Details

The simulation engine can be run via the command line for quick analysis or through a Jupyter Notebook for more interactive and exploratory work. The code is modular and well-documented, making it easy to extend or integrate into other financial analysis platforms.

---

Visualizations

Project Significance

• Demonstrates the ability to build scalable, high-performance computational models for complex systems.
• Illustrates a systems-thinking approach, from initial data ingestion to automated deployment and analysis.
• Showcases best practices in reproducible research and modern software engineering.

Project Overview

The SMA Crossover Backtester is a production‑ready Python framework for designing, testing, and tuning moving‑average crossover strategies. It seamlessly switches between Stooq and yfinance for reliable data, offers interactive ipywidgets dashboards and dynamic visuals, and automates parameter sweeps—empowering both research and live‑system workflows.

---

Key Features

• Reliable Data Sources: Primary Stooq with yfinance fallback ensures uninterrupted historical pricing.
• Interactive Dashboard: Real‑time parameter adjustment and instant feedback via ipywidgets.
• Dynamic Visuals: Four‑panel display of price & signals, equity curve, drawdown, and rolling Sharpe ratio.
• Automated Optimization: Grid‑search for ideal SMA windows, with results exportable to CSV.
• Robust Metrics: Sharpe ratio, max drawdown, rolling performance, and more.
• Dual Interfaces: Command‑line tool and Jupyter Notebook support for flexible use cases.
• Modular Architecture: Clean separation of data ingestion, indicator logic, signal generation, backtesting, and risk analysis.

---

Technical Skills

• Python: pandas for data handling, matplotlib for plotting, and automated scripting.
• Quantitative Finance: Strategy backtesting, risk assessment, and performance benchmarking.
• Software Engineering: Modular design, unit testing, and reproducible workflows.
• Interactive Analysis: Jupyter Notebooks with ipywidgets for exploratory work.

---

Technical Details

Functionality is organized into dedicated modules for data loading, indicator computation, signal logic, backtesting, and performance analysis. The suite supports both programmatic imports and CLI execution, and includes a full test suite to ensure reliability. Interactive notebooks enable on‑the‑fly parameter tuning with instant visualization updates.

---

Code Example

A typical import statement for using the SMA Backtester’s modular API:

from sma_backtester import fetch_data, compute_sma, generate_signals, backtest_signals

---

Visualizations

---

Project Significance

• Exemplifies professional‑grade systematic trading research and implementation.
• Highlights best practices in modular Python development and test‑driven design.
• Provides a robust template for building, backtesting, and optimizing algorithmic strategies.

Project Overview

During my Summer 2025 Metrology Retention internship at Entegris, I built a suite of VBA macros to automate the processing, analysis, and reporting of structured data from a central Excel worksheet. This solution filters and reshapes raw inputs, calculates key statistics (sums, standard deviations), flags high-variance results, and generates request-specific, color-coded reports with embedded charts—each exported to its own workbook. It reduced the end-to-end task time from about 38 minutes to under 3 minutes, making it over 1200% more efficient.

---

Key Features

• Data Transformation: Automated cleaning, filtering, and reshaping of raw datasets into analysis-ready tables
• Statistical Analysis: Computed sums, averages, standard deviations, and variance flags via VBA functions
• Dynamic Reporting: Assembled parameterized reports—formatted with consistent layouts, color coding, and embedded charts
• Error Handling: Implemented validation routines and logging to catch and report data anomalies
• Workbook Automation: Programmatically generated and saved separate workbooks for each report request

---

Technical Skills

• VBA Programming: Advanced Excel automation, object model manipulation, and macro development
• Data Analysis: Statistical calculations, data manipulation, and automated reporting
• Process Optimization: Workflow automation, error handling, and documentation
• Business Impact: Real-world problem solving with measurable efficiency improvements

---

Technical Details

The solution processes structured data from a central Excel worksheet, applying automated filtering and statistical analysis to generate request-specific reports. Each report is exported as a separate workbook with embedded charts and consistent formatting, eliminating manual processing steps and reducing task time by over 1200%.

---

Project Significance

• Demonstrates real-world automation of critical business processes with measurable impact
• Showcases advanced VBA programming and Excel automation capabilities
• Illustrates the value of process optimization in professional environments

Note: Developed as part of my internship at Entegris, demonstrating real-world automation of critical metrology data workflows.

Project Overview

A classic Snake game implemented in Python with the turtle graphics library. This project demonstrates fundamental programming concepts through an interactive, engaging game that showcases object-oriented design, event handling, and game loop implementation.

---

Key Features

• Object-Oriented Design: Clean separation of concerns with dedicated classes for Snake, Food, and ScoreBoard components.
• Interactive Gameplay: Responsive controls with arrow key navigation and real-time collision detection.
• Modular Architecture: Split into two files for maintainability—main game logic and class definitions.
• Visual Feedback: Real-time score display and smooth graphics using Python's turtle library.
• Educational Focus: Demonstrates core programming concepts in an accessible, fun format.

---

Technical Skills

• Python: Core programming, turtle graphics library, and object-oriented design.
• Game Development: Game loop implementation, collision detection, and user input handling.
• Software Design: Modular architecture with clear separation between game logic and class definitions.
• User Experience: Intuitive controls and visual feedback for engaging gameplay.

---

Technical Details

The project is structured with two main files: snake.py contains the game loop and main logic, while snake_game_classes.py defines the core game objects (Snake, Food, ScoreBoard). The Snake class manages body segments and movement, Food handles random placement and respawning, and ScoreBoard tracks and displays the player's score.

---

Visualizations

---

Project Significance

• Demonstrates fundamental programming concepts through an engaging, interactive application.
• Showcases object-oriented design principles in a practical, accessible context.
• Provides a foundation for understanding game development concepts and user interaction.

---

Project Structure

The codebase is split into two modules for clarity and maintainability:

---

Main Game File (snake.py)

Entry point to launch the game, containing:

• Setup of the game window and turtle environment
• The primary game loop for movement, rendering, and timing
• Collision checks and game-over logic
• High-score display and reset handling

---

Classes Module (snake_game_classes.py)

Defines the core game objects:

• Snake: Manages body segments, directional movement, and self-collision checks
• Food: Randomly places food items on the screen and handles respawning
• ScoreBoard: Keeps track of and renders the player’s score at the top of the screen

---

Downloads

---

How to Run

1. Download both Snake_Game/snake.py and Snake_Game/snake_game_classes.py
2. Ensure you have Python 3 installed
3. Open a terminal or command prompt
4. Navigate to the folder containing the files
5. Execute: python Snake_Game/snake.py

Note: Both files are required—Snake_Game/snake.py imports classes from Snake_Game/snake_game_classes.py.

Disclaimer: This game is a simple educational project and may have some quirks—such as food sometimes appearing near the edge, or the score being displayed at the top. For best results, run it in a standard Python environment with the turtle module installed.

Project Overview

A console-based C++ implementation of the popular card game Sushi Go!, developed as part of a university programming course. This project demonstrates solid object-oriented design, robust game logic, and proficiency with C++ best practices.

---

Key Features

• Object-Oriented Design: Well-structured classes for cards, players, and core game mechanics
• Data Structures & Algorithms: Efficient shuffling and management of the deck, hands, and scoring data
• Game Logic: Turn-based gameplay flow, card passing, round scoring, and win-condition evaluation
• Console I/O: Text-based user interface for menu prompts, card selection, and real-time score feedback
• Error Handling & Testing: Input validation, unit-style diff testing with sample decks, and memory safety checks

---

Technical Skills

• C++ Programming: Object-oriented design, memory management, and standard library usage
• Software Engineering: Large-scale project management, testing, and documentation
• Game Development: Complex game logic implementation and user interface design
• Academic Rigor: Formal specification adherence and comprehensive testing methodologies

---

Technical Details

This console-based implementation of the popular card game Sushi Go! demonstrates advanced C++ programming concepts through a complete game development project. The codebase features robust object-oriented design with well-defined classes for game components, comprehensive error handling, and thorough testing using diff comparisons against expected outputs.

---

Project Significance

• Demonstrates advanced C++ programming skills and object-oriented design principles
• Showcases comprehensive software engineering practices including testing and documentation
• Illustrates the complexity of implementing real-world game mechanics in a structured programming environment

Note: As this was submitted for a university course, detailed source code is not publicly available.

Project Overview

The PCEP (Certified Entry-Level Python Programmer) certification is a professional credential that validates fundamental Python programming skills. This certification demonstrates proficiency in Python syntax, data types, control structures, and basic programming concepts, serving as a foundation for advanced Python development.

---

What PCEP Covers

• Python Fundamentals: Variables, data types, operators, and expressions
• Control Structures: Conditional statements, loops, and flow control
• Data Collections: Lists, tuples, dictionaries, and sets
• Functions: Function definition, parameters, and return values
• Exception Handling: Basic error handling and debugging
• File Operations: Reading and writing files in Python

---

Skills Validated

• Python Programming: Core language features, syntax, and best practices
• Problem Solving: Algorithmic thinking and program logic development
• Professional Development: Industry-recognized certification and skill validation
• Foundation Building: Preparation for advanced Python certifications and development

---

Certification Details

The PCEP certification validates comprehensive knowledge of Python fundamentals through rigorous testing of core programming concepts. This credential serves as a stepping stone toward more advanced Python certifications like PCAP (Certified Associate in Python Programming) and PCPP (Certified Professional in Python Programming), demonstrating commitment to professional development and industry standards.

---

Results

---

Why This Matters

• Demonstrates validated Python programming skills through industry-recognized certification
• Showcases commitment to professional development and continuous learning
• Provides a foundation for advanced Python development and further certifications

Project Overview

In 2025, I earned the FCC Amateur Radio Technician License to support my future role as Communications & Ground Station Lead for the CubeSat Club. This license demonstrates comprehensive understanding of radio communications, electronics, and FCC regulations, enabling me to contribute to satellite communications and ground station operations.

---

License Privileges

• VHF/UHF Operations: Licensed to operate on frequencies above 30 MHz for local, regional, and satellite communications
• Digital Communications: Qualified to use packet radio, APRS, and other data-link techniques
• Satellite Access: Authorized to uplink commands and downlink telemetry from amateur satellites
• Equipment Modification: Permitted to build and modify radio hardware within FCC guidelines
• Emergency Communications: Trained for public-service and disaster-response network participation

---

Knowledge Areas

• Radio Theory: Electronics, RF propagation, antenna design, and signal processing
• Regulatory Compliance: FCC regulations, frequency allocations, and licensing requirements
• Communications Systems: Digital modes, satellite communications, and emergency protocols
• Safety Practices: Electrical safety, grounding, and RF exposure management

---

License Details

The Technician license represents comprehensive knowledge of amateur radio operations, including radio theory, operating procedures, FCC regulations, and safety practices. This credential enables participation in satellite communications, emergency response networks, and technical experimentation within the amateur radio service.

---

Results

---

Why This Matters

• Demonstrates comprehensive understanding of radio communications and electronics
• Enables participation in satellite communications and ground station operations
• Provides foundation for CubeSat communications and emergency response capabilities

Project Overview

This project simulates the behavior of water molecules at the atomic level to reveal how they self-organize and interact. It provides a complete, end-to-end workflow for molecular dynamics research, demonstrating how to set up a simulation, run it on high-performance computing platforms, and analyze the results. The entire process is automated and reproducible, creating a powerful and accessible tool for computational chemistry.

---

Key Features

• Accurate Molecular Modeling: Uses the industry-standard TIP3P water model and advanced simulation techniques (Particle Mesh Ewald) to ensure physically realistic results.
• End-to-End Automation: The entire workflow is scripted, from initial system setup with AmberTools to running the simulation with OpenMM and generating final plots.
• Insightful Data Analysis: Automatically calculates and visualizes key structural properties, like the radial distribution function, to reveal the signature patterns of liquid water.
• Reproducible Science: The project is fully containerized with Docker and includes detailed environment specifications, ensuring that the results are verifiable and consistent.
• Extensible Framework: The modular design makes it easy to adapt the workflow for simulating other molecular systems or exploring new scientific questions.

---

Technical Skills

• Python: Scientific computing (MDTraj, NumPy), data visualization (Matplotlib), and workflow automation.
• Molecular Dynamics: Simulation setup and execution with OpenMM, AmberTools, and industry-standard force fields.
• Systems Engineering: Building automated, end-to-end pipelines for scientific research.
• Reproducibility: Environment management with Conda and containerization with Docker to ensure scientific validity.

---

Technical Details

The simulation generates a trajectory file that can be visualized in standard molecular graphics programs like VMD, allowing for an interactive exploration of the results. The analysis scripts produce publication-quality plots that are ready for inclusion in scientific reports.

---

Visualizations

---

Project Significance

• Demonstrates a scalable and automated workflow for complex molecular dynamics simulations.
• Highlights a systems-engineering approach to scientific research, from initial setup to final analysis.
• Provides a reliable and reproducible template for conducting computational chemistry research with open-source tools.