Reviews

Pros: 1. Lectures are easy to follow with engaging Professor 2. Go at your own pace class 3. Fun assignments Cons: 1. Explanations were too superficial 2. Felt like half a class 3. No math at all Detailed Review: I enjoyed the class and thought the programming assignments were fun. All the assignments are released up front, so there is a lot of freedom if you have some busy weeks. Some people front loaded the class and finished in a month or two. The professor is interesting to listen to and his coding examples in the lectures will help in the programming assignments. The homeworks were rewarding to code up and quite fun to do. My main criticism is that this felt like half a class. I know that in 2024, this class had some content removed when the ADL class was created. However, now the class is just too easy. If you have a CS background, expect about 5 hrs per week on average. I don't have a strong programming background and do not program day to day. There are some recent reviews (from after the class was redesigned in mid 2024) that claim the class was 15 hours a week, and I have to assume those are students coming from a non-cs background --- perhaps in the MSDS program. If you do have a CS undergrad, I would suggest taking this class together with another class, as it was too easy. I think skipping DL and jumping into ADL is also a very viable alternative for many. I also disliked that the professor didn't really show any math. I am fine with the class being all practical, but I feel like he could have shown eg a small convolution example on a matrix, etc. Honestly, there was more math and detail in Andrew Ng's Coursera DL class than in this graduate level class, which I found disappointing. I finished the class mid October and kind of felt like I was cheated since I am paying out of pocket. This felt like half a class. If you are looking for a very easy A, this class many be for you. There should be a final project or an additional hw assignment. I did like the mini quizzes that followed the lectures, as they helped me pay attention during the engaging lectures. All the assignments are autograded which I liked. The threshold to get an A is pretty low, and you don't need to do the extra credit or finish all the assignment tasks to get an A. My 6 hrs per week for this class included doing all the extra credit on the programming assignments, and honestly doing the extra credit was half of the work. If you are aiming for a lower A, the workload would be even less.

Pros: 1. Learn a wide array of topics, including containerization, microservices, serverless etc. 2. Can work in teams for labs 3. Fair Exams Cons: 1. HW seemed too "linear" 2. TA's unresponsive on edstem at times 3. Detailed Review: What I liked most about this course is how in the lectures we covered new topics regarding containerization, microservices and serverless, all hot topics in the industry today. The exams were fair, and it seemed they were graded fairly as well. My main issue with this class was the labs. The setup for the lab itself was a bit convoluted and many people using the local setup had issues and had to request remote access to a UT machine. The labs themselves were fill-in the blanks where it seemed like we used someone else's implementation, and the prof went in and just deleted a few methods that we had to fill back in. While it wasn't hard, it seemed like we didn't learn what each step was doing in depth and why we were doing what we were doing, rather just following the hints provided as sort of a roadmap of what code to write. The TA's were helpful during office hours, however, I felt like on edstem(piazza's replacement) it seemed like there would be 2-3 days before TA's would respond to a question at times. However, a lot of the office hours (especially in the last 2 months of the class) were cancelled/rescheduled. One good thing about labs is the ability to work on teams, however, since each lab built on each other and every part of the code was interconnected it was a bit inconvenient switching between teammates to split the coding part, and we ended up having one person doing the coding for last 3 labs.

Pros: 1. If you're rusty on your C, this course will throw you into the fire and force you to learn it quickly or drown. 2. If you enjoy a course with heavy coding emphasis, and a learn-it-yourself structure, you'll more than likely do fine here. 3. Book is a great read. Cons: 1. TAs not responsive 2. Lecture material is not sufficient for the new projects. 3. Project team structure is not really beneficial because the workload split is not immediately clear. Detailed Review: This class was recently 'restructured' to use Pintos as the class project. Since this is the first semester, I hope this doesn't apply in the future, but that was about all the restructuring done here. The lectures are outdated and still reference the old assignments, providing no guidance on the new assignments. To top it off, I think the project requirements are also just ported over from Stanford, so that is about all the guidance you'll get. Nothing helpful is produced by the TAs on the Ed discussion boards, if they answer at all. In total, there are 5 projects - the first an introductory shell, and the rest are Pintos projects. Projects MUST be done in groups, with little flexibility to work by yourself. Here's the issue: since the projects are so poorly guided, you'll likely not be able to take advantage of having teammates because you won't even know what work needs to be split. In my case, that meant everyone on my team working on every project by themselves hoping something would work. If you're unlucky, that might mean you implement the working solution every single time and your teammates get to stop suffering before you. On top of the coding portion, assignments also have design documents, which by themselves, are not terribly bad. These are worth 20% of each project. Lastly, the timing of the projects felt slightly off. The introductory project seems to get a lot more time than the last two projects. As is, the last month of class has you churn out a midterm, 2/5 projects, and a final. Not fun. On top of projects, the course kept its 2 exams - 1 midterm and 1 final. Exams are worth 30% of the grade. Due to how much of the course is devoted to the projects, this part of the class really felt like a separate course. You are allowed a cheat sheet for the exam, and it's wise to spend it on the outdated lectures. However, the exams were not terribly difficult. Overall, this course does let you learn a lot on your own at the expense of a stressful, high workload. You can expect to spend a good chunk of your weeks working on the Pintos projects, including referencing outside material trying to get some background knowledge. If tweaked, the course could be an enjoyable learning experience for those who are interested in OS. I would not recommend taking this course with another class.

Pros: 1. Course material covered up-to-date topics 2. Professor was highly engaged 3. Well-designed assignments Cons: 1. A lot of scattered topics 2. Not much assignment coverage in the last part of the class 3. Some of the topics could have been explained better Detailed Review: I didn't enjoy this course as much as some of the other reviewers. The course covered a wide range of topics in NLP that didn't necessarily follow from each other. This can be good if you want exposure into a lot of different topics in NLP. On the other hand it made the course feel unfocused and it was hard watching through the many hours of lectures. One great thing about the course was that the professor was very involved on Piazza and was committed to updating the course materials with recent topics in the field. The assignments in the first half were a good way to revise the materials covered in the lectures but towards the end of the course they became irrelevant to the assignments.

Liu's lectures were far more straightforward than Klivan's lectures. I found Klivan's teaching style confusing with the lack of concrete examples. Liu's half of the course was much better because the assignments correlated more directly to the lectures, and it was easier to grasp the concepts this way. Expanded Grading: Rating: 2 Klivans, 4 Liu

Pros: 1. Provides a rigorous overview of data structures and algorithms that prepares for future classes and job interviews 2. Active instructional staff on Piazza and several office hours are available each assignment Cons: 1. Lectures very high level, typically insufficient for preparing for quizzes or assignments 2. Opaque and slow grading limits learning from mistakes 3. Very run-of-the-mill course, minimal specialization of material for data science Detailed Review: Disclaimer: I recently graduated from UTCS taking the undergrad Data Structures and Algorithms courses as well as tutoring various versions of Data Structures, so while I did not particularly have issues with this class I will try to think through the lens of an average student in this program. This course is essentially something you would find in any computer science degree plan, so those in this program without a background in computer science may struggle more than others. The prerequisite of "one semester of coding" really depends on the quality of that semester and whether the coding was in Python. I personally did not find the lecture delivery very effective. I'd often lose focus waiting for the professor to write things on the chalkboard. Also, I found the back-and-forth with another student during lecture to add little to the discussion. While I agree with the professors intentions to focus on building a conceptual understanding of the data structures and algorithms first, too much time was spent on this leading the lectures to be mostly insufficient for application later on. Luckily, all of this material can be found across multiple reputable sources on the internet. The quizzes appear to have been a problem in previous iterations of the course, and they continue to be problematic. Though you can easily learn all the material on your own, it is still crucial to watch the lectures because many quiz answers are derived specifically from what the professor said in lecture. The average quiz scores were quite low, likely due to several questions each quiz that were overly subjective or beyond the scope of the lectures. After mixed results irregardless of my understanding of the material, I stopped caring about the quizzes and focused on the assignments since their weight was much heavier. Assignments increase in their weight and difficulty as time goes on in this course. Set-up in PyCharm and turn in through GitHub on Gradescope were simple following their provided instructions. The starter code for assignments were well-documented, but I felt that the assignments specs were often lacking in details which made testing the programs difficult. Luckily, the TAs were active on Piazza and would clarify any questions individuals had on the details of the assignments. It was particularly helpful when the TAs made a stickied post on Piazza summarizing all the clarifications per assignment so that no detail would be missed. The tests provided in the starter code were a nice start, though grading on assignments was very opaque. It's unclear how different tasks are weighted until you receive the final grade, and the feedback from the autograder is very limited. Grades would be received roughly a week after the assignment was due, in the middle of the next assignment, so learning from mistakes on the previous assignment was limited to a degree. Overall, it appears this course has improved logistically, but remains mediocre in its contents and assessments. Luckily, there is a curve promised to balance out the difficult quizzes and assignments, but I feel like that shouldn't be necessary in this type of course. This course is rigorous, but if you put in the time to learn the material it should give you an edge in your data science career and be helpful for the rest of this program.

Concepts here are more interesting than the actual assignments. The assistant prof does a great job of breaking down the math-heavy sections of the book, but I do think they needed way more example problems than they currently offer. They primarily just need to figure out the platform that they provide assignments on -- weekly homeworks have annoying 'all or nothing' type questions, the programming results are very binary and annoying to debug, and the final was more difficult merely due to the time constraint. It makes learning the material more stressful than it needs to be. I'll also note that the program/conceptual difficulty jumped up quite a bit for me in the back half. I ended up having to take some of the deep learning lectures to learn how to implement the NNs with pytorch. With that being said, it's fairly easy to get a high grade as you can hit a 70% before you even take the final if you spend enough time on the homeworks/programming assignments.

Pros: 1. Lots of content is covered 2. No exams 3. Fairly straightforward homework (not too many hours to complete) Cons: 1. Example code needs to be refactored 2. No reference textbooks on syllabus 3. Some of the math notation on the slides is confusing Detailed Review: Overall I really enjoyed all the contents of this course. It did cover material that you would normally find in a regression course like simple / multiple linear regression, regularization, ANOVA testing, F-tests, and logistic regression. However it also went into several other more advanced topics such as Bayesian regression, nonlinear regression / newton raphson, parametric and nonparametric bootstrapping, GLMs, metropolis hasting algorithm, Gibbs sampler, EM algorithm, mixture models, and non-parametric methods such as trees, splines, and kernel smoothing. The only downside is that most of the methods weren't put into context of an example problem / dataset. So you will need to find external texts / references such as Elements of Statistical Learning for that. The homework for the most parts were fairly straight forward. Most took anywhere from 2 hours for the easiest assignments up to 8 hours for the toughest ones. Around 40% of the assignments are multiple choice and the rest are peer graded. Most assignments were around 60% deriving various mathematical results and 40% programming (most used R, but you are free to use whatever programming language you prefer). All of the datasets are fabricated/simulated data made up from the course staff, so again no "real world" toy datasets to apply the material with. You pretty much have to code up the solution using only basic tools such as matrix operations, functions, and loops to derive the solutions and not use pre-made packages. I thought this was good because it reinforces the mathematical theory even though you would never use these implements in a real world setting. The example code needs to be refactored. Plenty others have complained already about this so I won't go any further on that. Some of the notation in lectures is ambiguous. For example vector and scalars don't use the typically notation where the vectors are differentiated from scalars using bold font. Also the prime symbol ' can mean a matrix transpose or a derivative. Sometimes a random variable would be written as equal to its pdf function instead of showing that it's distributed according to that distribution. You could usually figure it out most the times by the contexts, but it did make following the slide more difficult than necessary at times. Overall I enjoyed the course.

Pros: 1. Great professor/TA engagement on Piazza 2. Very generous grading policy 3. Long windows to complete assignments Cons: 1. Lots of rambling in stats lectures 2. Better (free) textbooks out there 3. Statkey (and the approach to statistics problems more generally) Detailed Review: Overall, I did not find this course to be very difficult, but it's not a cakewalk either. As others have mentioned, the probability sections are notably harder than statistics, but both will be mostly review if you've taken the respective undergrad courses. The grading policy is quite generous - they drop your lowest two quizzes (out of six) and lowest two homeworks (out of 13). It's also pretty flexible time-wise - though the quizzes (30 minutes) and two midterm exams (2 hours) are timed, you have a week-long window to complete them. Homework assignments are usually out at least two weeks before their due date as well. Dr. Parker and the TAs were very engaged on Piazza - pretty much every post got an instructor answer within a few hours. Lectures are ok, though the professors have very different styles. Dr. Mueller (probability lessons) tends to be very straightforward, almost to a fault, and had me pausing and rewinding quite a bit. Dr. Parker (statistics), on the other hand, often over-explains things, and I found myself just going to read the slides instead (the stats slides are good reference material, to be clear). The probability textbook was somewhat useful, but it's dense and can take a couple read-throughs to make sense. I found myself referring to Blitzstein and Hwang's Introduction to Probability (free online) when I needed a clear explanation of something. I barely used the recommended stats textbook at all, but to be fair, it's listed as optional. My biggest frustration with this course comes with how the statistics problems (homeworks, quizzes, and exams) are structured. I think Statkey is a good tool for demonstrating concepts, but not so great to be graded on. At a certain point, you're being graded on whether you can repeatedly click buttons in the right order, not on how well you interpret the concepts. The delicate balance of machine grading vs. statistical variability is also problematic - I found myself running 20+ iterations of a simple trial on more than one occasion because I didn't get a clear alignment with one choice over the other. That's not because of anything I did, it's just that the answer choices aren't always well calibrated for the data in the problem. Bottom line, the only thing Statkey really made me an expert in was clicking "generate 1000 samples" and force closing my browser when it ran out of memory. The thing that makes even less sense to me is why a statistical programming language like R isn't used instead. The course actually introduces some problems in R in the first couple of weeks...but then you never hear about it again. That's not to say there aren't challenges to be overcome with using R as well, but at least your parameters don't get reset every single run. R doesn't go offline in the middle of timed assignments either. But in this class, you MUST use Statkey - there are problems that you will get wrong if you use any other method. As an aside, I took this together with Data Viz while working full time. I found that to be a very manageable combo - about an hour each weeknight and 3-6 hours total on the weekend.

Pros: 1. Very light workload and an easy A if you keep up 2. Programming assignments are straightforward and well supported by the TAs 3. Lots of extra credit and generous grading policies Cons: 1. Overall feels more like an undergrad survey than a graduate course 2. Later topics (navigation, SLAM, MDPs/POMDPs) are only treated on paper, not in code 3. Quizzes are a big chunk of the grade and the first one comes a bit out of left field Detailed Review: Overall, this was an easy course, probably too easy. There are four programming assignments: one in PDDL and three in Python. The PDDL assignment’s main challenge is just learning the syntax. Once you get past that, it’s very mechanical. The Python assignments cover BFS/A* search, minimax, and simple Bayesian belief updates. They’re all quite doable if you have any prior Python experience. TA support was solid and the discussion board was very active for such a large class. Assignments appears maybe ~6 weeks before they're due, with some overlap so you can work a little ahead but not much. That, combined with generous deadlines and lots of extra credit, keeps the time commitment low. It’s really not hard to get full credit on the assignments without putting in extraordinary effort. By the end of the semester I only needed about 50% on the last quiz to lock in an A. Content-wise, the course feels more like a gentle introduction than a true grad-level dive. The core programming work stops after things like search and belief updates; the more interesting later topics (robot navigation, SLAM, MDPs, POMDPs) are only handled in lecture and on quizzes, no chance to implement or experiment with those ideas, which is a missed opportunity if you’re hoping for something more applied. The quiz structure is a bit awkward: five quizzes that make up a large fraction of your grade. The first quiz is rough because it arrives with no real practice questions and feels a bit out of left field. On the upside, you can drop the lowest of the first three quiz grades, which effectively functions like a built-in makeup if you stumble early. Quiz 4 is very straightforward in style but covers twice as many topics as the other quizzes because of how the schedule is set up, so you’re tested on a lot of material at once. A practical tip: pay attention to the breadth vs. depth tags on the syllabus. They’re a good signal for how much detail you’re expected to know on each topic. Bottom line: this is a very easy, low-stress course with good TA support and simple assignments. It’s great if you need an easy A, a light pairing with a harder class, or a less time-consuming semester. But if you’re looking for a rigorous, project-heavy, graduate-level treatment of planning, search, and uncertainty (especially the later topics), you may want to skip this one and look for something more demanding like Reinforcement Learning.