I developed a fullstack application, utilizing Django in the frontend and a Python server for the backend, connected using the Websockets protocol. It allows for Open Computing Facility members to queue songs from Youtube and other media sources.

It utilizes ytdlp, ffmpeg, and pyaudio to download and play songs. Multithreading is used to provide smooth playback and allow downloading in the background. This application is deployed using Kubernetes and virtual containers. Key features include media controls (play/pause, next), synchronized lyrics, and a song queueing system.

Pathfinding Algorithm Visualizer is a project where I utilized C++ and SFML to visualize different pathfinding algorithms.

This interactive project allows users to select from a range of pathfinding algorithms, including DFS, BFS, Dijkstra, and A*, and apply them to either a randomly generated maze or an open area. The algorithm visually highlights the visited squares, providing insight into their distinct characteristics and behavior.

RISC-V CPU is a project where I designed a RISC-V CPU using Logism.

I designed and implemented the parts of a CPU necessary to execute nearly all of the RISC-V instructions, including the Arithmetic Logic Unit (ALU), Register File (RegFile), Immediate Generator, and datapaths.

The CPU was able to run I-type (immediate) instructions, R-type (register) instructions, B-type (branch) instructions, load and store instructions, and jumps and U-type instructions. These instructions were also pipelined, allowing for two instructions to be run per CPU cycle.

Build Your Own World is a 2D, procedurally generated dungeon crawler game written in Java, where the user has to collect a key to escape a maze while being chased by enemies.

I implemented a sophisticated seed-based world generation engine using Prim’s MST. The game also features restricted vision based on line of sight, interactable light sources with a robust lighting system, an immersive sound system, enemies equipped with A* pathfinding capabilities, a player shooting and combat system, and the crucial functionality to save and quit games.

Secure File Sharing System is a project where users can securely create, access, append, and share files securely, despite an attacker having access to the entire database, through the use of various cryptographic library functions in Go.

The system can initialize and load users on multiple devices. The users can create files, retrieve and append to these files, and also share these files so other users can access them. Of course, the system also comes with an access revocation system and prevents previously shared users from regaining access to files. The project uses symmetric encryption and HMACing to ensure integrity and confidentiality in files and RSA asymmetric encryption and digital signatures to ensure integrity and confidentiality in invitations. Some other important library functions include hashing, Argon2Key, and hash-based key derivation.

During this project, I learned how to use Pytorch on various machine-learning applications, including language detection and digit classification.

To recognize handwritten digits, I began by creating a one-layer Linear neural network, using ReLU activation to combine layers and Cross-Entropy for the loss. To filter the data, I performed a convolution on the data and flattened it to enhance model performance, achieving an accuracy of over 97%. For language recognition, I used a two-layer Recurrent Neural Network to recognize the languages of words of different lengths with an accuracy of over 81%. This project helped me understand neural networks and how to edit hyperparameters such as batch size, the learning rate, layer size, number of layers, and epoch size to achieve the best models.

During this project, I simulated a Pacman game trained with reinforcement learning. I implemented value iteration, Q Learning, Approximate Q Learning, and Deep Q Learning using the Pytorch library.

During this, I solidified my understanding of Pytorch and Reinforcement Learning algorithms, including how to optimize hyperparameters such as the learning rate, number of hidden layers, hidden layer size, and batch size.

Scheme Interpreter is a project where I designed an interpreter for Scheme that translates lines of Scheme code into Python, and returns its output.

The project relies heavily on a deep understanding of Scheme and Python’s object-oriented programming. Through recursion, it parses the Scheme expressions to a custom Python object through lexical and syntactic analysis, then evaluates and outputs the resulting expression. The recursion also uses the tail recursion optimization to minimize memory usage. The final result can parse Scheme expressions like primitives, call expressions, and special forms to their resulting values.

Snek is a clone of the popular game Snake written in C.

I utilized double pointers and memory management to recreate the game’s functionality, including keyboard input, randomly generating food, and snake growth and death. I also gained familiarity using cgdb to debug my code, and Valgrind to check for memory leaks.