What are UFBs
About UFB
Class Software Projects
Ray Marching Rendering Engine
For my final project for a computer graphics class in 2024, I created a graphics rendering engine that can render simple 3D objects using shaders (code that runs on the GPU instead of the CPU). I used a popular technique called Ray Marching, which instead of using the standard rendering method of defining a 'mesh' of points for a 3D object, renders objects using math equations. The basic premise is that you can come up with an equation for most shapes that will tell you how far away any point is from the surface of that shape. This is called a Signed Distance Function. For example, the distance between a point and a circle is the distance between that point and the center of the circle,
minus the radius of the circle. Using these functions you can render objects by essentially casting a 'ray' or a line towards every pixel on the screen and seeing what the distance is to the nearest object. Once you have that working, you can combine objects in interesting ways using other fun math which can create some really interesting effects. If you're interested in the technique, check out this YouTube video as it's a lot easier to understand with visuals and a more in-depth explanation.
Concurrent Transactions
During the fall of 2024, I took a class entirely focused on concurrent programming, aka how to write code that can run on a machine with multiple cores without causing all sorts of crazy issues, including my favorite term from the class 'Heisenbugs', which are code bugs that are sometimes there and sometimes not. The fundamental problem faced when writing concurrent code is how to ensure things happen in the order you expect when anything from minor time delays to compiler optimizations can cause your code to do
unpredictable things. There are many techniques we learned in this class to guarantee our code would execute as expected. Those techniques ranged from the standard libraries used for synchronization, to how to build the basic functionality those libraries provide. In this final project, I created a simulation of a banking systems where hundreds of thousands of transactions need to be processed without money going missing mid-transaction. To do this, I implemented several different synchronization methods including a Single Global Lock, Two Phase Locking, C++ Transactional Memory and a custom implementation of the optimistic concurrency control algorithm TL2. With each of these methods, I was able to compare the run-time on several different distributions of transactions and different thread counts to see how different synchronization methods responded to congestion and parallelization. Unfortunately, due to this being a class assignment that gets reused every year, I cannot publish my code, however, I would be happy to share it with you if you are interested.
Modeling Plant Behavior
During the first semester of my masters, I took a class with the mouthful of a title: "Theoretical Foundations of Autonomous Systems." In this class, we learned about different ways to model systems to be able to make different types of formal guarantees about those systems. This is useful for software systems that need to, for instance, never fail, such as a pacemaker. For my final project in this class, I looked into different ways to use one of the main tools we studied: Deterministic Finite Automata (DFA) to model plants. There are several different ways to do this but my project centered on a paper that proposed a way to use a DFA to model disease outbreaks in potato and tomato crops.
Pantry Chef
I took a class call Software Development in the fall of 2021. This class focuses on introducing students to the variety of software platforms and languages used in application and website development. As our final project, my team built this website which helps users in the kitchen by finding recipes involving ingredients they already have in their pantries. It also doubles as a recipe-sharing platform, allowing users to add recipes to the database. I learned a ton working on this project though I now I keep forgetting the syntax of a 'for loop' because I'm learning too many languages at once.
RRT Algorithm
For my final project of my Programming and Data Structures class in the fall of 2020, I implemented a simple version of an algorithm used in robotics for mapping areas and finding paths between starting and ending locations. The RRT (Rapidly Exploring Random Trees) algorithm works by building out a tree of connections leading towards random points on the field. The algorithm fills up the space, avoids obstacles and finishes when the ending location is reached. The code then returns a path from beginning to end, though it is not necessarily the shortest possible path. For a more detailed explanation of the algorithm, my code and my process, check out my Github repository.