PORTFOLIO
LATEST PROJECTS
Final Year Project - Hearing Aid Platform
Individual final year project developing a comprehensive Progressive Web Application (PWA) that provides an augmented reality experience for visualizing hearing aids. The platform includes hearing tests, appointment booking, and personalized audiologist consultations. Built with React, TypeScript, and Kotlin backend, featuring iOS Quick Look AR, WebXR support, and Azure cloud services. The application demonstrates advanced full-stack development, AR/VR technologies, and healthcare application design. Complete with offline support, cross-platform compatibility, and professional-grade hearing assessment tools.
Causal Reasoning in Large Language Models
Individual research project investigating the limitations of Large Language Models (LLMs) in distinguishing correlation from causation. I reproduced the CORR2CAUSE benchmark using a 4-million-parameter BERT-tiny fine-tuned on 5,000 synthetic examples, achieving 85% accuracy in-distribution. However, accuracy collapsed to near random chance when causal direction was perturbed by a simple back-door variable swap. I introduced lightweight causal rationalisation through training on "because… therefore" explanations, recovering 15 percentage points on the swapped set. This research demonstrates advanced understanding of machine learning, causal inference, and experimental design.
Advanced Databases - SJDB Query Optimizer
Individual coursework where I built a query optimizer for SJDB, a simple RDBMS. My optimizer accepts a canonical query plan (a project over a series of selects over a cartesian product over the input named relations) and constructs a left-deep query plan which minimizes the sizes of any intermediate relations. This involved implementing advanced database optimization algorithms, cost estimation techniques, and query plan generation. The project showcased deep understanding of database internals, query optimization theory, and performance engineering.
Cloud Application Development - Group Project (Lecture Note Generator)
Group project with 6 other students creating a Software as a Service (SaaS) platform for lecture note generation. Our system could process lectures in various formats (mp3, mp4, etc.) and generate customizable notes with different detail levels and styles. Users could choose between lecture transcription only or enhanced notes using external knowledge. The platform featured real-time transcription, note generation, quiz creation, and sharing capabilities between users. This project demonstrated advanced cloud architecture, AI integration, and collaborative software development skills.
Cloud Application Development - Part 1 (Quiplash)
Individual coursework focusing on Azure cloud services and serverless computing. I wrote Azure Functions in Python using the v1 programming model, deployed a FunctionApp on Azure, and performed CRUD operations on documents in Cosmos DB. The project involved querying collections in Cosmos DB and configuring additional cloud services in the context of a FunctionApp. I created a Quiplash-style game backend with real-time functionality, achieving 92% in this coursework. The code demonstrates proficiency in cloud architecture, serverless computing, and NoSQL database management.
Cloud Application Development - Part 2 (Frontend)
Individual coursework creating the frontend for the Quiplash application using Vue.js. I developed a responsive web interface that connects to the Azure Functions backend, implementing real-time game functionality, user authentication, and dynamic content updates. The project showcased skills in modern frontend development, API integration, and real-time web applications. I achieved 86% in this coursework, demonstrating strong full-stack development capabilities.
Computer Vision Group Coursework - Scene Recognition
Group coursework with 3 other students testing understanding of image formation, image modelling, and computer vision. We analyzed and designed algorithms for image processing and computer vision, developing and evaluating solutions to problems in scene recognition. The project involved implementing various computer vision techniques for scene classification and recognition tasks. Our team achieved 23/25, demonstrating excellent collaborative work and technical implementation skills in computer vision.
Computer Vision Coursework 1 - Hybrid Images
Individual coursework demonstrating understanding of current approaches to image formation and image modelling, basic image processing and computer vision. I implemented basic image processing algorithms including convolution operations and hybrid image generation. The project involved creating hybrid images by combining low-frequency components of one image with high-frequency components of another, resulting in images that appear different at different viewing distances. I achieved 90% in this coursework, showcasing strong implementation skills in computer vision algorithms.
EARLIER PROJECTS
TetrECS
I have developed a Tetris-inspired game using JavaFX that offers both a classic single-player mode and an engaging multiplayer mode. In the multiplayer mode, I implemented real-time functionality, allowing players to create parties, chat, and compete with friends, adding an exciting social dimension to the game. I also designed and coded interactive gameplay elements, ensuring smooth block movement, rotation, and an effective scoring system to keep players engaged. To enhance the overall user experience, I created a user-friendly interface with responsive game controls, making it easy for players to enjoy the game.
Coronavirus Database
For my coursework project, I embarked on a comprehensive data analysis and modeling endeavor centered around COVID-19 statistics. This project demanded the transformation of raw data from a CSV file into structured SQL tables, meticulously designed to adhere to the Boyce Codd Normal Form (BCNF) principles for optimal data integrity and efficiency. Additionally, I created a GNUPlot script to plot the cumulative deaths of the top 10 countries with the highest cumulative deaths as part of my extension.
eGarden
During my Interaction Design coursework, my team and I developed an interactive tool called eGarden to help people optimize their home energy use with advanced energy technologies. We started with a literature review of relevant studies and conducted in-depth user interviews, followed by first-pass coding and thematic analysis to identify key themes and latent insights. We detailed these themes with illustrative quotes and created an affinity diagram to visualize concepts and relationships. This thorough analysis enabled us to articulate a clear problem statement that our tool could address. We then developed a low-fidelity prototype, produced a video explanation, and conducted evaluations with another group, refining our design based on their feedback through thematic analysis. This comprehensive process showcased our ability to translate theoretical research into practical, user-centered solutions.
Ad Auction Dashboard
During my coursework, our team developed an ad auction dashboard where users could upload their campaign zip files containing server_log, impression_log, and click_log. We extracted statistics from these logs and displayed them as graphs, allowing users to filter data by age, user ID, context, and date. The system supported multiple user roles: admins, editors, and viewers. Admins could manage user accounts, create and modify campaigns, and add filters; editors could adjust campaigns and filters; viewers could only view the campaigns. Additionally, users could export graphs as PNGs and data as CSVs. This project demonstrated our ability to create a comprehensive and user-friendly ad auction analysis tool.
Haskell Problem Solving Code
During my Programming III coursework, I tackled various complex problems using Haskell. One notable challenge was solving a circuit puzzle, which required rotating pieces and finding an optimal path from the source tile to the destination tile. This task demanded an efficient algorithm to minimize computational time, which I successfully implemented. Additionally, I delved into the intricacies of the lambda calculus language by developing a parser and printer for it in Haskell. I further extended my understanding by encoding let blocks using lambda calculus, showcasing my ability to apply theoretical concepts to practical scenarios. These accomplishments, reflecting both problem-solving skills and theoretical knowledge, culminated in achieving a commendable grade of 90%
Distributed File System
During my Distributed Systems coursework, I created a distributed storage system using Java, networking, and distributed systems principles. The system featured a Controller and multiple Data Stores (Dstores), supporting concurrent client requests for storing, loading, listing, and removing files. Each file was replicated R times across different Dstores, with the Controller managing file allocation and sizes. Clients accessed files directly from Dstores to improve scalability. Although all processes ran on the same machine, the design was applicable to multi-server systems. The Controller waited for at least R Dstores to join before serving requests, and performed rebalance operations to ensure even file distribution and replication. This project highlighted my skills in developing a scalable and robust distributed storage solution.
Programming Language
During my Programming Language Concepts coursework, my team and I designed and implemented a domain-specific programming language for querying simple Graph Data documents. Using Happy for parsing and Alex for lexing in Haskell, we developed a language inspired by existing query languages, tailored to solve specific problems related to graph data manipulation. Our project involved creating an appropriate syntax and writing an interpreter to handle queries and manipulations. We tackled five example problems by writing programs in our language to solve them, which, along with our interpreter's Haskell sources, comprised our initial submission. For the second submission, we documented our design decisions in a programming language manual and solved five additional unseen problems, demonstrating our language's robustness. This project required creative and clean syntax design, effective error handling, and the ability to meet qualitative and quantitative performance benchmarks, ultimately showcasing our skills in language design and implementation.