I love all things computers, whether it be systems, linux, graphics, or video games!
My passion when programming is working in lower level languages working on cool computer systems: previously, I've worked on operating systems, computer networks, and some fun computer graphics projects.
I'm currently a Junior at Brown University pursuing a Sc.B in Computer Science. Outside of computers, you can find me reading or cooking some (hopefully) delicious food.
Being a Head Teaching Assistant (HTA) for Brown's CS department meant that I gained a lot of experience leading and running a course with the professor and fellow HTAs.
We lead a team of 19 TAs to support the ~150 students taking CSCI0170, an introductory course in CS. I helped redesign some of the course projects and helped some TAs write some needed code. Lastly, I helped coordinate staff meetings which to communicate our next steps with the course with the UTAs.
SPOCs are the undergraduate assistants for the System Administrators (technical staff) of Brown's CS Department. We essentially have the capabilities to do anything a System admin can do. We manage any tickets sent to the problem email and assist with the maintenance of Department hardware and software. Additionally, we monitor the department systems on nights, weekends, and holidays. A further description can be found here
Being a SPOC has been a wonderful time! We are really given the chance to learn a lot about Linux and general System Administration. I've had the chance to respond to many tickets and work on many projects. For instance, I helped out the the department's local VM image: CS Home Edition. Additionally, I've helped setup the backend for websites and added the ability to have any machine you login to know the desktop environment (gnome, xfce, etc.) you used at the last machine.
CS TAs at Brown truly care about the work they are doing. Someone becomes a TA because they loved taking a course and want to learn more, but, more importantly, they want to help the future students taking the course
During my time as UTA, I've held weekly lab and office hours for students. I've test class projects and prepared assignments to be released. I've even spent the grueling hours grading student assignments. Ultimately though, I love interacting with students and teaching them about topics I'm passionate about.
Weenix is the labor of my time in CS1670/1690 (Operating Systems) at Brown. It was a semester long project dedicated to coding an OS, similar to the original UNIX OS, in C. To some, Weenix being written in C is a given (real operating systems are written in C ;)), but I'm just excited about Rust being introduced to the Linux kernel.
Weenix consisted of five semi-projects:
This was a 2/3 semester long project to built an IP/TCP stack from the UDP-based ground-up.
Instead of dealing with a complicated OSI Level-2 hardware implementation - we encapsulated our packets in UDP.
We started with creating a "node" program - which acted almost like a router. It implemented IP packet sending and forwarding - each node could connect to others node and used RIPv4 to communicate.
On top of IP, we implemented the classic TCP Protocol and were able to send 1MB files between nodes reliably.
As part of my embedded software course, some friends and I created a Color-sensing RC Car with an Arduino
The car is remote controlled by the button array on a second Arduino we call the transmitter. The car requires a WiFi connection as we use the local network to send data from the transmitter to the car. Each button represents a direction and on a change in state (!pressed -> pressed and vice versa) triggers an Interrupt Service Routine
The car features a watchdog for safety, motor drivers which are PWM controlled, and it's independently powered.
Per the "color-sensing" capability, the car responds to color that it detects, using a color sensor, below it. It will stop for 2 seconds on Red (with a 5 second timer before stopping again), slow down on blue, and speed up on green.
Lastly, we wrote a report for our project. It contains safety and liveness concerns, project requirements, finite state machines for the receiver and transmitterm and more!
As a final project, my friends and I wrote a planet generator using the mystical GPU powers of OpenGL.
To create your own planet, you can use an on-canvas brush to draw what terrain you want to be on the planet. Then we take the brush data, create a height map interspersed with perlin noise, and displace the vertices of a sphere to create the planet.
Currently, the planet supports three terrains types (with coloring dependent on type): water (the base sphere coordinates), flatland (slightly spiky and green), and mountains. On top of this, I implemented a skybox behind the planet and a custom toon shader to make the planet look nice :)
A really satisfying project, this was a C++ Raytracer developed from scratch with the help of the Qt Framework.
The Raytracer supports: shadows, recursive reflections and refraction, and texture mapping. The raytracer was done using Phong Illumination, and we load in primitives to the scene with a custom scenegraph parser.