Reviews

I know some students like Professor Witchel's teaching style but I am not a fan of sarcasm. I felt that the course videos could be better. Some videos were okay but I felt that the in-class videos were especially bad and that the order and flow was not great on edX. The material is not too difficult but can take time depending on programming background. Some assignments are long because it took time to learn the material but I think it was manageable. Piazza was more helpful with hints and assistance from other students. Assignments are usually posted on Monday/Tuesday and due Saturday or Sunday. It would be nice if we got them on the weekend instead since many students work during the week. I think the time to grade the assignments was too slow. It's the end of the semester and we still have 2 homeworks that have not been graded. The homework and flip classrooms come with starter code which was not good for the final project because we did not learn some topics like setting up projects, activities and gradle. I am not sure what makes this a graduate level course. It seems the same as the undergraduate version. The weighting of the final project is low so you can not work too hard on it and still make an A as long as you did well on the assignments.

As a former Math undergrad, I thought this was going to be easier than it was given my backround in LA, Stats, theory, and proofs. This course really needs a textbook to help guide the work. Liu's portion follows the book well (his book), but Klivan's section is all over the place. Klivan's seems to focus on novel approaches rather than just teaching to standard approaches. This, to me, greatly reduced the value of those lectures. As an example, the Decision Tree lecture was confusing, so I looked through a combination of 5-10 textbooks online and on campus (i'm in Austin), and his approach wasn't in any of them (!?). Futher, all the textbooks followed roughly the same introduction to Decision Trees. This held through much of the course materials, meaning that you'll be studing esoteric approaches rather than standard approaches. If you're already familiar with these topics, then this would be interesting, but I strongly caution against someone who has no familiarity with them.

I would start by saying that your background matters in terms of the pace of this course, especially in the beginning.I had never done any app style programming, so I found it took awhile to get used to the idea of having to coordinate layout with the actual logic. Android programming in Kotlin ends up being just a long procession of API calls, which is both a blessing and a curse. The text for the course is Kotlin and Android docs, which I found to sometimes be as obtuse as you can imagine, with relatively few examples and sparse explanation. You will google things....constantly. His demo code is good for "what" to do, but he didn't explain well why or how it was actually doing what he wanted. I would liken this course to more of an informal tutorial than what you would expect from a graduate course. As far as the professor, he's rude, condescending, elitist, and far too worried about being snarky and cool for my taste... personality differences aside, you will learn how to program apps in this class....sink or swim is the mantra.

Pros: 1. Very interesting subject matter 2. Learn a lot of content 3. Amazing lecture book Cons: 1. Lectures are from 2019 and don't relate to class anymore 2. TA support is terrible 3. Assignment revamp leads to this feeling like two entire classes Detailed Review: The class projects are based around an educational operating system. The punchline to my review is that they switched this class from being based on one such OS, Xv6, to another, Pintos, without any update to the course material. The class is now group-based, but they don't actually have that information in the syllabus, it was announced only on Ed-Stem. The lecture material that relates to the projects only relate to Xv6. The distribution of Pintos they gave us didn't have GDB set up properly, so they had to send us a new copy. Instructions on assignments are extremely vague. I get the impression that with Xv6, this class was challenging but doable, but now this was easily a 20+ hour a week course for me. As a side note, the textbook is amazing and available for free. It was not relevant to the projects, but I learned a lot from it. It is really a shame, because the subject matter is fascinating and I found that I learned a lot from it. I think this is still a class to take if you are interested in learning about operating systems, but be prepared for a stressful semester if you are also working full time.

Theory lectures are good, but majority of the grade comes from c based projects, where if you don't know the language, you're in for a bad time. No solutions are posted, and you're exptected to figure things out for yourself(very little programming done in lectures)

Agree with above - the material isn't terribly complex and the psets aren't that bad, it's just that the tests themselves are difficult (and feel disconnected to the material) and are 75% of the grade. I thought Algorithms was a better class (but more work), so if you have to choose the lesser of 2 evils I'd say pick Algorithms.

Takes a lot of extra research to figure out and do homeworks. Also the change in professors halfway changes homework and test styles, which can be quite jarring. Do not take this as your first class.

I found Klivan's part of the course really tough. You kind of jump right in to some hard stuff and I had a hard time keeping up. I liked the practical stuff but was kind of thrown off by the difficulty of some of the math. I would recommend taking/review linear algebra beforehand. Didn't really like this class.

I went into this course with high expectation but ended up being disappointed. In terms of content, I really like Reinforcement learning and the ideas behind it. I will break why this course didn't meet my expectations. Lectures: The entire course revolves around the Reinforcement textbook by Barto and Sutton. It's a very good textbook with detailed explanation of each topic. Every week you have to read one chapter. This is fine for the first 7-8 chapters, but after that, the content gets heavier and it requires much more time to understand. The lectures are extremely short compared to other classes and provide almost no explanation of the foundations of each chapter. They are helpful, but you have to look at them in terms of supplemental material. In my opinion, I really don't like this style of teaching. I think a good class contains good lectures explaining the basic concepts which students need to grasp, and the textbook can be used to go over the details. I believe this system comes from their in person teaching style where they ask students to read the chapter and then they'll go over any questions in class. But in online format, this method did not work well for me. After each chapter, I had many questions which were not clarified during the lectures even from the foundations. I think good lectures (such as David Silver's) would have avoided all of these issues. Every other course I've taken had lengthy lectures on foundation topics we need to learn, and I believe that's the way to go. The point of the lectures are to simplify large topics so learning can be optimized during the semester, otherwise I can read the textbook by myself at my own pace without the need of the class. Also simplifying large concepts would help to remember the foundation material. Homeworks: The homeworks were pretty standard. They got a bit harder after chapter 10, but even then they were mostly solvable and clear. You also have multiple attempts for most of the problems. There are also weekly reading responses which are simple. Programming assignments: The first two assignments were just following algorithms of the book, but later assignments became a bit harder as they require using Neural Network. I would suggest learning a Neural Net framework such at pytorch in order to make it easier. Overall, the assignments take some time to complete, but they are doable. Final: The final was a bit tough as it contained some harder questions than the homework. The average was in the 60s so that's a good indication of how hard the final was. One of the reasons for this is the 1-attempt no partial credit problems. Some problems required calculating or inputting numbers, and if you got the final answer wrong, you would end up with 0 points for that problem. The course was curved this semester pretty well. The cutoffs were reduced to improve grades, and as a result, I think grading was fair. Even if you get don't do great on the final, you can still end up with an A. Side note: this semester, the deadlines were pushed towards the end of the semester, so you could do assignments at your own pace and submit all before the end of the semester. I personally liked this as I didn't have to stress about finishing assignments on time, but it definitely requires some self-determination to not fall extremely behind. Overall, I really liked the material and think the homeworks were helpful to learn, but I wish the teaching style was better. It's not a bad class to take, but keep in mind that you can learn everything by yourself if read the textbook.

The course content is quite interesting but the concepts are a little difficult to understand at first (it gets really difficult after about chapter 8). The lectures were pretty much useless and I ended up reading each chapter 2-3 times to understand the concepts clearly. The programming assignments are doable but you'll have to learn everything required to complete them on your own because the lectures do not have any programming or practical component. The weekly homeworks have numerical questions that might be difficult to solve mainly because neither the lectures nor the textbook have solved examples. So you've got to clearly understand the algorithms and equations, and then figure out how to apply them to solve the given problems. The most annoying part of the course was the fact that every question on the homeworks, programming assignments and exam was such that you either get full points if you get the answer right or a zero otherwise. There is no partial credit whatsoever. I found the final to be quite difficult because many questions required a lot of manual calculations and even if you made a tiny mistake you end up losing all the points for that question due to the brutal all or nothing grading scheme. In the end the grades were not curved much and IIRC the cutoff for an A- was 88%. which is just 2% less than the usual 90%. In my opinion the grades should have been curved more to account for the unforgiving all or nothing grading policy and the incredibly time consuming questions on the final. I had very high expectations from this course but was let down by the quality of lectures and grading. The support on the discussion board Piazza was quite good though and one of the TA's was very helpful.