Reviews

Pros: 1. Interesting course - you'll learn a lot 2. Great instructor, even better TAs Cons: 1. Very difficult course Detailed Review: I am from the MSDS program with little programming experience, so keep that in mind for this review. This was a very interesting course, but almost overwhelming during my first semester. I had to brush up on my programming skills very quickly, and I lacked a lot of the math and algorithms background. I found that the lectures didn't help me too much with the assignments because they were at such a high level compared to the homework. I also felt like some of the lectures and assignments had slightly conflicting ideas because the lectures would tell you to approach a problem one way, and the homework would suggest something else. I relied heavily on office hours and wished they were structured a little better. Maybe it's changed since then, but I found myself sitting in office hours for hours on some days waiting for my turn for a TA to look at my code. I found that was very inefficient. I could have used Piazza, but I found it overwhelming sometimes because there were so many questions and queries. Every day. Maybe updated instructions for the homeworks or a better explanation of the starter code would have helped a lot decipher each assignment. Homework assignments 3 and 5 almost broke me. I think I cried just about every other week but still managed to pull an A.

Pros: 1. Broad and complete enough 2. Good refresher on math 3. Focused more on application than theory Cons: 1. Felt like 2 classes were compressed into one 2. Could have done with a little more focus on the details of building a simulation 3. Detailed Review: If you are fresh from an undergrad with a stat portion this might seem a bit easy, but it's been a few years since I've had to do calculus, formulate a mathematical proof or even read mathematical notation. Others have said it's like an undergrad course, but it's definitely more like a refresher, covering a lot of ground in probability in 5 or 6 weeks. I hear that later courses will assume familiarity with the math (and obviously the probability concepts) so I was glad of the reintroduction. I found the stats portion to be valuable - I've done some simulation before, but didn't quite recognize how powerful it could be. It could be compressed a little though, with maybe a little more depth given to the "how" of simulation, e.g. different methods of randomization, and there could probably have been a note on modelling multi-stage processes with monte carlo simulation (as simple as that might be). However, many in the class seemed to have trouble with this portion, so maybe it's not quite as straightforward as I thought it was. Overall, this is definitely the best class to start with. I thought there was a strong learning curve but looking back it seems much simpler than I found it at the time, which I think reflects well on the lecturers.

Pros: 1. The lectures align well with the course material and help to build on the more practical knowledge gained by doing the assignments. 2. The exams were very fair. You can use some notes, and the honor system was used instead of formal proctoring. 3. The projects are very reasonable workload-wise, and do help you to connect the major ideas of the material being covered. You can get an idea* of how you will be graded by running the grading scripts locally prior to submission (* does not cover all areas of grading, however; see Con 1A). Cons: 1. The course now has two curveballs that weren't present in prior iterations: A) Projects must be completed individually (no group collaboration), and B) The project grading now features "hidden test cases" - i.e. we'll grade you on some things we didn't ever tell you to code in the assignment details, but hope you did anyway. 2. Brush up on memory management in C or you will suffer during the first couple of projects, which require you to compile with the "-fsanitize=address" flag (meaning fairly innocuous memory warnings will instead throw errors and prevent your project from compiling, even if they wouldn't make much difference in the real world).

Pros: 1. Not too much work 2. Easy concepts 3. Cons: 1. Don't really "learn" much 2. 3. Detailed Review: I took this course because I needed 2 more classes to graduate, and I was kind off burned out and just wanted to finish the degree program. I took one more strenuous class along with this, and if you are in a similar boat and just need a class for an Easy A just to graduate without too much work, then this class is ideal. I think the lectures are decent and the TA was very involved, and he really explained how Machine Learning is used in the real world. The quizzes are rather easy, and the final project is a decent amount of work with a lot of writing, however, can be done if budgeting time well. If you are looking for a class where you learn a lot about Machine learning and want to challenge yourself, then this class isn't ideal. Even though you do learn a lot about applications of machine learning, you don't have to apply it much yourself and isn't really tested on the quiz, with only the final project being where it is applied.

One of the more difficult courses in the program, but if you know what you're getting into from the beginning, it's doable. Plan to attend Plaxton's pre-semester Zoom office hour, too. I suspect if you've had a solid undergraduate exposure to algorithms (ie: CS331 at UT), you'll likely find this course straightforward (a refresher of topics you've already seen and some new graduate-level topics). I needed to supplement the CS388G course lectures with MIT OCW content and Stanford (Roughgarden) lectures (from the respective undergraduate CS programs at MIT/Stanford). "Introduction to Algorithms" (aka "CLRS", MIT Press) is also an excellent reference/supplement. The third edition is widely-available used. Plaxton and Ramachandran have been teaching this course (and others) at UT for decades; I think they know a thing or two about teaching this core course at the graduate level. The exams and the problem sets are, to put it mildly, "challenging", but the course is curved for this reason. As with any UT MSCS course (including the on-campus versions), if you've limited exposure to the material, your success will hinge upon the level of TA support. For Spring 2023, we had some pretty incredible TA support (6-7 office hours per week across three TAs, detailed hint sessions). BRAVO ZULU to Jesse, Aditi and Ayush! TL;DR - Algorithms is essential as part of any MSCS program of work. You should definitely take this course, but make sure your family, employer, etc., are prepared for an intense semester.

Pros: 1. Absolutely outstanding professors that put an impressive amount of effort into engaging and communicating with students 2. Small workload for working professionals 3. Gentle introduction to the degree for people without strong probability and statistics backgrounds Cons: 1. The course has an undergraduate scope of content 2. No programming required 3. Detailed Review: My undergraduate background is in mathematics and statistics. I'm enrolled in Probability and Machine Learning while working full time. People with strong stats and math background will find this course very simple. This course seems like it was geared more towards getting people who have been out of school back into academia rather than building onto the pre-requisite knowledge of probability and statistics. The flip side of this means students without stats backgrounds will be gently introduced into the MSDS program. Students are encouraged to use programming environments explore different ways of tackling problems outside of the methods discussed in the lectures. With that said, no programming is actually required for the course. Students can explore solutions or simulations using Python, R, or whatever they feel comfortable with. Sometimes the professors will hand out snippets of R code for student use. They expect students to use a free web applet called StatKey to answer simulation-related questions. Lectures are accompanied with PDF uploads of the presented slides as well as any supplemental information. People with strong math and stats backgrounds can skip the lectures or reading the textbook altogether - really. The course consists of bi-weekly quizzes, two midterms, and weekly homework assignments. The quizzes and midterms are typically closely related with homework assignments. No curve-balls as far as testing content is concerned. All of this content is graded in EdX multiple-choice style questions. This means grades are all-or-nothing for each question, so be sure you check you entered the correct response before moving on to the next question. The dedication both professors have to communicating with students is outstanding. Both professors will respond very quickly to any question or concern in private e-mails or the Piazza discussion board. The Piazza discussion board is very active with thoughtful discussions and guidance between students and professors. I really cannot overstate just how strongly these two professors wish for their students to succeed. Dr. Mueller put the same emphasis on his students in his undergraduate courses, and it's so nice to see this has extended to an online program. These academics truly want their students to excel. I didn't use the textbook or attend office hours, so I'm not personally capable of commenting on their usefulness in the course. The time requirement for this course is going to be heavily dependent on your background. Those with statistics backgrounds could easily spend an hour or less a week to work on assignments or quizzes, but 10 hours does sound like a reasonable workload for those using this course as a refresher. The gentle introduction this course provides makes it an obvious first-choice for students new to the program that wish to slowly roll into the rest of the program. Students that are well versed in the topics may want to wait to pair this with more difficult or time consuming classes. Chances are you won't learn anything new in this class if you've taken undergraduate statistics classes.

Pros: 1. Lectures are interesting and entertaining 2. Your python programming skills will definitely improve 3. Projects were fun and thought provoking Cons: 1. Quizes: They are only moderately related to the lectures 2. It is not possible to learn from mistakes as grading does not allow students to see what they did wrong 3. Detailed Review: The class is heavily based in python programming. The first week has a good intro lecture, but then little (no) programming is taught afterwards. I was able to pick up python without previous experience (but many years of Matlab experience) by reading about different functions online. With no programming background, this course would be very difficult. I enjoyed the projects, but they did vary significantly in the amount of time that they took, so workload will differ from week to week. The worst part about the course is that it is not easy to learn from mistakes as solutions to the quizzes are not provided and similarly, failed test cases for the projects are not known.

Pros: 1. Very responsive professors 2. Good coursework material with content that allows for collaboration and discussion in addition to the HW/quizzes/exams 3. Reasonable refresher/introduction back to probability and statistics Cons: 1. Could be too easy for those with experience in the subject already 2. First semester had issues with typos (but the professors addressed issues quickly) 3. Detailed Review: A quick rundown / refresher on probability and statistics. Those who had a firm grasp of the subjects from undergraduates will find this course easy. For those who have been working for a few years and may be a bit rusty in math, it would be good to brush up on some basic calculus either before or during. There is flexibility in what programming language you choose to use (none of the HW required turning in code, just interpreting results). For those who are working full time and want a non-stressful start going back to school, this is a good starting class. For those who are trying to graduate as fast as possible and have solid foundations in math already, this is a class that could be taken in addition to another course. Workload estimate is from perspective of someone who has been out of school for a few years, but comes from an undergraduate engineering background.

Pros: 1. Great lectures 2. Excellent instructor/TA support 3. Generous grading rubric Cons: 1. Peer grading is tedious 2. Mandatory participation = Piazza spam 3. Detailed Review: This class is easy and only requires a few hours of work per week, but I still felt like I learned a lot. Dr. Wilke and the TAs are especially great. They're more engaged than most in-person instructors I've had, even though they're dealing with the spam-fest that is this class's Piazza. The lectures are really well done too - they follow a pattern of first explaining all the concepts and then showing how to code it in R. It's an effective formula that also does a great job of reinforcing learning over the course of the semester. Even though this course is straightforward, there are some students who have trouble with it. The code is really the easy part - what seems to cause problems for people is following instructions and interpreting the results of their work. Do you want to use a package that isn't on the course list? Don't. Are you thinking of making 11 figures when the assignment says 2? Don't. Can you explain your main takeaway? Can you connect your figures to that point? And can you do it all in 2 paragraphs or less? If not, you aren't effectively communicating results. There is certainly coding in this class, but even more than graphs and tables, it's about communication. Putting that all together, rather than finding optimal colors and shapes for your charts, is really the objective of this course. You'll get more out of it if you go in with that mindset.

Pros: 1. Projects force you to become a better programmer 2. Lectures are good quality 3. TA's were great Cons: 1. Grading structure is opaque 2. Some of the quiz questions are poorly worded 3. Projects are time consuming Detailed Review: Lectures - The lectures are all of Professor Lin writing notes on a chalkboard with a student sitting nearby and they frequently have discussion back and forth. Overall I thought it was a nice format and did a good job mimicking the natural flow of an in person lecture. The only negative is that there were no course notes available. Some students posted their personal notes on piazza, but they weren't always 100% accurate or were missing some content. I took notes when time and life allowed me to, which isn't often. I typically would search online for some decent notes from other courses prior to taking the quizzes. Quiz - The quizzes were tough. For the most part they didn't contain any programming and were all about the theory covered in lecture. Some of the questions were poorly worded and made them even more difficult than necessary. This resulted with the average on most quizzes being quite low. Granted, the teaching staff did a pretty good job giving credit back if students made a good case on Piazza explaining their thought process on poorly worded questions and how it caused confusion. Projects - The programming assignments were not trivial. The first two are not too bad, then it quickly ramps up past the third assignment. One very contentious aspect of the assignments was to not provide students with the test code. The point was to have us learn how to think and develop our own test cases. Coming from a non professional programming / non CS background, I thought this was a good concept to learn. You were however pretty much left to your own devices on learning how use a test suite and develop your own tests. If you developed good test cases and could verify the correctness of your code, you generally received a pretty good grade. On most of the assignments the autograder had some test cases that were pretty much impossible to anticipate, many often dealing with speed requirements. After the first two assignments they released partial test code to help get started. Some students didn't understand it was a partial autograder, and that it didn't provide full test coverage. So there were a fair amount of Piazza post of students saying they received a poor grade even though their code passed the partial autograder case. So fair warning, if in doubt just write your own test suite and use the provided one as an added bonus. They also let us work in groups for assignments 3-5. Even if you are pretty comfortable writing your own code, utilize the groups for at least swapping test cases. My team members helped me catch some edge cases I missed as I did likewise for them. TAs - Overall I thought the TA's were amazing. They had plenty of office hours throughout the week and were very active on Piazza in both the public and private posts. At the end of office hours they allowed you to get into a break out room if you wanted to look over some code with them one-on-one. Prerequisites - In terms of what material to know prior to taking this course, I think understanding programming up to some basic level of OOP in python is pretty much required. The professor expected students to have one year of high school AP computer science or one semester of college introductory programming. It is also a good idea to learn how to use write test cases and use a debugger prior to taking this course, since they are essential but not a lot of time is spent teaching you how to use them. Also make sure you understand how to use the basic data structures in python such as list, dictionaries, sets, tuples, and strings as you will need to very fluent applying these in the projects. Grading - This is perhaps the most frustrating aspect of the course. We were told not all the programming assignments were going to be weighed equally, but that the final weights are TBD. So trying to gauge how much an assignment actually affects your grade is quite difficult. Then when you get something wrong on the autograder, the error message is often quite cryptic so its a hit or miss if you can figure anything out from it. Hopefully they will find a way to make the errors returned by the autograder more useful in the coming semesters. The autograder also took quite awhile to run on some of the assignments, which resulted in very long delays before getting a grade back. Hopefully this will also get fixed in the future. This is a very ambitious course. The professor's goal are to make you better at programming, learn fundamental data structures and algorithms, and learn to think critically. This is a lot to squeeze in a semester, so be prepared to spend a lot of time on this course if you are unfamiliar with any of these, if not all of them. Overall I am glad I took the course and learned a lot from it.