Academics

Introductory

In this section, I will be discussing my academic career, the skills I learned, and how my classes and experiences shaped my way of thinking and working. I will primarily discuss the skills that I learned and my role in group projects if one was assigned. If available, there will be links to the GitHub repositories associated with each class and its projects. Below are quick, 1-sentence summaries of what my courses were about. Please click the buttons on the right to read about my accomplishments in the classes in more detail.

Data Structures and Algorithms

I learned the concepts of time and space complexity and implemented algorithms and abstract data types to visualize them.

Intro to Software Development

I mastered object-oriented design concepts such as model-view-controller software architecture and added Git as an important tool to my toolkit.

Cyber & Info Security Management

I am being engaged with core cybersecurity principles and the importance of cybersecurity through penetration testing labs and student presentations.

Web Programming

I am working with a group of 6 other students to build a fullstack web application using jQuery, NodeJS and ExpressJS, and I have the responsibility of implementing the backend.

Intro to Game Design/Development

I cooperated with 3 other students to develop a game in C++ and SDL2; I made all the sprites and artwork, implemented NPC interactions, and handled map rendering.

Reinforcement Learning

I fully understood key concepts and terms in reinforcement learning such as policy, value, and q-learning, and implemented various reinforcement learning models.

General Information

School: College of William and Mary
Graduation Month and Year: January 2025
Current GPA: 3.54
Dean's List Placements By Semester: Spring 2022, Fall 2023, Spring 2024

Transcript download

You can download my unofficial transcript here: My Unofficial Transcript

About

Data Structures & Algorithms were two computer science class in college where the goal was not to just write code that works. These classes was focused on the ideas of time and space complexity in coding, two concepts that would forever change the way I do things. Before, I was concerned only with making my code do what I wanted it to do, regardless of how inefficient it may be. This course prepared me for the more conceptual side of computer science that didn't just involve writing working code.

Final Grade: B (Data Structures) / A (Algorithms)

GitHub Link: https://github.com/Derek9132/CSCI-241

Notable Projects/Experiences

Doubly Linked List

I implemented a doubly linked list, which is a list in which the contents of the list are not neccessarily next to each other in memory. Instead each element stores a memory pointer to the element after it and the element before it. This makes insertion and deletion operations run in O(1) constant time if the reference of the element that needs to be inserted/deleted is known. Space complexity for a linked list's operations are O(1).

Queue and Deque

I implemented a queue, a data structure in which elements can only be removed from the front and added from the back. This ensures that elements inserted first will be removed first and elements inserted last will be removed last. Queues are useful as waiting lists for multiple components/tasks that need access to the same shared resource and for job scheduling in which tasks need to be executed in a first-in-first-out order. Insertion and deletion have O(1) time complexity and queue operations have O(1) space complexity.

I also implemented a deque in the same assignment, which is a double ended queue that allows insertion and deletion at both ends. As well as being able to implement anything a queue can, deques can also implement undo/redo functionality, a feature that has likely saved the lives of thousands of programmers and data entry workers. Other features it can implement are LRU caches and Round Robin scheduling.

Balanced Binary Tree / AVL Tree

I implemented a balanced binary tree and it was my favorite assignment in Data Structures. A normal binary tree adds elements that are greater than a chosen 'root' node to the right of the root and lesser elements to the left. This part was easy enough to add. But I also needed to balance the tree so that one side of the tree does not become too long as that would result in the worst case scenario. I faced a lot more difficulty and struggle in this part of the assignment, but I got it done my struggles helped me understand exactly how this data structure worked. Insertion, deletion, and search for balanced binary trees are O(log n).

Sorting Algorithm Implementations

I implemented quicksort, merge sort, selection sort, and heap sort. Though I would always use the programming language's built-in list/array sorting methods before, these algorithms were much more useful to me now that I understood the implications of the built-in methods. All the mentioned sorting algorithms run in O(n log n) in the average case except for selection sort, which is O(n2) in all cases and taught me what not to do when compared to the other algorithms.

Acquired Skills

About

Intro to Software Development introduced me to the fundamentals and core concepts of professional software development. I found myself using what I learned from this class in my 400 level computer science classes and in my personal projects as well. Therefore I consider this to be the most important computer science class of my college career. This class is where I first learned how to use version control with Git and where I was first required to think about and draw a diagram of my project's architecture before jumping straight into coding. My favorite concept from this course is the model-view-controller software design pattern because I find it easy to understand and yet still very organized. I use this design pattern in the game I am developing in my spare time. Projects were written in Java and the Eclipse IDE.

Final Grade: A

GitHub link: https://github.com/Derek9132/CSCI-301-Intro-to-Software-Development

Notable Projects/Experiences

Memory Game

This was a basic card-flipping memory game that was to be played in Eclipse IDE's console window. Requirements were to have an object-oriented structure and have at least 10 commits to GitLab. I learned how to use Java, how to create object-oriented structure, and how to use version control. I really enjoyed this first step into the course and it set me up for success in my future projects.

Wordle Bug Fix

This project was assigned in a partially completed state, and my task was to use unit testing to fix some unintended bugs and add new features. Students were assigned a Wordle program that could just barely pass off as functional. Wordle is a popular game in which players try to guess a word with X letters in Y attempts, represented by an X by Y grid with one letter per cell in the grid. After each guess, the letters of the user's guess take on different colors depending on if said letters are not in the hidden word, in the word but not in the correct position, or both in the word and in the correct position. This barely functional version of Wordle had a bug which allowed users to input combinations of letters that did not form real words, which made the game too easy as players could simply enter one of each letter into each guess to see which letters were in the word, for example "aeiou" to reveal vowels and then "tbhgs" to further reveal unseen letters. My task was to fix this bug and also implement a difficulty feature and an end screen which would reveal the hidden word to the player. What I learned most from this assignment is the importance of unit testing when fixing bugs.

Here is a video of me very poorly playing my own assignment:

GUI Memory Game

This project was a recreation of the console window memory game, except this time it would be played on Java's graphical user interface (GUI). My primary takeaway from this project was the model-view-controller design pattern, in which the controller updates the mode and the view requests the model for the update before displaying it to the user. Not only did we have to follow this architecture but we also had to draw out UML diagrams to show how our projects would be structured. The difficulty feature from the Wordle Bug Fix assignment was also required to be implemented in the new memory game. There was no skeleton code provided, adding to the challenge. Despite that, this was my favorite project of the course.

Here is a video of me playing it and showcasing all of its features:

Acquired Skills

About

This class is all about cybersecurity. I learned about core concepts of cybersecurity, cybersecurity strategies, common types of attacks and mitigations, and real-world incidents. Throughout the course, I have had the opportunity to apply what I learned via lab sessions that let me simulate attacks on a dummy vulnerable server. Throughout the course, students are required to give presentations on a cybersecurity topic of their choice and explain its definitions, causes, mitigations, and real-world incidents associated with the topic. I chose to present on 3rd party software vulnerabilities and in doing so discovered that cyber-attacks using 3rd party software as a vector have become egregiously common as of late. In short, this course taught me common cyber-attacks and their mitigations, some low-level computer processes and how they can be exploited, and the cybersecurity trends at the national and global level.

Final Grade: A

Google Drive Link: https://drive.google.com/drive/u/1/folders/1QNBptdv-v-fCXvPu6kDlYec0X-DQs6qN

Notable Projects/Experiences

I have to say I thoroughly enjoyed the pentesting labs that this course offered. The Linux command line was a new environment for me, but my professor explained the purpose of the commands we use very clearly and was very patient with us. Seeing things from an attacker's point of view changed the way I thought about the apps and code that I use and write. Here are the labs I have completed:

Cross Site Scripting + Cross Site Request Forgery

I was able to figure out that a website failed to sanitize user input and encode output, and used this knowledge to retrieve the session cookie and execute a cross-site request forgery attack to change the user's password.

Configuration Vulnerabilities

I mounted a server and checked it's configuration to discover that it does not squash root privileges (uses the no_root_squash option), which allowed me to exercise root privileges on the server to then see the hashed passwords and unhash them as well.

Third Party Vulnerabilities

I scanned a server to identify that the 3rd party modules in use are out of date and using vulnerable versions, and I exploited the vulnerabilities in those versions to install a backdoor onto the server and gain root access. This taught me the importance of always keeping 3rd party modules and packages up to date.

SQL Injection

After discovering that a website does not validate user input, I injected SQL queries to see all the databases on the website's SQL server, see the hashed passwords of all the users, and write them to my own server to unhash them. I learned how important it is to validate user input and escape special characters in this lab.

Acquired Skills

About

The primary goal of Web Programming was to prepare students for a career in fullstack web development. What I really liked about this class is that it is almost entirely hands-on for the students and mostly hands-off for the professor. The course used a flipped-classroom style, in which students are expected to watch assigned videos and come into class on Tuesday ready to apply that knowledge in an in-class assignment. Thursdays are dedicated to the final project which required students to split up into teams of up to 7 and develop a virtual conference room website that uses Robert's Rules of Order to facilitate meetings. The professor was there to help with difficulties and motivate us with the threat of a bad grade, but other than that it is a course run mostly by the students.

I found myself learning faster than I ever have before in any of my other classes. Even if I did not watch the assigned videos, I could typically come into class and figure things out on my own or with my pair programming partner thanks to the hands-on nature of the assignment allowing me to freely try different methods and learn through trial and error. The professor was also very kind and thoroughly explains how to solve any problems I might encounter. Students were expected to finish the course with a strong understanding of client and server side operations, ReactJS, HTML and CSS, and NodeJS and ExpressJS.

Final Grade: A

Notable Projects/Experiences

CSS Flexbox and Grid

In the course's frontend lessons, I was able to master CSS positioning with flexbox and grid. To expand my knowledge on these displays in my own time, I practiced making responsive pages using flexbox and grid. There is heavy use of both in our final project.

ExpressJS LRU Cache and Batch Processing

These are two important server-side operations that I learned via class assignments. I set up an LRU cache to store request data and shorten response time by removing the need to query the database every time a request is made. I also set up batch processing alongside the cache to take multiple identical requests sent within a short time window and returning them altogether instead of slowing the server down with all the requests.

Final Project

The final project for this class was a virtual meeting/conference room site that uses Robert's Rules of Order to ensure more orderly meetings.

I was in charge of implementing server side and database operations such as creating user accounts, user authentication, and creating and joining meetings. I was able to set up a cloud database on Microsoft Azure so that the entire group could access it. I implemented registration and logins, and even allowed users to upload a profile picture. I added CRUD operations for users, committees, and motions. I also helped with some frontend here and there as necessary. Because I took this course at the same time as my cybersecurity course, I also volunteered to ensure proper security measures were in place such password encryption with bcrypt and input sanitization.

Acquired Skills

About

This course, as difficult as it was, was one of my favorite computer science courses. Like the Web Programming course, Intro to Game Design & Development was largely hands-on for the students and focused around a group project. Groups of 4 were to develop a fully fledged game using C++ and SDL2 that would look visually appealing, have solid software architecture, and most importantly be fun to play. Though the professor was mostly hands-off when it came to the final projects, he gave excellent presentations on core game development topics. Some of my favorites were behavior trees and state machines, physics engines, and story and world-building.

Final Grade: A-

Github Link: https://github.com/Derek9132/CSCI-437

Notable Projects/Experiences

Pong with C++ and SDL2

The first project in this class was to develop a very simple pong game against a computer-controlled opponent using C++ and SDL2. The goal was to get everyone accustomed to using C++ and SDL2, a very bare-bones environment that provides just enough to make a game with sounds and graphics. We would be using SDL2 for our final project as well over a full-fledged game engine like Unity or UE. I found this new environment very difficult to navigate, but thankfully I wasn't the only one and the professor was always there to help. We were also required to have proper software architecture and separation of the player's view and the game logic. Putting everything into one big main.cpp file wouldn't do. The professor expressed that if we could have two computer player objects playing against one another, that would be the ultimate proof of having understood the separation of view and logic. Though I didn't have the time to pit two computer players against each other, I do think my separation of game view and logic was acceptable. And if you ignore a small bug that causes the ball to turn into a particle accelerator and disappear if it bounces at a certain angle, my project ran fairly well. I even got minor extra credit for making my own pong and paddle textures instead of using SDL's builtin shapes renderer.

My Group's Game: Cat-aclysm

Somewhere in another galaxy, a planet is discovered that is proven to have the requirements to support life. A team of five scientists is dispatched to this strange new world to study the alien species that may live there. One of them insists on bringing his beloved pet cat on the expedition, claiming that it will be useful as an emotional support companion. When the owner is bitten by one of the planet's diseased and aggressive alien mice, however, the cat becomes far more necessary than just an emotional support pet. The cat must navigate the strange planet and do battle with the martian rodents to secure the components necessary for their owner's cure. This is the story behind our game, Cat-aclysm.

Cat-aclysm is a box-pushing puzzle game that features otherworldly music and art to create the atmosphere of an unfamiliar and potentially dangerous place. The game consists of four puzzles scattered across the map, each with several boxes, enemy mice, and the ingredient for the cure that the player needs. Players can click E to scratch at the mice or R to hiss to leave them frozen in fear and unable to move. Clever players may figure out that the mice need not neccessarily be killed, and that careful pushing of the boxes while avoiding detection allows them to simply trap the mice. Players can click i to interact with a scientist. Doing so will heal the player and save the game.

My primary tasks for this game were creating and rendering the map, handling animations, NPC interaction, and making all the art. This included the tileset for the map, the user interface components, and all the frames of the animations for each of the game actors. I also got to help with the enemy AI and camera movement. While I was a junior, the other three members of my team were seniors with ample experience in optimal coding from their internships. They were always willing to explain the code they wrote, the thought process behind, and the procedures they took to avoid overhead. I learned more from them than even the professor. This was also my very first time building a software as part of a team. I adapted to collaborative version control smoothly and always updated my team members of my progress via Slack.

Here are some of my best sprites:



Here is a video showcasing all the game's features (cutscene, NPC interaction, save and reload, movement, attacking, etc):

Acquired Skills

About

Reinforcement Learning was a Python-based Data Science course that focused on core concepts and algorithms found in reinforcment learning and AI. I got to learn how reinforcement learning differs from supervised and unsupervised learning, evaluations of policy and value of an agent (in simple terms, how the agent makes decisions and is rewarded), and the ever-important Bellman equation and Markov decision process. Though I had never taken a data science class before, the professor did a wonderful job at helping me navigate through the difficult content and the confusing algorithms. Projects were written in Python and included policy and value iteration on stochastic VS deterministic environments, Monte Carlo vs Temporal Difference, and deep Q-learning. For my final project, I used Unity game engine's ML-Agents package to attempt training two agents to play hide-and-seek against each other.

Final Grade: A

GitHub Link: https://github.com/Derek9132/DATA-320

Notable Projects/Experiences

Deterministic vs Stochastic policy with Frozen Lake

My first assignment was to use policy and value iteration to train an agent from OpenAI Gymnasium's Frozen Lake environment. The primary goal of this assignment was to understand the difference between a deterministic and stochastic policy. A deterministic policy will always map a state to a specific action. In other words, the agent is guaranteed to take a specific action based on which tile it is currently standing. That is why the agent using a deterministic policy immediately finds its way to the gift. A stochastic policy, on the other hand, uses a probability distribution sample to select the next action on a given state. This is when the agent actually has to decide on which action to take. And if you watch the agent using a stochastic policy, it certainly does seem like there is more thought being put into each action. The agent takes longer to reach the goal as it often decides incorrectly.

Deterministic Policy
Stochastic Policy

Monte Carlo vs Temporal Difference

My next assignment focused on model-free learning and the difference between on-policy and off-policy learning. Monte Carlo methods and temporal difference learning are both model-free methods, meaning that the agent does not need knowledge of a model of the environment and makes decisions based only on how it is rewarded after each action. Think of it like two different ways to learn a new game. Model-based learning is like learning to play chess, in which players must learn the rules of the game beforehand. Model-free learning is instead akin to playing a new video game that gives little to no guidance on what to do, leading to the player mashing buttons and trying new things until they find out what works.

Monte Carlo is on-policy with zero bias but a high variance, meaning that the value estimates are all over the place but are on average accurate. Temporal difference has little variance but some bias, meaning the value estimates are stable and close to the target value but never perfectly accurate. In most cases, temporal difference learning is more efficient than Monte Carlo.

Final Project

Seeing as I was taking Intro to Game Development concurrently with this course, I decided to attempt making a game in which players could play hide-and-seek with an agent trained with deep learning. My plan was to have two agents with the tags "seeker" (in red) and "hider" (in blue) and train them against each other in a series of obstacle courses. Once the models were properly trained, the player could give themselves the hider or seeker tag and play against the opposite tagged agent who would try to find or avoid them. I set up various obstacle courses featuring spinning walls, ramps, and corners. I have provided a video of the training environment below. The agents were trained over 6,750,000 steps and each training session took roughly 4-5 hours. I have also provided a video of the training process that compares the first 10 minutes of the training to the 4th hour. The seeker agent learned after roughly an hour and a half that it needs to make contact with the seeker agent to get its reward. Unfortunately, as you can see from the training video, there's something off about the hider agent's behavior. Instead of trying to escape and hide, it just sort of stays there and shivers in fear. I must have made a mistake in how the hider agent is rewarded and penalized. I can't say it turned out exactly like how I wanted it to, but it was still so fun watching my seeker agent gradually learn to move towards the hider until eventually it just makes a beeline for the hider as soon as it sees it. It was an amazing learning experience and I don't regret choosing to do this project at all, though I do wish I had a few more days to perfect it.

Environment setup
Training Process

Acquired Skills