Course Details

Pros: 1. Mathematically challenging course that requires thorough thinking (much harder than typical LeetCode questions) 2. No midterm or final exams, just weekly quizzes 3. Lenient quiz grading where minor mistakes were typically ignored 4. Most students received A or A- Cons: 1. Extremely slow quiz grading with insufficient TA resources (only two TAs for ~80 students) 2. Quizzes were significantly harder than the provided sample quizzes 3. The 48-hour quiz window (Friday noon to Sunday noon) was restrictive considering that TAs did not start grading until much later Detailed Review: This course was structured around 12 weekly quizzes with no midterm or final exam. While there was no required textbook, three were recommended: Intro to Algorithms (CLRS), Algorithm Design by Kleinberg and Tardos, and Algorithms by Erickson. The lectures were generally clear, though occasionally the professor would thoroughly explain simple concepts while rushing through more complex topics. A few video recordings had issues (missing from Panopto or overlapping versions) that were never fixed throughout the semester. The course workload was very high, making it the most difficult elective I've taken in the program. Each week has solved exercises to help understand the material, though these were actually much harder than the quiz questions themselves. The biggest issue was the grading. With only two TAs (each limited to work 15 hours per week) for about 80 students, quiz grading was extremely slow. The professor has a script to project final scores after dropping the two (prorated) lowest quizzes, but this wasn't run until 9 quizzes had been graded (at which point 11 had already been taken), reducing its value for students trying to assess their standing. The graded quizzes this semester seemed to be much harder than the sample quizzes from the previous run. I suspect the professor may have been trying to counter potential LLM usage, but this might have inadvertently pushed more desperate students toward using such help. A better approach might include a mix of easy/medium (more points) and challenging (less points) questions. The final grade distribution was: * A (90+, ~47%) * A- (80-89, ~35%) * B+ (70-79, ~8%) * B (60-69, ~9%) * D (<30, 1 student) I would recommend this course if you enjoy mathematical challenges, but not if you're primarily hoping to improve your LeetCode skills. Be cautious about taking this alongside other demanding courses, as the workload can be difficult to manage.

Pros: 1. Heard the course was revamped. They do give you all of the homework solutions. If they made you figure those out on your own before... holy would this class be ridiculous. 2. Lectures were surprising all that were needed most of the time for most of the quizzes 3. Lecture material and subject is an entirely different matter, but the professors did explain things well. I don't think I ever had any trouble understanding or following their logic. Cons: 1. Was hoping it would make me better at Leetcode. Honestly doubt it, but I think the stuff they do cover is probably harder than any Leetcode hard you would see, so it probably makes understanding harder algorithms concepts easier 2. Every single week you have a quiz. And only a 48 hour window to take it from Friday noon to Sunday noon. Very annoying since of course I am studying over the weekend, and then waking up early on a Sunday to take the quiz in time. Wish they would make a better window. 3. Some quiz questions there's no way people figure it out in the small window. I really hate the quiz format since I think it just encourages everyone to use LLMs to take the quiz (I did not do this at all, and you are required to affirm you do not use any external resources). I'm probably just dumb tbh, but seeing the quiz averages and distributions really made me think most people were using LLMs. 4. Grading was awful for this class. TAs took forever to grade quizzes so you really never knew your standing in the class. At some point there was even like 5 quizzes you still did not have have a grade on. Detailed Review: Textbook is relevant, but you can just rely on the lectures and the provided homework answers, so skip reading it. Entire grade is just based on the grades of your quizzes. They do drop your two lowest grades. And quiz answers are proofs so lots of writing. I pretty much covered everything above, not much else to say. Was hoping to gain more Leetcode related stuff from the class, but we did not write a single line of code. Favorite thing I learned though was P and NP, that always sounded so mysterious but it makes a lot of sense now. Rated Piazza support lower because grading frequency sucked but they did have recorded office hours which was a huge plus (if you were interested in them, I personally did not listen to them). Took this class with Operating Systems, and that was... quite painful at times. I think this class actually is fine to take with another class if you're trying to finish the program ASAP. Mainly because the workload is very consistent, there's no project or final exams to worry about. You get into a pretty consistent routine with watching lectures, studying, and taking the quiz each week.

Pros: 1. Pretty good coverage on advanced algorithm topics 2. Challenging problem sets (homework) 3. Good TA support Cons: 1. Needs improvement on helping student to better understand the content 2. Very difficult exams 3. Time dedication alert - easily 30+ hours/week for some Detailed Review: This is arguably the most difficult class in this MSCS program, and I'd agree. It has never been easy for graduate level algorithms class, so even if I kind of expected that in the beginning, I still feel underestimated it. I usually spend 30-40 hours per week watching lectures, understanding concepts, reading books, and doing problem sets, but yet still don't feel very confident throughout the semester. The topics themselves are actually interesting. But the problem is that I don't think professors presented them in a way that makes it slightly easier for students to digest the content. There are a lot of dry proofs that students have to exactly follow, or otherwise it is easy to get lost. The class could have been more fun. Although no textbook is required for this class, most of the content follows the classic CLRS and Algorithms (by Jeff Erickson). Besides those, I have to search for online resources to better digest the content. Good thing is these topics are wildly discussed so I believe you could find a great number of supplementary materials to help you get through. I put challenging homework as pros because I do feel it valuable to dig into those problems, which helps me understand these topics. On the other hand, some of them are really challenging and painful - some questions themselves are even difficult to understand, and the suggested solutions sometimes are unnecessarily convoluted. Problem sets grading are done by peers, and it is not rare you get ridiculously harsh grades from frustrated students. When it comes to the exams, they are very difficult. Given three hours, students need to answer 9-10 questions. Score shows the top 25% get about 70%-80% of the points and the median get about 60%. The exams did post a lot of pressure. Good news is that the curve in the end is kind of generous - getting 80 will guarantee an A range (A or A-) and for Spring 2023, the A- cutoff is 77 and B- cutoff is 60. Walking out of the class, I do feel that I have much better understanding in some of Leetcode's medium to hard questions. I'd recommend the class to people who want to focus on software engineering direction, after all, algorithms are something we can't skip, but prepare for some level of sacrifice of life and/or work. Also, you have to be self-motivated, and in return it will be quite valuable for your career.

Pros: 1. TAs made the class bearable 2. Great way to learn Latex 3. Cons: 1. The class progresses at a break-neck speed 2. Topics in the first half feel disconnected 3. Lectures and slides are difficult to follow Detailed Review: First half: - It is apparent from the beginning of this class that it is not for the faint of heart and that it will be a massive time commitment. - The lecture notes for the first half of the class are dense PowerPoint slides that the professor scribbles examples on during lectures. You should be prepared to scribble on the provided slides as well. - The homework’s often feel very disconnected from the lecture material and do not serve as a good tool for learning the content. Rather, they are cumbersome, stress-inducing grinds that don’t reinforce the concepts at all. The homeworks differ from the lectures so much that they provide 6 questions and only ask you to do 4. There are also dedicated hint sessions for each problem to put you in the right track. Good luck completing the assignments without the hint sessions. Overall the assignments feel needlessly difficult and didn’t help the material stick at all (for me at least). - The instruction quality is average, but fails to provide examples and rarely explains how topics are connected to one another and rarely makes any connection about practical application of the material (I know it’s a theory course, but surely the content is used in practice somewhere right?!) Second half: - the second half of the course was markedly better than the first in my opinion. - the homework questions were much more relevant to the lectures. There was generally one question per lecture, and there were no hint sessions. The lack of hint sessions was a good thing, to be clear. The homework problems were much more manageable and often had multiple parts that built off of each other. They were great for actually learning the material. - the lecture notes were PowerPoint slides again, and the professor for the second half also scribbled all over them. It would have been great if clean figures had been included in the slides instead of the scribbles. - the instruction quality was above average in the second part of the course. The relationship between topics was often more clear, and real world examples were evident in the material. Overall, very difficult course that was a constant source of stress and frustration instead of enjoyable learning. I would not recommend it to a friend, nor would I wish it upon my worst enemy.

Pros: 1. Broad range of topics covered so odds are you'll find something interesting/useful 2. Other courses will feel easier in comparison :) Cons: 1.Too much content. Topics don't always naturally build off previous weeks, so just a lot of separate ideas to learn. In general too much material presented to gain a solid understanding in any topic. 2. Problem sets are very time consuming. There's only 6 throughout the semester, and the TAs were generous in providing hints/tips to get started, but each one took 20+ hours to complete. 3. Tests are very difficult. I would be amazed to hear someone was able to get an answer for all the questions within the 3 hour limit. Detailed Review: Mathematical maturity is assumed for this class. You definitely need at least experience with algorithms and proof techniques. I have more background in this area than the average CS student or software developer and still had difficulty in this class. I will say I still think there's a good amount of important and interesting content here, just know what you're getting into. The TAs for our semester were very helpful. Course could have been even harder without their help. The course is generously curved, I do feel like the instructors are aware of the difficulty of the material and will curve the class to adjust for this.

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. TAs were awesome 2. Professors were ok, but hey, there's a curve 3. Explore theoretical cs : ) Cons: 1. Explore theoretical cs : ) 2. Problem Sets were time consuming 3. Exams were...hard Detailed Review: Yeah so like the title says, I only took this course because it's the only one I had not completed offered. I am almost done with this program and here we are. The review before mine was pretty spot on. I never really felt like I had a total grasp of the course material or comfortable with the course pace like I did other courses. If you are not comfortable with proofs and later, probability, stay away, or at least refresh yourself before. The course covers a broad range of topics, but the exams require what seems like extreme depth of these topics. I'm not kidding here either, the professors have zero problem giving PhD level questions in problem sets (from a TA)—this is a good and a bad thing I suppose. All of the TAs were awesome and gave more than generous help in their office hours, shout out to them for dealing with all the student gripes and complaints about the material. Overall, I thought the course material was interesting, but think it could probably be focused more on fewer topics.

Pros: 1. Pretty good TA support 2. Could *maybe* make you a better programmer 3. Increased my pain tolerance for future courses in the program Cons: 1. Massive workload, both in amount of lecture content and problem sets 2. Teaching style is very hard to follow, overly theoretical 3. Extremely difficult exams Detailed Review: This class was more painful than I could imagine. This is my sixth course in the program, and typically the arc of a course for me is the first few weeks are pretty tough, but then things start to click and the remainder of the course feels manageable and generally enjoy it. That never happened here. Things didn't really click, and what resulted was 12 weeks of suffering. There are a few problems with this course. First, there is more lecture material than any other course I've taken. I'd say on average there's 3 hours of very, very dense material to watch. The material is *highly* theoretical, so think many proofs, lemmas, etc. This is a theory class, so know before you start that there is 0 coding and a pretty high expectation for mathematical maturity. This is fine though, it's okay to teach a highly theoretical class (though I imagine the average student in this program is more interested in practical classes). The problem is that each week you'll jump to an entirely new topic, so you never really have time to truly understand the material deeply. What resulted was surface level knowledge of an array of seemingly related topics. I'd also argue that the content was ordered all wrong - for example they introduce basic graph algorithms after more advanced graph topics, which made no sense to me. The problem sets, 6 in total, take a very long time to complete and expect a deep level of understanding of the material. Because of my general lack of understanding, it would take me hours to just figure out what the problem was asking. This is the only course where I had to watch pretty much every recorded office hour session where they gave "hints" or "clarifications" (which were usually indecipherable, cryptic suggestions for how the answer key wants to you solve a problem) for the problem sets. Each problem set would take me probably 20 hours or so, and I never felt confident in the answers I gave. That said, it didn't really matter, because many peer graders would just give me high marks because they either didn't want to spend the time properly grading or because they felt bad that we all were suffering so much. By problem set 4 or so I found that there wasn't a direct relationship between time spent and my grade, so I relaxed a bit on the last two. The answer keys for the problem sets were immense walls of text - each time I was like how could anyone get this right? The exams were insanely hard as well. You have 3 hours to complete way more problems than was possible. Luckily the grading was pretty lenient, so even though I left large chunks of the first exam blank I still managed to beat the median. In short, this class was rough - rougher than any other course I've taken by orders of magnitude. I wanted to drop many times for the sake of my mental health and just enjoying life, but I always concluded that I'd come too far and I knew that as long as I completed the assignments with something passable then I'd get a decent grade. Do I think I'm a better programmer having taken this? Probably not. But the silver lining is that I know now that the last 4 courses I take will feel like a cakewalk by comparison.

Pros: 1. Exposure to technical algorithmic analysis 2. Practice using difficult mathematical proving techniques 3. Some of the TAs are very helpful Cons: 1. Unintuitive lectures that are disjoint from problem sets 2. Mathematically rigorous theoretical homework 3. Highly theoretical Detailed Review: I'm currently halfway through the semester and will update this review accordingly with a breakdown of grades and perspective on the final exams. This is by far one of the most difficult courses I've taken in this program. Like mentioned in Cons, the lectures are essentially uncorrelated with the problems sets. While there may be some theoretical overlap, it won't help you complete the homework at all. I should mention the bi-weekly problem sets are almost entirely proof based. If you're not a fantastic mathematician (think Google research intern), you're probably going to have a very rough time on the problem sets. Office hours are required but thankfully recorded. For reference: I've completed the entire calculus series in undergrad and have dabbled in linear algebra. There are some reviews here that insinuate that the course has been "fixed". I would argue the contrary. Additionally, another review argued that this class "makes you a better programmer despite not having any coding exercises". I would argue against that as well. I have industry experience in software engineering and while some of the theoretical concepts may have applications in research and other parts of the SDE industry, this will class does very very little to make you a better programmer. If I knew what I knew now, I would have most definitely have chosen to take another course. Good luck.

Pros: 1. 2. 3. Cons: 1. 2. 3. Detailed Review:

I concur with the review entitled "Algos Spring 2022". But I had no previous experience in a course that required writing proofs and submitting problem sets typeset in LaTeX, so I had to work a little bit harder than others. That said, I found the course extremely worthwhile, and was definitely satisfied when I completed it. Also, because attrition in the course was quite high, I recommend that you do not take another course with this one if you work full time. But if you think you can give 20 hours per week (or a few less if you've taken a serious undergraduate algorithms course previously), I think that the course experience will be worthwhile and rewarding. Finally, I used the course text (CLRS, "Algorithms") a great deal and found it to be much more useful than recommended texts for other courses.

This course was mostly the same material you would see in an undergrad level Algos course with some more advanced topics and a little more in depth on certain proofs or complex data structures. The problem sets were similar problem difficulty to an undergrad Algos class, but maybe with a little more critical thinking involved. For me this was the part that made it time consuming. If you like sitting there with a whiteboard and figuring out edge cases and small sample algo problems trying to break your methodology then this is a great course for that. It also reinforces some of the problem solving techniques you might see in coding interviews at the beginning of the course. The later part of the course is a little beyond what you would typically see in a coding interview.

I took this course along with OLO. I liked this more and was able to understand the concepts better. That said, the assignments are very difficult and can feel unnecessarily complicated.

Pros: 1. You will learn a lot. Course spans a range of material, from introductory concepts to advanced. 2. Indispensable skillset that will help you in coding interviews, and as a CS professional more generally. 3. Very reasonable workload, and straightforward exams. 4. Great TA support, including hints for coursework. Cons: 1. You might need to supplement lectures with external sources. Detailed Review: I suggest you take this course. Bottom line is that it makes you a better problem solver/programmer despite not having any coding exercises. I think the past negative reviews are outdated now, the course has most likely been revamped as what they report didn't match my experience at all. For the homeworks you will need to put in more than minimal effort (obviously) and stretch the brain for a few hours each time, but the TAs are there to help with tricky homework parts and comprehension questions. This is inevitable as it is through this process that you become better at Algorithms. The exams were straightforward applications of material covered in class, basically simpler homework exercises which could be solved pretty quickly. The only con imho is that neither lecturer uses examples as a teaching medium. In most cases this is OK but if I hadn't watched a real execution of e.g. the Push Relabel Max Flow algorithm, I wouldn't have grasped the intuition and how it works just from the pseudocode. This is no big deal however, as there is plenty such material online. The two recommended textbooks are both battle-tested and I recommend them as well.

Pros: 1. Lectures in the first part are of high quality and combine a bit of introduction into key cocepts plus deep dive. 2. Scores for the class were quite high overall. Cons: 1. If you aren't familiar with Latex or have forgotten how to do formal proof, the first couple of homeworks take 20+ hours. This drastically gets better later on. 2. It's completely theory (no programming) so if that isn't your cup of tea, it can be quite monotoneous. 3. The second part is "very theoretical" Detailed Review:

I don't think the instructors did well explaining the concepts. We had to check lectures from Internet to fully understnad it. Homeworks are hard, usually takes me 20 plus hours and still did not get them right. Peer grading is just a terrible idea. People give lower grade them deserved.

Probably one of the worst classes I have taken. The topics are fine but no real cohesion from one week to the next; it feels like a bunch of jumbled important topics that are connected if you look deep enough on your own but are not presented that way. I found the lectures to have so little utility that I ended up learning everything from outside sources (textbooks: CLRS, Kleinberg & Tardos; lectures: tim roughgarden (http://timroughgarden.org/w16/w16.html), Jelani Nelson (http://people.seas.harvard.edu/~cs224/fall14/index.html), and Erik Demaine (https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/ and https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-046j-design-and-analysis-of-algorithms-spring-2015/index.htm). The homework problems can be difficult to understand and going to TA office hours is practically a must. This course also had peer grading for homeworks (typically you grade 3 peers) and it was not uncommon to see scores from different peers differ by over 30% of the total assignment value. Most times the instructors took a simple average of the scores your peers gave you. Tests felt to be largely an exercise in having the right information written down on your 1 allowed notesheet, but with test questions being so different from problem set questions it can be difficult to determine what is the right information to write down. Also, some lectures would wind up on a test before they were in a problem set then show up on the problem set after the test. I would say avoid this class if you can, but with only 10 classes that's not possible; I would say save this for an otherwise easy semester. EDIT: here is the letter grade breakdown: A: 88 to 100 (20) A-: 80 to 86 (26) B+: 76 to 79 (11) B: 67 to 74 (10) B-: 61 to 64 (5) C+: 52 to 53 (2)

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.

The first half was crazy hard. The lectures weren't really related to the assignments. Sometimes optional videos were required to complete the homework. The second half was much more reasonable. Still hard but I could relate the lectures to the homework.

More work load with busy schedules and more number of problem sets and tests.

High workload. The homework, especially for the first half are very hard, Strongly suggest attending TA's office hours. Good idea to supplement knowledge by watching lecture videos from other algorithms classes (i.e. MIT open courseware and Tim Roughgarden's lectures). Also manage time well, as soon as you finish a homework or a test, you need to start preparing for the next stage.

There was probably around 20% more material covered in the lectures compared to other courses I took this semester. A very theory-heavy course. Some background in algorithms is recommended but not required. First semester homeworks are difficult. Second semester homeworks get slightly better, but not by much. TA office hours will help for homework and conceptual understanding if you are able to attend them.

No detailed text provided.