This repository contains my coursework from Westminster University. Each branch corresponds to a class. Featured projects highlight key outcomes and learning experiences.
- CMPT 202: Intro to Data Structures - Fall 2023
- CMPT 251: Computer Systems & Programming - Fall 2023
- CMPT 375: Web Applications - Spring 2024
- CMPT 306: Algorithms - Fall 2024
- CMPT 341: Programming Languages - Fall 2024
- WCSAM 203: Linear Algebra - Fall 2024
- CMPT 301: Artificial Intelligence - Spring 2025
- CMPT 351: Operating Systems - Spring 2025
- CMPT 322: Software Engineering - Spring 2025
Branch: cmpt202
Branch: cmpt251
Featured Assignment: Project 2 – Memory Manipulation in C
In this project, I implemented image transformations on bitmap files — converting them to grayscale, posterizing, resizing, mirroring, and rotating — all using raw memory manipulation in C. The assignment required working directly with bitmap file structures, reading and writing pixel data, and performing transformations by manipulating memory at the byte level. I used pointer arithmetic to navigate through pixel arrays and dynamically allocated memory to handle images of varying sizes. This project was one of the most enjoyable ones as it made abstract concepts in C feel tangible through visual outcomes.
This assignment helped me attain a system-level understanding of the computer by requiring me to work directly with memory addresses, understand how data is stored and accessed at the hardware level, and manage resources manually without high-level abstractions. It also developed my problem-solving skills as I had to debug segmentation faults, trace pointer operations, and optimize memory usage for performance. The visual feedback from the bitmap transformations allowed me to immediately see the results of correct versus incorrect memory manipulation, reinforcing my understanding of how computers represent and process data at a fundamental level. This hands-on experience with low-level programming deepened my appreciation for critical thinking in debugging complex memory issues and understanding the relationship between software and hardware.
Repository: cmpt375
Featured Project: JACL Website Project
This project involved collaborating with students from the Media Arts & Design program to develop a professional website for the Japanese American Citizens League (Salt Lake Chapter). As part of the development team, I worked with Django to build both front-end and back-end features for the site. The project simulated a real-world client relationship, requiring our team to gather requirements, communicate progress, and deliver a production-ready website that met the client's needs. The interdisciplinary nature of the project meant coordinating with designers, managing a shared Git workflow, and balancing technical implementation with creative vision.
This assignment directly addressed multiple learning goals. It strengthened my understanding of software design concepts and techniques through implementing a full-stack web application using Django's MVC architecture, database models, and templating system. The project also provided significant experience in group collaboration, as I had to coordinate with both CS students and Media Arts students, navigate merge conflicts, conduct code reviews, and communicate technical constraints to non-technical team members. Additionally, this project emphasized communication skills as I had to translate client needs into technical requirements and present our progress in terms the client could understand. Finally, working with the Japanese American Citizens League connected the project to global responsibility by creating technology that serves a community organization dedicated to civil rights and cultural preservation, making me consider how software development can support social good and underrepresented communities.
Branch: cmpt306
Featured Assignment: Final Project – Pathfinding Algorithms
In this project, I designed and implemented multiple pathfinding algorithms — including Dijkstra's algorithm, Greedy Best-First Search, and various Priority Queue implementations — to compute optimal paths on elevation maps stored in .tiff format. The assignment required reading and parsing geographic elevation data, representing it as a graph structure, and applying different pathfinding strategies to find routes that minimized elevation change or distance. I compared the algorithms by analyzing their execution times, path optimality, and memory usage, using real topographic data to test how theoretical algorithmic complexity translates to practical performance.
This project deepened my system-level understanding of the computer by requiring me to work with file formats, understand how spatial data is stored and accessed efficiently, and optimize data structures for performance-critical operations. It also developed my problem-solving skills as I had to analyze trade-offs between algorithmic approaches, debug incorrect path calculations, and reason about why certain heuristics produced better or worse results for different terrain types. The emphasis on comparing algorithmic performance through empirical testing strengthened my critical thinking abilities, as I had to move beyond theoretical analysis to understand real-world factors like cache performance and data structure overhead. This hands-on experience with algorithm design and analysis reinforced the importance of choosing appropriate data structures and algorithms based on problem constraints and performance requirements.
Branch: cmpt341
Featured Assignment: Brainfuck Interpreter
In this assignment, I built an interpreter for Brainfuck, an esoteric programming language with only eight commands that manipulate a tape of memory cells. The project required implementing the complete interpretation pipeline: lexical analysis to tokenize the source code, parsing to validate bracket matching and program structure, and runtime evaluation to execute the commands and manage the memory tape and instruction pointer. Despite Brainfuck's minimal syntax, the interpreter needed to handle loops, memory management, and input/output operations correctly, making it a compact but complete language implementation project.
This project developed my problem-solving skills by challenging me to build a working interpreter from scratch, requiring careful attention to edge cases, bracket matching for loops, and proper state management during execution. It also reinforced critical thinking as I had to reason about how high-level language constructs are translated into executable behavior, debug subtle issues in the interpretation logic, and test the interpreter against various Brainfuck programs to ensure correctness. Through this assignment, I gained a deeper appreciation for how programming languages work under the hood, including tokenization, parsing, and the execution model that bridges human-readable code and machine operations. This foundational understanding of language implementation has made me a more effective programmer across all languages.
Branch: wcsam203
Featured Assignment: Final Project – Movie Recommendation System
In this project, I developed a recommendation system using Singular Value Decomposition (SVD) applied to a dataset of 50 users and 50 movies with rating patterns. The system analyzed user-movie rating matrices to identify latent features and generate personalized movie recommendations for each user. I implemented and compared two similarity metrics — Cosine Similarity and Euclidean Distance — to determine which approach better captured user preferences. Through empirical testing and analysis, I concluded that Cosine Similarity is ideal for identifying users with similar taste profiles regardless of their rating scale tendencies, while Euclidean Distance is better suited for scenarios where the absolute magnitude of rating differences matters.
This project strengthened my system-level understanding by requiring me to implement mathematical algorithms computationally, manage matrix operations efficiently, and understand how data representations affect algorithm performance. It also developed my problem-solving skills as I had to translate abstract linear algebra concepts into working code, debug numerical accuracy issues, and interpret the mathematical meaning of SVD components in the context of user preferences. The creative aspect came from exploring different similarity metrics and reasoning about which mathematical approach best modeled real-world recommendation scenarios. Additionally, the project required clear communication of technical findings, as I had to explain the mathematical reasoning behind my conclusions and present comparative results in a way that justified the choice of similarity metric for different use cases.
Branch: cmpt301
Branch: cmpt351
Repository: cmpt322
Featured Project: Bob's Math Adventure
This project involved working as one of three developers on a team to design and develop an educational math game that teaches elementary students mathematical concepts through interactive gameplay. The project simulated a real-world software development cycle using Agile methodology, including requirements gathering from stakeholders (in this case, our instructor acting as the client), sprint planning, iterative development cycles, code reviews, testing, and deployment. As a core member of the development team, I implemented multiple features across the game's architecture and actively participated in all phases of the software engineering process from initial design through final delivery.
This assignment provided significant project experience working in a group setting, requiring close coordination with two other developers through regular standups, paired programming sessions, code reviews, and Git collaboration workflows. It also deepened my understanding of software design concepts and techniques as we had to architect a maintainable codebase, design class hierarchies for game objects, implement design patterns, and refactor code based on changing requirements across multiple sprints. The project emphasized collaboration skills as we navigated team dynamics, resolved merge conflicts, distributed workload fairly, and made collective decisions about technical approaches. Additionally, it developed my communication abilities through writing clear documentation, presenting sprint demos, explaining technical decisions to stakeholders, and providing constructive feedback during code reviews. The creative aspect emerged in designing engaging game mechanics and user interfaces that made learning math fun, while the global responsibility dimension connected to creating educational technology that could help students from diverse backgrounds access quality math education.