Here's what you'll see after your profile has been scraped:

• Python with Beautiful Soup for web scraping profiles and film data
• Multithreaded scraping with ThreadPoolExecutor for faster data collection
• Pandas for data processing and analysis
• Plotly for interactive visualizations
• Streamlit for designing and deploying the web interface

This project was a really fun way to combine my personal interests into a tangible product. I thought about what kind of insights would be meaningful to someone who watches a lot of movies and how to present those insights in a way that's both informative and enjoyable to look at. Letterboxd doesn't have a public API, so I turned to web scraping with Beautiful Soup. This meant I had to be careful with rate limits; I accidentally exceeded them at one point, but this helped me implement better error handling and request throttling in the final version. On the front-end side, I put a lot of effort into mimicking Letterboxd's UI to make the dashboard feel like a natural extension of the platform. Streamlit's convenience was a blessing for rapid prototyping, but its limitations forced me to get a little creative with injected HTML/CSS to achieve the exact look that I wanted. There's a lot of room to improve and expand the project, but overall I'm happy with how it turned out, and it was super satisfying to bring the idea to life.

• Next.js for building the front end
• Tailwind CSS for styling
• Vercel for deployment
• A couple of APIs & services:
  • Letterboxd RSS feed for recently watched movie data
  • Last.fm API for Spotify listening data
  • Deezer API for music artist images
  • Nodemailer for emailing recommendations

I was initially unsure about whether I should make this website strictly professional or a little more casual. Ultimately, I leaned into the latter because I wanted it to be like a snapshot of the person I am right now.

I built this website from scratch and I'm a bit of a perfectionist, so it ended up becoming a never-ending cycle of tweaks and refinements. I became very fixated on tiny design choices; as a result, I spent an embarrassing amount of time browsing fonts, adjusting hex codes, and trying out different hover animations.

Below are a few past iterations of the design, ordered from most to least recent:

For my current design, I tried to incorporate elements of a retro aesthetic while still keeping it minimalist, and I'm (mostly) satisfied with how it looks now. Despite all the nitpicking, it felt very rewarding to create something that grows alongside my interests. I'll try to keep this website as up to date as possible.

Building the time-series forecasting model involved:

• Scraping and processing 23 years of NASA OPeNDAP hydrology data (2002 - 2024), which included environmental metrics such as rainfall, snowmelt, soil conditions, and much more
• Lots of feature engineering to align the different environmental metrics with their delayed impact on water inflow
• Designing a 3-layer LSTM network with a custom Huber loss function to handle outliers
• Fine-tuning dropout, regularization parameters, and model architecture to prevent overfitting
• Visualizing evaluation metrics (validation loss tracking, dropout, r²)

Hydropower and renewable energy was a field that I had pretty much no knowledge in before working at Hatch, so I was eager to learn about the role of software in the energy sector. This project was interesting to work on because of the real-world application and potential for growth. What excited me the most was seeing how this model could be improved and integrated into the company's optimization systems for hydropower plants. As for the development process, I ended up gaining a much deeper understanding of the theory behind machine learning while I was experimenting with the model. It took a lot of time and learning, but I enjoyed the process!

Poképlants creates an interactive gaming experience where users can use their real-life houseplants as Pokémon-style characters to battle others. The user would add their plant to their "Plantdex", and hardware components (a camera, moisture sensors, and a photoresistor) would provide real-time insight into the plant's health. Stronger plants have stronger abilities, so the game is meant to create an incentive for players to take better care of their plants.

• Hardware for measuring plant health
• OpenAI for identifying plants and their health
• Langchain for processing data into game actions
• Flask for the back end
• Socket.IO for real-time multiplayer battles
• React for designing the game

This project initially started off as a kind of unserious idea from a team member ("what if we made Pokémon but with actual plants?"), but it ended up taking us further than we expected. Our intention was to go for the environmental track prize, which was an IKEA shark plushie. Instead, we ended up winning the whole thing and receiving a pair of 2nd-gen Airpod Pros! I found it pretty exciting to collaborate with a talented team and work under pressure to turn an idea into a product. There was a lot of front-end work involved here, and we were determined to make the game and its mechanics look fun, which is why we decided to try to evoke the nostalgia of old Pokémon games. Overall, I was happy about how this project turned out and pleasantly surprised by its win at Toronto's largest summer hackathon.

The user would express the task that they are trying to accomplish; for example, maybe they want to practice Leetcode and get a job. The extension would then start observing their activity, making snarky comments verbally and nudging them to get back on track (hence the name). If they opened a problem and went straight to the solution, they would get called out. The extension "speaks" out loud in a tone and voice that's meant to mimic the narrator in The Stanley Parable.

• JavaScript for the core functionality and user activity monitoring
• React for the extension's pop-up and dashboard
• MongoDB for storing activity logs
• Flask for the back end
• GPT-4 (OpenAI) for generating responses
• Eleven Labs TTS for giving voice to the narrator

This product isn't perfect (most hackathon projects aren't), but it taught me a lot about how Chrome extensions work under the hood. I gained some pretty valuable full-stack experience, but unfortunately also learned firsthand about how frustrating Chrome extensions can be to debug, especially when I'm trying to trace different messages and errors between background scripts, popups, and content scripts. However, this made it extra satisfying when the project started coming together nicely. I enjoyed the process of building Nudge, especially in the unique environment of a hackathon, and found the premise to be really fun to design.

Chroma allows the user to input their available colours by adding them with a colour picker or uploading a photo of their paint swatches. These colours will be stored in a palette that they can edit and fine-tune. Next, the user can choose to take or upload an image to use as a reference, and the app will generate a palette based on this image. With these two palettes, the app uses a linear algebra approach to calculate the ratios for how much of each available colour is needed to create the target colours.

• Flutter for building the mobile app
• Flask for the back end, which includes a Python script to handle calculations
• OpenCV for extracting colours from images
• An AWS EC2 instance for hosting the Flask server

Mobile app development operates pretty differently from web development, so it was a little intimidating at first, especially since this was my first hackathon. However, we were determined to make it work, even under the time constraints. We did a lot of breaking, fixing, learning, and desperate researching to finish the project just in time. It's worth noting that the RGB colour model (which is optimized for screens) might not be the best representation of how paints actually mix in real life, but the resulting colours generally ended up being pretty close to the target colours. This experience introduced me to the world of mobile development, which I would definitely be willing to explore further.

Some features of the project include:

• Multiplayer mechanics (compete 1v1 with another player)
• Tetris mechanics (e.g hold queue, block previews, ghost piece visualization)
• Customizable commands (the ability to rename commands and create macros)
• Level system (5 distinct levels with unique block generation rules)
• Special effects ("blind" and "heavy" modifiers to disrupt opponents)

• C++ with smart pointers for automatic memory management
• Object-oriented design (e.g abstract Block and Level hierarchies)
• Observer design pattern for decoupled UI rendering (text and graphical displays via X11)
• Factory design pattern for dynamic block/level generation
• Modular components (separated game logic, UI, and gameplay mechanics)

The process of developing Biquadris was a deep dive into object-oriented programming. Before writing a single line of code, our team invested significant time in designing a detailed UML diagram to map out class relationships, responsibilities, and interactions. This upfront planning paid off; by agreeing on architecture early, we avoided major refactoring headaches later and could work in parallel without stepping on each other’s toes. We spent a lot of time thinking about good design, so this project also reinforced the benefits of encapsulation and loose coupling for making teamwork smoother. After implementing the core game mechanics, I had the opportunity to enhance the project with bonus features. I grew up playing Tetris, so I had a lot of fun with refining the design of the game and adding features. We ended up earning a 106% final grade on the project, which I was pretty happy about! The experience not only strengthened my skills with C++ but also deepened my appreciation for clean, scalable design.