Over the past 4 years at UT I have taken a variety of computer science classes. These include required classes, and a number of upper division electives which I was able to choose at my own discrestion. Some of my personal favorites include Autonomous Multi Agent Systems, Compilers, and Object Oriented Programming. If you'd like to see all of the classes I've taken, then feel free to have a look at the different years on this page. You may also be intrested to see some of the more interesting projects I have completed for school, which can all be found under Favorite Projects.

Freshman Year


CS 314 – Data Structures and Algorithms, Dr. Gordon Novak

  • Went over various basic data structures (arrays, linked lists, hash tables, etc.)
  • Discussed various algorithms (searching, sorting, DFS, BFS, Dijkstra, etc.)
  • Learned the basics of Map Reduce


CS 313k – Logic, Sets, and Functions, Dr. Vladimir Lifschitz

  • Went over the fundamentals of logic
  • Learned how to complete simple proofs

CS 429 – Computer Architecture, Dr. James Peterson

  • Learned the basics of computer architecture
  • Went over various computer architectures (X86, ARM)
  • Learned the fundamentals of C programming
  • Wrote a variety of C programs, including a Y86 simulator and polygon adjacency

CS 378 – Computational Biology, Art Covert

  • Learned basic Python programming
  • Did introductory research in the field of computational biology
  • Completed a group research project over the effects of resources on populations

Sophomore Year


CS 439 – Operating Systems, Dr. Alison Norman

  • Went over various OS topics such as file systems, memory management, and security
  • Implemented different parts of Pint OS, a toy operating system
    • System calls
    • Threading
    • File system
    • Virtual Memory

CS 105 – Introduction to Perl Programming, Curtis Dunham

  • Learned the basics of programming in Perl
  • Completed a variety of projects, including a program to find the distance between actors and Kevin Bacon


CS 331 – Algorithms and Complexity, Dr. Greg Plaxton

  • Went over various common algorithms
  • Learned how to determine the complexity of an algorithm
  • Introduction to dynamic programming
  • Implemented an algorithm over a series of programs, with each program being more efficient, after doing various exercises over the current iteration of the program

CS 356 – Computer Networks, Dr. Mohammed Gouda

  • Went over the following networking topics:
    • TCP and UDP
    • Topology
    • Routing and Switching
    • Wrote toy networking protocols using Abstract Protocol Notation

Junior Year


CS 347 – Data Management, Dr. Philip Cannata

  • Learned basic SQL programming/querying
  • Went over various data management topics including:
    • Data modeling
    • NoSQL vs SQL
    • Transactions and Concurrency
  • Created an application using Oracle Apex

CS 378 – Big Data Programming, David Franke

  • Learned about the Map Reduce paradigm
  • Completed several Map Reduce programs on AWS that implemented the concepts discussed in class

CS 371p – Object Oriented Programming, Glen Downing

  • Learned the fundamentals of C++ programming, and how they compare to their equivalent practices in Java
  • Completed several projects, with a focus on gaining an insight into real world programming through the use of git, pair programming, issue tracking, and documentation


CS 375 – Compilers, Dr. Gordon Novak

  • Went over the basic building blocks of a compiler
  • Discussed various compiler optimizations
  • Implemented a Pascal compiler (lexer, parser, code generator) using C and yacc

CS 350f – Operating Systems 2, Dr. Aloysius Mok

  • Discussed several advanced operating systems topics including:
    • System calls
    • Synchronization
    • Virtual memory
    • File systems
    • Deadlock detection and avoidance
    • Generalized rate monotonic scheduling
  • Completed several basic projects involving the Linux kernel

Senior Year


CS 354 – Computer Graphics, Dr. Don Fussell

  • Learned about several graphics topics including:
    • OpenGL programming
    • Rasterization
    • Coordinate transformation
    • Light and reflection models
    • Shaders
    • Ray tracing
    • Hierarchical modeling
  • Completed several programming assignments in OpenGL including a model viewer, scene graph manager, and ray tracer

CS 344m – Autonomous Multiagent Systems, Patrick McAlpine

  • Learned about a variety of topics that relate to multi agent systems including:
    • Agent architectures
    • Inter-agent communication
    • Distributed decision making
    • Multiagent learning
  • Completed a research project/paper in the RoboSoccer domain


CS 378 – Declarative Programming, Dr. Vladimir Lifschitz

  • Learned about the field of declarative programming
  • Wrote numerous programs using the CLINGO programming language
  • Discussed the theory behind CLINGO and other answer set progrmming languages

CS 341m – Mobile Computing, Mike Scott

  • Served as a refresher course for my Android programming skills
  • Went over a variety of Android programming topics including:
    • UI development
    • Hardware services
    • 2D graphics
    • Local data storage techniques
    • Cloud data storage techniques
  • Created a fully functioning Android app, PhotoHunt along with two other students. (Aila Enos and CJ Kim)

Favorite Projects

Choose a project from the dropdown below.

Y86 Simulator

Computer Architecture was the first time I felt challenged in a computer science class. The C programming language proved difficult to learn at times, but by the end of the class I was starting to feel more confident in my skills. Our final project was the creation of a simulator for the Y86 (a simplied version of x86) architecture. The program ended up being a joy to write, very interesting to architect, and I am very proud that I completed it. You can find the project on GitHub here.

Computational Biology Paper

During my first year at UT I had the opportunity to take part in the Freshman Research Initiative (FRI), a program that provided freshman with introductory research experience. I was placed into the computational biology stream where I learned about how biologists and computer scientists used programming to simulate biology and evolution. Although it was an interesting class, I ended up choosing to not continuing to participate in the program. I did however write a research paper at the end of the semester with 2 other students. Given that I was still a freshman, I am very proud of the paper and had fun working with the other students. If you'd like to read it, you can find it here.

Degrees of Kevin Bacon

Perl is probably the most esoteric language that I have learned while at UT. The final project in the Perl class I took was to write a program that parsed IMDB data into a graph data structure so you could find the shortest path between any actor/actress and Kevin Bacon. This would then give you the Bacon Number of the actor/actress. This wasn't a super challenging project, but I definitely had fun writing it. Most fun of all was the loading bar I made which started going backwards at around 50%. I had alwas joked as a kid that slow loading bars jumped backwards when you weren't looking. Thus, my loading bar was an homage to that idea. You can find the code for this project here.

Pascal Compiler

I took Compilers during the spring semester of my junior year. Throughout the semester, we gradually created a basic Pascal compiler. Starting with the lexer, then the parser, and then the code generation, I created a program capable of producing runnable programs out of fairly simple Pascal programs. It was definitely one of the more challenging projects I have completed during my time at UT, but would always provide great satisfaction whenever I overcame a challenge.

Autonomous Multiagent Systems Project

During the fall of my senior year I took Autonomous Multiagent Systems. The class provided an introduction into the topic and a variety of sub-topics. The class also delved into the practical applications of the subject through the RoboCup Soccer league. For the first half of the semester we completed a series of labs focused on programming in RoboCup, and then for the second half students performed completed a research paper of sorts via the RoboCup software.

I chose to investigate the practicality of applying cooperative pathfinding to a RoboCup team. The project was fun, challenging, and the results quite positive and interesting. If you'd like to read my final paper, you may so here. You can also find all of the code I wrote here. Unfortunately I am not able to release the full code base as it is the property of of UT Austin Villa team.