Tag Archives: utexas

gates_speedway_day-350

A Review of my University of Texas Academic Career

After having completed the requirements for the Bachelor of Computer Science at the University of Texas, I feel it is a ripe time to do a quick review of the classes I took for my degree.

Freshman Year

CS 315, “Algorithms and Data Structures”: This class was the second of the required “entry-level” courses at UT. I found the class adequately covered data structures  and equipped one well for an interview. I took advantage of using Lisp, which first introduced me to functional programming. We worked on an interpreter which could take a set of functions and known variables, and solve the entire system if possible. Additionally, you also end up implementing Dijkstra’s, A*, and other path-finding algorithms. However, I didn’t find the lectures very interesting.

CS 313K, “Logic, Sets, and Functions”: This was the introductory logic course. The first part of the course is very easy and covers boolean logic. The second part covers sets and proofs. I got a little behind in the class since it was my freshman year and found induction proofs to be difficult at first, and I didn’t enjoy them. However, they prove extremely useful when planning and implementing recursive algorithms. Set logic is also very useful and can be easily implemented in languages with set notation (Haskell, Python, etc).

CS 378, “Autonomous Vehicles in Traffic”: This class was and was one of the Freshman Research Initiative courses offered at UT. Basically, we learned about Marvin, the University’s autonomous car. You get rudimentary C++ knowledge and implement a road-detection using OpenCV. The class was pretty easy in my opinion, and you were exposed to various frameworks such as ROS and OpenCV. It’s worth taking if you haven’t been exposed to anything I mentioned above.

CS 336, “Analysis of Programs”: This class built upon CS 313K, focusing on induction proofs and dynamic programming. The class was a bit tougher but not impossible. The lectures were fairly good, but I personally don’t find the logic types of classes to be extremely engaging. Again, a decent class covering a good section of theory.

CS 439, “Computer Organization and Architecture”: This was the first of the “Systems” classes at UT. You are thrown into working with C quite early and focus on how the processor works. The first assignments are essentially optimizations using bit manipulation, but this class had one of my favorite labs, the “Bomb Lab.” In this particular assignment, one had to enter a series of code phrases into an executable provided by the instructor. The catch: every time you entered an incorrect code, the bomb “exploded” and you lost points. You had to disassemble the program and read through the Assembly to find the correct input. One of the most useful classes at UTCS.

Sophomore Year

CS 344M, “Autonomous Multi-agent Systems”: This was a research oriented class which dealt with managing multiple agents in a distributed system. I still have the textbook, as it has lots of interesting material ranging from consensus-building to efficiency to individual decision making. We read some fascinating research each week and wrote responses, I’ll list some of these publications at a later date. The final project is actually building a virtual soccer team of independent, but collaborating agents to compete in the “RoboCup.” Interesting stuff.

CS 439, “Principles of Computer Systems”: Also referred to as Operating Systems, this class is one of the most challenging in the entire curriculum. However, in my opinion it is also the most valuable. We build off 429 concepts and learn about the low level implementation of algorithms. First we implement semaphores, mutexes, locks, and multi-process scheduling in a teaching OS called Pintos. Then you move on to implementing system calls, memory management and paging, and finally a file-system. My team met for almost 4 hours every day to work on the project. It was hard as crap, but I learned more in this class than any other.

CS 345, “Programming Languages”: I took this class with Professor Cook, who first introduced us to Haskell before going into detail about scoping, environments, and expression evaluation. You end up implementing a JavaScript interpreter in Haskell (how cool!). This was also one of my favorite classes.

CS 378, “Algorithms and Complexity”: I took this class with Prof. Zukerman and did not like it that much. I felt the lectures were straight out of the book, and the tests had nothing to do with the lectures. I got a 68% in the class and it was rounded up to a B+ (!). Haha. Beware this class, I believe it is renamed CS 331. We basically covered the same stuff as in the other logic classes and I remain unimpressed by the reason I was required to take it (namely, graduation requirement changes).

Junior Year

CS 371M, “Mobile Computing”: This is an interesting “app” development course taught by Mike Scott. You cover the libraries and implementation methods for working on an Android system. You get out what you put into this class, so I would advise implementing a slightly more difficult project idea, since you will learn more. I built an app for meeting people near you studying. I implemented Facebook authentication, a backend server in CakePHP, an adapter for integrating data between the device and the server, and implemented push authentication. I thought it was a good course, and would recommend.

CS 350F, “Operating Systems”: I just finished this class… A bit of a letdown. We covered a subset of 439 and in less detail. The professor and lectures were a bit unorganized. I found the class to be kind of pointless since there wasn’t anything new for me to learn. Wouldn’t recommend.

CS 375, “Compilers”: Yes, Prof. Novak’s lectures are quite dry, but I still enjoyed writing a compiler. I couldn’t really tell if this was a tough course, or if I just have terrible senioritis… You only have to work like 2-3 solid days for each of the 5 major assignments, and in the end you have a Pascal->Assembly compiler. Pretty sweet. I would recommend this to stretch your programming and debugging ability, as well as your patience.

CS 373, “Software Engineering”: One of the most practical, pragmatic courses offered at UT, taught by Prof. Downing. In this class you work with Python, Django, and SQL to build a web application in a larger (6 person) team setting. This is a valuable class, especially for anyone who hasn’t worked on such a project before. Prof. Downing is very good and clearly cares about his students, which is an added bonus.