Course Details

Pros: 1. Great lectures. 2. Good content. 3. Presumably generous curve, and opportunity for "Karma points" which presumably can bump your grade a bit to the next letter if you're borderline. Cons: 1. Assignments are way more complicated than examples in the lectures. Presumably there's a generous curve, but a score of ~86% with TONS of Karma work still yielded a B+ (pretty much as if little to no curve had been applied). Maybe their curving scheme benefits lower scores more disproportionately; not sure as the strategy was not disclosed. 2. The "hidden tests" are largely useless because you have no feedback as to what the tests are testing for and why they might be failing; even if you perform dozens or even hundreds of other tests to ensure your data structures are correct and your algorithms are efficient, you can still miss points because of some arbitrary "hidden test" they chose to base the grade on. This is not very conducive to learning, compared to letting you know what test is failing, and leave it to you to figure out why and how to fix it. 3. It's terrible that quizzes have a hard deadline and can't be retaken or taken late; some people travel actively for work and internet connections are not always reliable. Detailed Review: Pretty good course; better than Probability & Inference (the only other one I've taken), but definitely more challenging.

Pros: 1. Well-designed programming projects featuring either games or data structures. Could be even more fun to revisit them after the pressure of the course is over. 2. Generous late project policy with six "slip days" .(Note that this does not apply to quizzes) 3. Professor knows his stuff and lectures are old-school (blackboard) but interactive with an assistant or TA as "student" .(somewhat a refreshing sight and deparature from profs purely reading powerpoints and making you sleep) 4. Professor has a sense of humour during lectures. Cons: 1. Somewhat lack of transparency in grading. For example, lots of hidden test cases which may or may not be related to the published sample tests (will be a greater issue in later projects). 2. You won't really know your performance/grade until the end of the semester. Also, if your cohort performs differently than other recent semesters' cohorts, the grade cut-offs or curves can turn out differently than expected (e.g. in Spring 2025, the cut-offs for B and B- are way higher than 3 previous semesters). 3. Information overload during certain lectures. Also, many lectures won't really directly prepare you for the projects. 4. Some students may feel intimidated with the class atmosphere, including with respect to the professor, e.g. very low involvement in Ed Discussion forum, Somewhat overemphasis on "no whining" (even spelled out in the syllabus), etc. Detailed Review: This class was supposed to be UT MSDS's introduction to programming and toned down compared to MS CS's "Algorithms: Techniques and Theory". But its scope is still quite ambitious. First, it's supposed to teach data structures (lists, stacks, queues, trees, graphs, etc). Next, it attempts to teach programming fundamentals including writing your own test cases and debugging. Lastly, it aims to teach problem solving skills. Greater emphasis is on application instead of just knowing the topics. In practice, the learning curve in this class still quite varies (Even the professor acknowledges that and admits in the syllabus that some people will spend 3-5 hours only on an assignment, while some will need to spend 20-30 hours). Complete beginners will find it very difficult, while those with good programming background will find it very easy. Actually, once you identify and get the specific needed skills/topics and have a good working outline, the projects will be easier to deal with. In fact, especially for the first two projects, to save time, I recommend drafting/DOING THE PROJECTS IMMEDIATELY once they are released. You can even do them before finishing the lectures if you know what you're supposed to know and do. (But for the quizzes, don't ignore the lectures) First, note that the course and program prerequisite generally includes knowledge of basic Python programming. Prior to entering this class, you're supposed to master functions and dictionaries already. Even better, know basic OOP (you may wish to enroll in other online related courses if you want). Focus on these topics for the projects: Projects 1 and 2: Basic python syntax, functions and dictionaries (Dictionaries especially for the second one) Projects 3 onwards: Recursion and iteration. Also DFS and tries for project 3. Projects 4-5: Binary search trees, heaps, B-trees, and related operations Project 6: Graphs, BFS, DFS, Djikstra's Algorithm. But for the quizzes, you'll also be needing the other lectures so do try to finish them (and read up in other sources as needed). Do note that the main textbook is in Java. Part of the reason with this is that the professor wants to emphasize programming and problem solving aspects that stay constant even as software, hardware, etc. evolve from time to time. The syllabus also provides two supplementary references to look for (you may look for others too). Overall, the class is introductory level but can also serve as a filtering subject of who has the necessary programming background.

Pros: 1. Classes are interesting, well paced. 2. Teacher Assistants are really approachable and eager to help you. 3. You can learn Python if you have not used it before 4. There is testing help for the assignments. Cons: 1. Challenging for non-coders. 2. Some questions in the quizzes have more than one correct answer and you may not get the points. 3. Detailed Review: I did like the way the professor taught using the chalkboard (old school), with one assistant also helping with the class to be dynamic. Projects were challenging for new coders. I spent more hours than expected to get a working code.

Pros: 1. The TA's have been great on ED discussions. 2. Introduced fundamentals of good programming, with a lot of enfasis on testing and debugging. 3. Covered the must know algorithms and data structures. Cons: 1. The lectures are based on a chack board, not aways very organized/easy to read Detailed Review: Overall it is a great course. Very well run. Covers the basics really well. Brought me to a whole new level of proficiency/confidence in programming (I had some experience programming, but I do not have a CS background). Some projects could realistically need +20 hours of work if you are not that experienced with programming. Totally worth it. If you have a CS background, you will spend a lot less time on this course, and then it could be advisable to pair it with another. If you can, take it soon into the program, provided you have the time to dedicate. It will impact all the other courses that require an extra dose of programming skills.

Pros: 1. Prof. Lin is an engaging and thoughtful lecturer 2. Will improve your programming (and testing/debugging) skills 3. Cons: 1. Class schedule was a little uneven in terms of time between project and quiz due dates 2. 3. Detailed Review: Although it was a lot of work, I really enjoyed this course. Prof. Lin is an engaging lecturer who’s clearly put a lot of thought into how he presents the material, and I learned a lot from the lectures and projects. I thought having a student as an interlocutor was particularly effective for the online format. Lin’s teaching style (describing things in more plain terms, working through proofs and algorithms step by step on the chalkboard, and having a dialogue with the student) was a lot more helpful than reading off powerpoint slides. In terms of my background, I took a couple of introductory computer science courses in undergrad and did a lot of R and Python programming for a job in academic research. I still wasn’t sure how I would fare in this class, given previous reviews. Overall, I thought the course was time consuming but manageable, with the caveat that the learning curve is steep for those who aren’t familiar with object-oriented programming. I felt the projects were manageable and fun, and my programming skills improved immensely, especially when it comes to debugging and designing test cases. The quizzes were tough and required a lot of out of the box thinking, but I felt they were mostly fair (I’m sure many will disagree). I thought watching the lectures a couple of times and referencing the textbook (mostly for big picture information because it's written in Java) was sufficient enough to do well on the quizzes. The test cases for projects aren’t always the most descriptive, so you’ll have to go to office hours to get details. It’s not a good setup for learning from your mistakes, but I also get that the staff doesn’t want the test cases to be public information. The syllabus mentioned that there would be a generous curve, but I wasn’t sure how generous because the class averages were fairly high after the first few assignments. However, the course ramps up in difficulty fairly quickly. I put in a lot more time thinking the cutoffs would be higher this semester, but the curve ended up being similar to past semesters. Logistically, I think the class was mostly managed and organized well. The TA’s were somewhat active on the Ed discussion board and held regular office hours, making extra time before project deadlines. They could be cagey answering some questions, but were otherwise usually pretty responsive when it came to more urgent matters like grading. There were a couple of students in particular who were also really active and helpful. The only thing that threw me off a bit was that the staff didn’t seem to observe the spring break (mid-March), as they released lecture videos that week and had a quiz due the Sunday immediately after.

Pros: 1. Interesting programming assignments 2. Lecture format works well 3. Curved grading Cons: 1. Graded test cases are not provided 2. Quiz questions were difficult 3. Awkward difficulty depending on experience Detailed Review: Class workload is highly dependent on your previous experience with programming. I saw classmates that were struggling from the very beginning of the course and others that were breezing through the assignments. This made it feel like the difficulty was awkward, and certainly not what I expected from a graduate course. Too easy to be a grad-level data structures class, but too difficult for new programmers. That being said, some of the programming assignments were genuinely interesting and engaging. They were good applications of the lecture material. Some base test cases are provided to you in the starter code, but a big part of the assignment is creating your own test cases. The graded test cases were never provided as far as I know, which meant I didn't really know what went wrong with my code. The lectures have conversational segments, where a TA answers and asks Prof Lin questions during the lecture like students would in a traditional classroom. This made the lectures are approachable and the TA-conversational format works well with the course material. There were a few quiz questions in each quiz that were confusing or more difficult than I expected based on the lectures. For the most part though, the quiz questions were extensions of the lecture itself. Definitely one of those classes where you need to watch the lecture so you can do well on the quizzes. I had to skim through the lectures for a few weeks and it really affected my quiz grades. Workload was also really dependent on the project. The first 3-4 assignments were easy enough, in the range of ~5-10 hours of work each. The last two projects were challenging and took me ~12-15 hours to complete. I have programming experience, although I did not do a CS undergrad. If you took a data structures class in undergrad, you'll likely find this class to be around the same level. If you have no programming experience, I would recommend you brush up on the basics (using Python) before starting the class or don't take any other classes for this semester.

Pros: 1. Good review of topics you should've picked up in an undergrad DS course 2. Projects will help you develop programming skills 3. Cons: 1. Test cases are a pain and unclear 2. Quiz questions require a ton more thought than what is covered in lecture 3. Very surface-level covering of algorithms Detailed Review: Okay, the quizzes can be hell but you'll get a lot out of this class, especially if you have a weak programming/DSA background. As someone with a good DSA background, this class was largely an exercise in programming rather than learning. This class is by no means sufficient to go into programming interviews with: I'd recommend doing some supplementary reading each week to help add similar data structures/algorithms into your arsenal. I say that this feels as if it is an undergrad class. Nothing here is really graduate level. The professor said in a video somewhere that this class was added because DS students generally had a weaker programming background. That's great and all, but this should be a graduate class. In my opinion, they really should've kept the algorithms class that DS students were allowed to take in the past for the stronger students and also offer this for students who need some help. Curve is pretty lenient in my opinion. Raw ~85% is enough for an A. The first three assignments are pretty easy. #4 and 5 are difficult and require a lot of debugging. #6 just requires some thought on strategy. The quizzes are hard right from the start and continued to be hard right up to the end. TAs when I took this were great, especially Joseph. Prof was absent pretty much the whole class as is to be expected. Was there to essentially give a copy-paste introduction at the beginning and to roast cheaters at the end.

Pros: 1. You need to learn DS and Algos - this will set you up 2. If you're rusty with OOP/Python concepts you'll get better 3. You'll get solid support from course mates and some TAs Cons: 1. Schizophrenic Professor and grading 2. You'll never figure out, why your test cases failed 3. No support from most TAs (except Ha) Detailed Review: Let us face it - If you interview anywhere for a ML/Technical DS role chances are you'll have a coding round that involves knowing Big O analysis. If you haven't done that before then prep before you come to this class and try and get the most of it. Unless you've a (recent) degree in CS you'll likely want to spend a lot of time in concept land before you take a course like this one - you'll need decent OOPs skills and Python coding abilities to attempt this course; don't lull your way into it. On the other side, this course skips a lot of Sorting and covers some Searching (not exhaustive); BFS/DFS/Djikstra etc. are covered and decent intro; you'll need a lot more Dynamic Programming than here. Prof Lin’s lectures are useful, though there's a ton more resources on YouTube that are better. Read up all of them in your spare time. The lectures are pre-taped in a Socratic method type format and are okay. More about his idiosyncrasies further down The quizzes are kind of crazy and you'll need to watch the lectures to attempt the quizzes to do well. Now comes the heartburn - the assignments. In Kaggle style you'll get some known test cases but you'll mostly be evaluated on unseen test cases. They won’t tell you *why you failed* some test cases even after they score them. So mostly you don't know what the heck you did wrong. The Prof. and the TAs claim this will help you "learn". I beg to differ - if one doesn't know why they erred, what exactly have they learned? They've learned they got a zero on some test somewhere. Pedagogical outcomes should be tied to actual learning of students, not in administering clever test cases and leaving people confused and frustrated. The biggest con – I will go out on a limb and call this out – Prof Lin wrote 2 posts in the entire semester – One in the beginning welcoming people and telling us not to whine. One in the end, where it sounded to the rest of the crowd that he had caught someone cheating. And it seemed like he waited the entire semester to relish his catch. Otherwise, he was MIA with zero participation. It is quite obvious he does not care for you or your outcome. It almost feels like he’s solving some personal issue he’s had with someone cheating in the past or gotten a leg up at his expense etc. Did I learn anything? Sure. I also learned that I can a lot more on my own and with my course mates. I did get better at coding and algos. Is Prof Lin's class good for you and useful? Absolutely. Is he pathologically nuts? Yes. People in authority like him, should contemplate deeply about psychological safety. Is the way he grades (degrades?!) bizarre? Yep. Are the TAs generally helpful? Yes. But don't expect much - some of them are astoundingly unhelpful. Ha Thai is the best – he appears to be a human being who cares. Are the course mates helpful? Absolutely. This is the only forum where you'll get any help - Get on a Discord server for the class and focus on learning from each other. And yes, Leetcode on the side, to get ahead. Do you need DSA? If you want to succeed in technical interviews then you better get good at this topic. Either with or without this class.

Pros: 1. Your programming skills will absolutely improve. 2. You'll never again be tempted to debug via print statements. 3. You'll have a solid grasp of fundamental data structures coming out of the course. Cons: 1. --- 2. --- 3. --- Detailed Review: I really liked this course, even though I've scarcely ever worked harder to pull off a "B" than I did here. Professor Lin is great. The lectures are great, the quizzes are fiendishly difficult, but fair, and the projects are challenging, relevant, and geared at turning you into a better programmer than you were coming into the course. For me, at least, this goal was more than achieved. I know the course can be really challenging, especially in the second half. But fear not - there's a generous curve, and everyone who really puts in the effort in the end does well. Lin is a great professor and a really decent guy...just work hard and you'll learn a lot in the course and (with the curve) come out with a passing grade.

Pros: 1. Really get your hands dirty with implementing algorithms in python 2. Assignments are quite interesting. 3. TAs are quite helpful Cons: 1. Takes a lot of time 2. Homeworks are unequally graded. Know this. Not all HWs carry equal weight. 3. Collaboration is not allowed in the later part of the course. Detailed Review: Overall quite stressful but important course. Gets you prepared for python programming and hels you understand important algorithms used in practice. Necessary to do an algorithms course at least once in your life. I was taking ML and DSA at the same time with a full-time job so I lost some hair in Fall 2023. Jokes aside, this ended taking about 20 hours per week on average for me and I do a programming job which involves me spending about 40% time writing code although C/C++. Find good homework partners for at least the first few homeworks where collaboration is allowed, this will help your understanding and also make you feel less alone as you go through the ordeal.

Pros: 1. Professor Lin is witty, helpful and knows the perspective of his students 2. The conversation-like structure of the lectures is very helpful 3. The projects are engaging and meaningful 4. There was a generous curve Cons: 1. The quizzes often felt too complex from the lecture info 2. The class essentially assumes you are familiar with Python (and Object-Oriented Programming) DETAILED REVIEW Pros: I really enjoyed this class, in main part because of Professor Lin! Professor Lin is one of the best teachers in this program. He constantly slipped jokes into the lectures and explained the material very well. He writes on a chalk board, which helped him to slow down his teaching which I liked because it helped me to understand better (versus skipping through slides on a PowerPoint). In the lectures, there is always a "student" present that Professor Lin talks with and asks questions to. The "student" also asks questions and makes clarifying comments. Having a student present helps to slow down the lectures and brings a unique learner perspective rather than just having the teacher present the material the whole time. I felt the projects were fun and meaningful. Projects 1, 2, 3, and 6 all have some sort of "game" aspect to them, which makes them more engaging. In general, most of the framework for the projects is already in place, so you don't have to start from scratch, which is very nice. You simply have to build upon the framework to get the desired functionality (using various data structures and algorithms). There was a generous curve at the end of the class. The final cutoff for an A was an 83 and the final cutoff to pass the class (with a B-) was 55. The need for a generous curve also means that the class was difficult for many students, but having a curve in general was nice. Cons: There are 6 quizzes in the class and they often felt too detailed. For me personally, I did far worse on the quizzes than the projects, and I usually got marked down because I missed minute details. Often I feel like the quiz questions couldn't be answered explicitly from the material in the lectures, which was frustrating. The first week of the class has a few lessons on programming in Python, but there isn't any formal lecture or training on Python or OOP. For me, this wasn't much of an issue because I had done OOP in Python before, but I put it here as a con because other students might not have that experience. I would highly suggest taking an intro online course on Python or OOP before taking this class. If you don't have that experience prior to this class, you'll find that you will end up doing that work during this class. FAVORITE QUOTES FROM THE CLASS "Elegance is not a dispensable luxury but a factor that decides between success and failure." -- Edgar Dijkstra “If you have a long, skinny tree in the forest, can anybody really hear it? Well, no.” — Witty Professor Lin

Pros: 1. A challenging survey of data structures and algorithms, good to get you into an analytic mindset 2. Lectures are interesting but somewhat incidental to the quizzes and projects 3. An effective if challenging way to learn/master debugging, testing, and coding if you need it Cons: 1. Little to no feedback on performance, very frustrating to not know what you did wrong and how to improve 2. Can be very time consuming if you aren't a day to day codesmith 3. Content is generic analysis and not oriented towards data science Detailed Review: Know recursion before you begin. Trust me, if you don't have your head around recursion you will suffer. It will help to bone up on big-O analysis because that is where things get serious first. In general I found googling more effective than the course texts throughout. Spend as much time on your test cases as your code. This was the first course I took. I came to the MSDS program with decades of experience developing technical software, including more than 20 years as an architect. Prior to this course, I hadn't taken a university class in well...ages. I was not well calibrated on the effort. I don't write a lot of code these days in my day job. I did know python. Take the preceding into consideration in reading the following. The lectures are interesting, and the rhetorical technique of having a student plant to make it conversational is effective. Prof. Lin is a good lecturer, very traditional old school type. it works. The lectures are interesting and engaging, but more related to the quizzes than the projects. The course is designed to get students into the mindset of analysis and design in general rather than data science specifically. As such the material is garden path CS. The quizzes varied in difficulty greatly, and I was surprised more than once on the depth of the questions or the subject. The projects were a variation on the lecture topics, loosely. The projects as noted in other reviews were very much tuned to scalable auto grading. This is the most significant problem with the course. The coursework is so focused on scalable auto grading and cheating prevention that it becomes nearly entirely devoid of learning opportunities, all assessment and no learning. There is essentially zero feedback on your work. The other problematic issue with the projects is the opaqueness of the grading rubric. The projects come with skeleton code to get you started including skeleton test cases, but zero information on what behavior is to be assessed. Time? Space? Negative test cases? Edge cases? You only find out when you fail a test case and then only can attempt to infer what exactly the criteria was from the test case name. If you leave a minor bug in the wrong place, you may find that path is executed in many/most test cases, and you will pay dearly. You can guess I learned that the hard way. Be very proactive and comprehensive in your test cases. The single most important thing for this course is time management. Do not fall behind because things pile up. Be very aggressive about starting the projects in particular. Get on them as soon as they are released or you may find yourself running out of time with the next project on top of you as well.

Pros: 1. Great lectures - clear, engaging, and well structured 2. Projects are reasonably challenging but not impossible 3. Good TA support in Piazza and lots of office hours Cons: 1. Difficult to learn from mistakes due to lack of grader feedback 2. Lots of unclear quiz questions 3. Detailed Review: My experience with this course is similar to most of the other reviewers. As someone without much formal programming background, I learned a lot and am a much better programmer for having completed it. Like most other reviewers, I found the second half significantly more challenging and time-consuming than the first. A few thoughts: -You need to learn to write your own test cases to do well in this course. You can get through project 1 and possibly project 2 with the provided cases alone, but that won't work as well for project 3 and beyond. -As others have pointed out, you won't get meaningful feedback from the autograder in most cases, and the instructors will not provide specific feedback on your code in public posts. Go to office hours or make a private post if you want answers. I got good feedback when I explained my thought process so the instructors could help me understand where I went wrong. -I thought the quizzes were the weakest part of this course. I understand that they're trying to make the questions ungoogleable, but I often found myself trying to guess the right interpretation. That being said, I was successful in getting a question regraded at one point, and Dr. Lin personally said he would clarify the wording for future semesters. The instructors *are* reasonable about giving feedback if you can clearly explain your reasoning, but it's a little frustrating that the questions are so unclear in the first place. -I thought the main textbook (Weiss) was helpful in explaining concepts (I know many others disagree). My routine was generally to watch the lectures first and then read the textbook to review for quizzes. Yes, the textbook is in Java, but the concepts are the same. It's definitely not essential, but I think it's worthwhile if you're someone who learns well from reading.

A brief bit about my background for context: I do not have any formal CS training. I had limited Python scripting experience prior to this class, but little to no OOP experience. Pros: 1. My programming skills increased by at least an order of magnitude by completing this course. 2. Dr. Lin is passionate about the subject matter and genuinely seems to care about teaching the 'why' behind the course concepts. 3. The TA's were top notch, overall. Cons: 1. There are no sample solutions provided for the projects, so it can be difficult to learn where to improve. 2. Similar to item #1, the grading is quite opaque. You can see the names of the tests you failed in Gradescope (after the grades are posted); however, in many cases the names don't give much information regarding what the test actually evaluated. Again, this makes it rather difficult to interpret how you went wrong. 3. The quizzes are deceptively difficult, relative to the content presented in the lectures. Detailed Review: First, I want to say that, overall, I absolutely loved this class. It challenged me it a good way and I can already tell that my programming skills have improved dramatically. Furthermore, I have already applied many of the concepts presented in the course in my professional life and have seen dividends. Dr. Lin has structured the course such that it teaches how to approach algorithm analysis and programming in general from a strategic perspective, rather than a vocational, tactical perspective. Both have their merits, but I definitely think that the approach Dr. Lin takes provides more value for this degree. If you don't have a CS background: be prepared to struggle. I would strongly recommend getting up to speed on object oriented programming principles & recursion prior to taking this course. Be comfortable with classes & inheritance. If possible, get used to debugging using PyCharm or another IDE, instead of using print statements. Some will say to focus a lot on Python prior to taking the class. Personally, I think that the required level of explicit Python knowledge is relatively low. If you know OOP from Java, Swift, C++, or some other language, you will pick up the Python syntax relatively quickly. But if you are new to programming in general, then learning OOP & Python simultaneously (prior to this class) is the way to go, if you can. If you are new to object oriented programming, DO NOT procrastinate on the projects. Start on them as soon as they are released. The projects took me anywhere from 10 to 60 hours. You will need to develop your own unit tests to make sure that your code is functioning appropriately, which is a skill all on its own. My only real complaints are that the quizzes tended to cover a lot of information not really addressed in the lectures and that the grading is exceptionally opaque. That being said, I still learned a ton and am glad that this course is part of the program.

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. Homework projects are all game-related and very interesting 2. A huge TA/supporting team of 6-8. TA office hour almost everyday 3. Lectures are well explained Cons: 1. No slides are given for the lectures 2. Sometimes not very clear definitions of inputs/outputs for the coding projects 3. A bit tedious into details, for some of the trees Detailed Review: Overall, I have mixed feelings about this course, but I like it the most out of the four courses I have taken so far in MSDS. There are pros and cons in many aspects of the course. Nevertheless I feel that I learn a great deal out of it. On the positive side, the homework projects are all game-related, which makes them very interesting. Additionally, the course has a large TA/supporting team of 6-8 members who are always available to answer questions and provide assistance. Furthermore, the lectures are well-explained by a knowledgeable professor who uses examples to explain concepts and summarizes key points for each session. However, there are some negative aspects to the course. Firstly, no slides are given for the lectures, and the professor uses chalk and board, which slows down the pace. If you need to look up something later, you have to watch part of the lecture video again. Secondly, some of the coding projects have unclear definitions of inputs/outputs, which can be a distraction from the main purpose of the course. Students sometimes need to ask questions on Piazza but do not receive clear clarifications. Finally, some of the trees can be a bit tedious to work with. The homework projects are a lot of fun because they involve building games with Python. The starter code and test cases provided are really helpful in verifying if my code is on the right track. However, some issues with the homework include the lack of clear definition about input/output, which can be frustrating. Moreover, Python iterators are used in some projects, but they are not taught in the lecture. Fortunately, we have a great TA team of more than 6 members who are always available to help with questions and code issues. Nonetheless, some of the quiz questions can be tricky. I have a background in physics and do not actually do coding at all in my work. I took the U of Michigan "Python for everybody", and part of the Stanford's "Divide and Conquer, Sorting and Searching, and Randomized Algorithms" course, both on Coursera, before taking this course. With those preparation, I feel the level of difficulty of this course is manageable for me. From spring 2022 to fall 2022 (the semester I took this course), they made quite some changes to the course. I hope they can make this course even better for future students. Grades cutoffs for my semester (I would say it was very generous) A > 84% A- > 76% B+ > 72% B > 64% B- > 58% C+ > 47% C > 0%

Pros: 1. Learn a good variety of fundamental data structures 2. Generous grading curve 3. Plenty of hands-on practical coding experience in Python Cons: 1. Assignments ramp up in difficulty considerably for the last 3 of 6 assignments 2. Quizzes can be tricky and have very vague questions/obscure wording 3. Detailed Review: Disclaimer: I come from a bioinformatics background with about 3 years of proper programming experience in Python, mostly self-taught with one semester of bioinformatics-based coursework in Python. This class was my favorite of the program so far, having also taken Probability, Regression, and Design Principles. The content is very engaging and I think that the topics covered are directly applicable to data scientists. Assignments: There are 6 assignments. The first 3 are quite straightforward with the last 3 being worth the most and more challenging. There is a large emphasis on efficient code which is made evident with one project where your code will not submit if it doesn't meet a certain efficiency/time requirement. While this can be frustrating, it is quite useful to actually teach how to write effective code and review different design decisions i.e. amount of recursive function calls, etc. Assignments are graded with an auto-grader and some starter test cases are provided. These are useful as a starting point, but students should be sure to exhaust their own test cases to make sure that code runs properly. A big emphasis in the class is learning how to test code creatively and independently. Quizzes: These were frustrating as they were all theoretical from the lectures. Grades varied widely on these with some quizzes being very tricky and the class average just barely above 50%. Luckily for me, I did much better on the assignments than the quizzes, and with quizzes being worth only 30% of the total, you can still do quite well even if you mess up some of the quizzes. Piazza & Professor: The lectures were done very well with a mock student-prof interaction on the blackboard. I was a big fan of this approach. Additionally, the level of TA support in this class was the best so far. Other thoughts: You will definitely need some real practical programming experience in Python to find this class manageable. I would suggest at least 1 year of informal Python programming, and familiarity with Python functions & classes. If you have never programmed in Python before, you will likely find this class VERY challenging.

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.

Pros: 1. You will end up learning a lot and gaining some new skills. You will need some of this course to pass most job interviews. 2. Tons of help is available, office hours and Piazza support were plentiful 3. You will get good at testing your code Cons: 1. Lectures felt a little disjointed at times, but they are pretty engaging to watch. 2. Opaque grading makes it hard to know how exactly you messed up 3. Pretty limited starter code or pseudo-code 4. Textbook examples are in Java Detailed Review: # My background My background is that I studied aerospace engineering in undergrad and took Java CS classes in high school. I've also been using Python at work for a few years now, mostly for analysis and data engineering. I also took one CS class that was in Java during undergrad, along with a few MATLAB scripting classes. # This semester's changes Before taking this course I had heard about the previous iterations being rough around the edges. I believe a lot of the problems with this course were addressed such as how now the development environment is pretty simple to set up (don't need to fuss with linux or anything like that), submitting your code is through github and canvas. Only one package is needed (pytest). A lot of TA office hours were available this semester, more than any other class I've taken. I'm pretty sure no matter the work schedule or time zone you are in you could find some office hour to attend within a couple of days. Not sure if this was the case in the past, but you get up to six "slip-days" where you can submit your code late. # Preparation It's hard for me (or anyone) to give a non-biased review of this course. It is very much "your mileage may vary" and the syllabus says just as much. If you are familiar with tackling programming problems, especially with Python, then you can probably do the assignments without breaking much of a sweat. This is pretty close to where I am. On the other hand, if you have never used Python or a similar object-oriented language before and have never heard of programming concepts like recursion, classes, methods, or loops then this course could be a complete black hole sink of time. Dr. Lin goes over these concepts during lectures, but it is so high-level that should be treated as review. I think people who get real lost in this course get confused that learning Python is the same thing as learning problem solving. You need to enhance both of these skills at the same time in order to do the assignments. There is no magic built-function in Python that will solve any of these assignments in a few lines of code. So, if you are trying to prepare for this course, I'd make sure you can do some pretty basic coding challenges to enhance your problem solving skillset and make sure you brush up on Python so you can enhance that skillset. If you feel good on these, then you should be on the right track to do well in the course. Some ideas: Coding Bat: https://codingbat.com/python Advent of code is fun, too: https://adventofcode.com/ Also, I'd mess around a little on Pytest if you have the time. # Warning on group work They allowed for group work on the first three assignments, that can be helpful but also a crutch at the same time. The first 3 assignment were worth only 21% of my final grade, while the last 3 were worth 49%. If you are copying your teammates code in the the first three you will be real lost on the individual assignments. I'd treat it as a way to bounce ideas of teammates and create test cases, not as a place to learn how to code or problem solve. # Grading and test cases You are graded by an autograder that will run a series of test cases of which only a small subset are provided to you. The rest remain inside a black box and you will only know if you passed or failed these after the submission window. This is done to encourage you to create your own test cases and to think about edge cases where your implementation may fail. I think this idea was on the right track, but the autograder feedback does not provide a ton of detail. You'll get a timed out error but have no idea that was a requirement, or really have any way to know how to test for that. The autograder doesn't give you accurate enough feedback to go back and fix what was broken, even if you wanted to. Also, because of the long submission window due to the six slip days, you won't get your grade until it's about time to submit the next assignment. # Conclusion I think this course is pretty decent and has definitely improved my coding and understanding of data structures. I don't know what the grade distribution will be like, but I doubt many will fail this course. I'm sure many more dropped it.

Pros: 1. Learn a lot about the subject matter 2. Improved my coding skills 3. Huge grading curve Cons: 1. Difficult environment set up that wasted a lot of time 2. Office hours are overcrowded 3. Detailed Review: We know at this point that the prerequisite of "1 semester of coding" was far off from reality, more like a couple of years. I would add that coding experience is also not as helpful unless it is OOP. There were some difficult concepts for me to grasp that probably were much simpler to students with a CS background. The course was very challenging and assignments took way longer to complete than what was advertised. Even those that were already very skilled programmers seemed to take longer than expected. I learned a lot from this course, but mostly from the independent study required to complete the assignments. I considered dropping this course after the projects quickly ramped up in difficulty after the first couple but pulled through.

Pros: 1. HW required actual coding in Python 2. Clear lectures 3. TAs generally helpful on Piazza Cons: 1. Several extremely difficult quizzes 2. Most conceptual material not directly relevant to most real-world data science jobs 3. Homework autograder seemed arbitrary sometimes Detailed Review: If this is your first experience with Python, you will be in over your head on the homeworks. You should take a crash course in object oriented Python before you start. I have a fair amount of Python experience and each homework still took me 6 or 8 hours. Be prepared for quizzes in the second half of the course to be difficult - the average grades on some quizzes were only a shade above 50%. I still find myself a little bit at a loss for how I could have done better on those quizzes. In the end, the grade distribution was generous, with A being the modal grade and the curve allowing grades as low as 85% or so to be As. Bottom line: If you know your Python and don't let the occasional tough quiz or weird autograder fluke get to you (knowing that there'll be a decent curve), it's a fairly good class, especially if they smooth out some rough edges.

Pros: 1. Lectures are good 2. 3. Cons: 1. Autograding is random and highly dependent on the grading environment 2. 3. Detailed Review: I've very good experience programming. I don't believe the ability to program is very critical to acing all the assignment (though it's of course necessary). They grade in an environment that's different from what students are working on which would potentially yield to a complete different results especially in terms of run time (run time of code is very critical in this course!). They don't really specify timeout in some assignment and rather they provide time complexity requirements such as O(log[n])! It felt like a joke in some cases how they are going about autograding. The issue I raise above isn't about the impact on the grade itself. It actually curtails learning. Even after the grades are out, you don't know what you miss to learn from. There is no single method to solve the same problem. If the runtime is the only metric for example, one would design solution accordingly and will have a chance to see how the program logic (rather than run time) is doing!

Pros: 1. Very good lectures with good explanations and clear examples 2. Mostly interesting projects, makes you a better programmer (but only if you were a programmer to start with, I can't imagine doing these assignments as an inexperienced programmer) 3. No exams Cons: 1. Grading very opaque, had no idea what my actual grade was at any point 2. Quizzes and to some extent programming assignments felt disjoint from lecture, especially at beginning 3. Huge focus on stopping cheating, at the expense of learning 4. It's impossible to keep up with Piazza Detailed Review: Note: I have a BS with a minor in CS, 10+ years programming experience, and a strong but informal Python programming background. Overall I enjoyed the class and felt like I learned a lot from the lectures. The lecture format was instructor at the chalkboard which is my favorite style (versus reading boring powerpoint slides). The lectures were interesting. The addition of a "student" to interact with the instructor was nice as well. The recommended book is okay, but the code examples are all in Java while the class is all Python. I gave up trying to keep up with the reading assignments (for lack of time) and didn't feel like it hurt my understanding. The quizzes were okay, but poorly worded sometimes. At the beginning of the semester the quizzes felt very disjoint from the lecture and in one case had material that I don't think had been covered yet. Also, the quizzes appear to be randomized so not everyone is presented the same questions. I have a strong objection to this scheme and I believe it is very unfair to not give the same set of questions to everyone. The programming assignments were mostly interesting and enjoyable. It is definitely to the student's benefit to already have experience programming in Python and some familiarity with Linux. The weekly time commitment for the later assignments was more than the earlier and I felt burned out by the end (making it difficult to get started on some of them). The programming assignments have "extra credit" called karma that doesn't provide points but if you do a lot of karma they may bump your grade at the end. I spent a lot of extra time doing some of the karma and felt like I should have saved my energy for the next assignment instead (my point being plan better than I did I guess). Grading was very opaque. There was a promised curve all throughout the semester, but at no point did I feel confident of my grade. There was little explanation of programming assignment grades or test cases and no correct code is provided, making it impossible to learn from mistakes. There appeared to have been requirements that were graded on but not provided in the assignment descriptions. The grading was frustrating and stressful. Piazza is awful as a platform for 400+ students in one class. It's impossible to keep up with. The instructor and TAs did a good job keeping up with it though and were timely in responding to private posts.

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.

I wont go into Pros and Cons but here is my detailed review: In the course outline, the topics are divided into three sections - Programming, DS and Algo. On one hand, in Programming, they want to teach testing, debugging, Programming Methodology as if you are a newbie programmer. However, on the other hand, they expect you to be a rigorous programmer with minimum of two semesters of hardcore programming experience (this is an official statement from Professors and TAs). In DS, you are expected to know basic data structures and they will try to teach you complicated structures like B-Trees etc. I am not averse to learning advanced data structures. Thought, I am from CS background but a lot of people from non-programming background are part of MSDS and I can understand their pain and confusion In Algo section, you don't know what are divide & conquer, greedy or Dynamic Programming. They may have taught DFS, BFS, Binary search etc. but which belongs to what - hardly anyone cares Lectures - Believe me, lectures are like 101 and a colossal waste of time. I stopped watching lectures after 2-3 quizzes. Just took the topic headers and went on YouTube and watched top 5 rated videos there. By the way, lectures don't help you anywhere - not in assignments, not in quizzes and there are no additional reading material Quizzes - In this course, quizzes are test of your mindreading skills, i.e. how good you are with reading mind of the person who designed the quiz. The questions and the options are too vague and will have multiple meanings and interpretations. I started feeling as if I was part of English course rather than a DSA course. The question will have multiple meanings and depending on which meaning you interpret, there will be an option (out of 6-7 options) which will match the answer of that interpretation. And if you change the interpretation, then there will be another option. Lectures and Quizzes have nothing in common. By the way, Quizzes contribute to one third (33%) of the entire grade (assignments contribute to remaining 67% of the grade) Assignments- There are 7 assignments (Course Agreement, Image Manipulation, Evil Hangman, Boggle, Treaps, B-Trees, Wikiracer). And all the assignments test you in the mind reading skills and your patience. For example, Course Agreement had a simple question - Have you read the Syllabus and Course policies and agree to it? The response is a free text to be filled in a text area and if you have put a simple Yes, you will get 0 out of 10. The response should have been two options - Yes and No through radio buttons and believe me it is the easiest assignment of all the seven. Also, all the assignments contribute differently to the 67% of the grade like earlier assignment contribute less and later assignments contribute more and No, we were not told about the exact breakup (i.e which assignment contributes how much) after Evil Hangman (as far as I remember). Now the assignments are supposed to be done in Python (agreeable) but using Poetry framework. The initial setup instructions were full of discrepancies. It was a nightmare to get everything setup correctly and then the debugger doesn't work. Though there is a lecture video on how to debug in VSCode but that is not applicable with VSCode+Python+Poetry. Initially all the assignments were individual assignments - Image Manipulation was relatively easy but it became too complicated because it was supposed to be done in Poetry. Then the difficulty level went 100X with Evil Hangman. Boggle became another 100X (Compared to Evil Hangman). After a lot of criticism and feedback on Evil Hangman, the Boggle, Treaps, B-Trees assignments were made Group assignments (in groups of 3) which made them bearable. According to me, Boggle was the toughest assignment because it involved poetry at its worst (e.g. if the Terminal window is less than a particular size, it will throw an error and you wont know what to do about it because you can't properly debug in Poetry. The only way to debug in Poetry is through Print statements which you need to place at various places. Boggle, Treaps, B-Trees and Wikiracer became a bit manageable because of Groups (Wikiracer was an individual assignments) and because the Pytests removed the dependencies on Poetry to a lot of extent. The assignments in general are difficult because partial code is provided by the instructor and you have to write code for few functions or classes and there were no proper instructions in the handouts on what is required. The handouts contain high level what the assignment wants you to do. TAs and Professors started providing videos on what is expected but it was nothing but a mere replication of the content in the handouts. The biggest problem which I felt in all the assignments were the use of ADTs (Abstract Data Types) which were extensively used (in Boggle, Evil Hangman etc) and mind you there are no videos on ADTs or OOPS concepts in any of the lecture videos. So, the entire assignment became an exercise on guessing what the TA or Professor were thinking while coming up with that particular structure of ADTs or inherited classes/functions. Now, those who know or have done programming are aware that every person will structure the code differently and hence it was difficult to comprehend what was required. Evaluations were another issue. Though the quizzes get evaluated almost instantly, the solution to the quizzes were released almost 10 days after the deadline and by that time, either you have forgotten why you chose a particular option or you are too tired/frustrated because you can clearly relate that your interpretation of the meaning of the questions/options (due to choice of words resulting in ambiguity and vagueness) were different than what was expected. Evaluation of assignments was a big issue. All the assignments were graded using a mysterious auto-grader with mysterious test cases and evaluation took a min of 7-8 days to 3 weeks and by the time the results are out, you would be busy with the next assignment and you would just accept whatever grader the auto-grader has given you. There were only two good things in the entire course - First there were no exams (mid-terms or end-terms) and second were the responsiveness of the TA and Professor on Piazza and their open mindedness. Spring 2022 was the first time this course was offered and honestly, I expected the course to have some hiccups but the course had a lot of mountains as hurdles. Withing 4-5 weeks, I realized that I wont be able to learn anything new from the course and I started treating this as a course to just be done with it so that I can get the degree. At the end of the course now, I realized that this was the right decision because I had taken DSA course in my UG in CS and there was nothing new which I learnt or was taught here. For future improvements - The Professor and TAs should understand that this is an online course and there are people with varying level of programming background and experience. It is not a campus course where the entire class has less than 2-3 year of programming experience. In an online course like MSDSO, there will be people with 0 programming knowledge as well as people with 20 years of work experience. DSA is a hardcore CS class. Next lectures should be redone. They should check the lectures and delivery of Data Visualization course (Spring 2022 was also the first time Data Viz was offered but the lecture quality was superb). They should provide autograder to the students so that they can run the auto-grader and see if there are any bugs. The focus should be on learning rather on making the course difficult in terms of grading

Pros: 1. Really engaging lectures by Professor Lin 2. Professor Lin and his TAs are on Piazza often to answer our questions 3. Office hours are very frequent, usually as often as once per day (on Zoom). This is better than what is offered for on-campus courses; indeed it is a gold standard of how online Masters's courses should be run Cons: 1. The quizzes could be vaguely worded at times 2. The learning curve at the beginning of the course could be tough for those without prior Python experience (at the very least, some experience with OOP and recursive functions) Detailed Review: As someone who has prior experience in Python I really enjoyed the course. The lectures are engaging and the homework is suitably challenging. That said, I think people who have no prior experience in Python would find the beginning of the course rather difficult. As I understand it, the course will not be offered for 2022 Summer and Fall for revamping. Honestly, I think the course is fine as-is and is of a suitable level of difficulty for an MS in DS. Nonetheless, the MSDS program should perhaps offer another (more introductory) programming course for those who are less experienced in programming; I sense there is a large divide in the class between people who have coding experience vs those who don't. Perhaps something could be done to close this gap (say a non-credit programming basics course)?

Pros: 1. Good introduction to Data Structures 2. Great lectures from Dr. Lin Cons: 1. First iteration - issues with assignments that should be ironed out for future semesters 2. Assignments don't link well to the lectures 3. Teach yourself how to code in this course Detailed Review: While I enjoyed the lectures in this course, the assignments were often frustrating. There's a large element of DIY learning with the coding aspects of this course. If you are not Python-savvy, do some online coding courses to prepare.

Pros: 1. Lectures are really interesting 2. Piazza is extremely active 3. Quizzes and projects are very hard, but in a way that teaches you a lot Cons: 1. Quizzes were short, and sometimes worded strangely, so one bad question can throw you off 2. There was a lack of transparency on the grading curve (like most classes to be fair) 3. Projects took a long time to get graded Detailed Review: This class is going to get revamped after this semester, so this review won't be too helpful, but I did want to say Professor Lin taught me a ton of information in a short amount of time. The class was very hard, and the ambiguity of my grade was sometimes frustrating, but I learned a LOT in this class.

Pros: 1. Lectures were quite good - the interaction dynamic in the videos made it easy to watch and focus 2. Assignments ramp up throughout the semester, starting with simple to increasingly more complex 3. Good overview of basic data structures Cons: 1. If you have any undergraduate experience in data structures this class will feel redundant 2. If you are new to programming, or new to object oriented programming the assignments may be a struggle 3. Direct connections to data science were lacking NOTE: The professor has already announced they are aware of the difficulty some students with no programming experience faced, and are re-working portions of the course so this review may not be reflective of future renditions of the course. Personal background: not a CS major, but minor experience in coding through out the years for personal projects. I did not find the assignments "hard" from a logical standpoint, but my lack of coding experience meant some of them took a good amount of time. Quizzes were not the best quality, but fair from a grading standpoint (all questions pulled from question banks). All assignments were in python. When it became obvious that some students were struggling more than others, the professor started allowing groups for future projects. The last project had to be completed independently. Overall, good class but I'd say for most people the workload is high. The teaching staff was responsive though and did their best at managing the diverse background of the students and tried to adapt where possible. Textbooks were handy for reference, but not required (all available online though). Only docking a point on lectures due to no notes available.

Pros: 1. The material was generally explained clearly in the lectures and there was an emphasis on practical concepts that are useful for programmers to understand. 2. The assignments were more time consuming than I would like but they definitely helped me improve my programming skills. 3. The TA support on Piazza was excellent. Cons: 1. The instructions/requirements for the first three assignments were far too vague, though some steps were taken to improve the clarity of the requirements for the last three assignments. 2. I had no idea how to properly study for the quizzes as they regularly tested material that was not covered in the lectures. 3. This class will likely be a miserable experience for you if you have no prior experience programming in Python. Instructor Comments: I enjoyed Professor Lin's teaching style and found his lectures to generally be engaging and informative. He made effective use of the chalkboard during lectures but I wish he also provided his lecture notes as a supplemental reference, especially since his handwriting was sometimes difficult to read and there were occasional errors in what was written on the chalkboard. On a personal level, I found Professor Lin to be likable and I appreciated his often self-deprecating sense of humor. TA Comments: The TAs played a critical role in this course and regularly provided important clarifications on assignments via Piazza. In particular, Matthew was incredibly helpful and clearly put in a great deal of time to make this course a better experience for the students. His intro videos for the last few assignments, along with Prachi's video for the last assignment, were very helpful and provided a nice overview of the assignments. Finally, Leo's interactions with Professor Lin during the lectures were entertaining and made the lectures more engaging and informative. Course Comments: Although this course required more hours per week than I had initially expected, I generally had a positive experience and felt that my programming skills improved significantly. I loved that there was such a strong emphasis on completing programming assignments as I find implementing, testing, and debugging algorithms to be far more engaging and useful in the long-term than a purely theoretical approach. However, one major criticism I have is that the instructions on the programming assignments, especially the first three assignments, were far too vague and prone to misinterpretation. I found myself needing to spend hours on Piazza reading through every student question and TA response just to fully understand how I was expected to implement the methods required in a particular assignment. Some effort was made to address this issue for the next three assignments, by providing some test cases to check the correctness of your implementation and intro videos to provide an overview of the assignment, but I believe improving the clarity and completeness of the instructions for each assignment is the single most important improvement that needs to be made for future iterations of this course. Another criticism is that I never really knew how to prepare for the quizzes and I regularly found myself asked to solve a problem that was not discussed in the lectures. Given that the quizzes were only worth 30% of the grade, compared to the 70% from assignments, I spent the vast majority of my time on the assignments and just hoped I didn't do too poorly on the quizzes. Some of the quiz questions were also worded poorly and seemed to have answers that were somewhat subjective. I would have appreciated some practice problems or additional guidance to help prepare me for the quizzes. Finally, I think it's important to keep in mind that I started this course with considerable prior experience in Python and program in Python professionally. Many of my fellow students who were not experienced with Python had a much more negative experience in this course and I know several students ultimately dropped the course because the workload was simply too much for them to manage. Aside from being incredibly thorough in reading the instructions for every assignment, I believe having prior experience programming in Python is the single greatest determiner of whether or not a student will be successful in this class. I think it's unreasonable to expect a student to learn Python solely during the duration of the course to a degree sufficient to complete the assignments, even if they have experience programming in another language. I believe either more time should be spent reviewing Python fundamentals in the first few weeks of the course or the instructors should communicate to future students that there is an expectation that they have prior experience with Python.

Pros: 1. Exposure to object oriented programming in python. 2. Challenging projects. 3. Not just learning to do loops and functions. Cons: 1. Piazza was a slog at the start - lots of people trying to figure out how to set up the environment. 2. Too strict on discussion - weren't able even to discuss quizzes and projects after they were complete. 3. Grading was very slow. Detailed Review: This isn't an intro to programming. I'm trying to think of the best way to describe what level you should be and the best I can come up with is: if you don't know what an IDE is, how to use a shell, or what OOP is, then you'll probably struggle in this class. I think a lot of people came in knowing how to use python in a jupyter notebook, and that just wasn't enough. I was afraid that the course work would be a large amount of simple repetition, but this turned out not to be the case. The projects were challenging without being impossible. I spent a lot of time thinking and figuring out how to get to the solution, within the framework of the abstract classes they provided. The lectures were good - I liked the student questions gimmick that they had going, I thought it broke up the lectures in a good way. The TA's were also super responsive; there were a lot of them and they held a few TA sessions a day. If you're in a broadly similar position as me - able to hack a solution together when you really need to - then this course is great for getting an actual foundation in programming. If you already have a background in CS, then this might be on the easy side. If you have no background, or just have only ever used jupyter notebooks, then maybe consider something like an "OOP in python" class or something before you start this.

Pros: 1. The professor is excellent 2. I have a good understanding of data structures 3. I learned (all self-taught) a ton about Python but it wasn't enough Cons: 1. There is no opportunity to learn to optimize from a solution 2. There doesn't seem to be any data science relevant examples or application 3. You will have to teach yourself Python if you are not intimately familar Detailed Review: The lectures are all well structured and easy to watch. Prof Lin utilizes a "student" to fake ask questions to keep the flow more natural and from being too dry. The concepts are presented in a way that are easy to understand. The projects increase in difficulty from moderate to all-consuming. He says you should have had a high school coding course or one semester of college coding before enrolling- but he clearly has no idea what is being taught in a general coding class. I needed a couple of years of coding courses before I would feel ready to jump into this one. If you are not a daily Python programmer- it is not impossible- but be prepared to spend 20+ hours per week on coding. These projects are set up with abstract classes and provided doc-strings and function structures in a way that at first makes you think they will be straightforward but are really set up to optimize the ease of using an auto-grader to process them. The structure ends up turning what could be maybe 25-50 lines of code into a monster coding exercise. They will not show a solution. They will not share a working copy. They will not give you feedback for improvement. They will never mention the projects in lectures. Trying to get help from the TAs is very difficult (though the TAs are very helpful and were very patient and giving of their time). With hundreds of people in the course, you can expect to wait more than 2 hours on Zoom before they get to you if you need help. Expect to teach yourself nearly everything you need to know. After the first project, there was an adjustment to allow for people to work in groups. I tried this and it was miserable so I plodded along doing each project on my own. You can use up to two slip days per project if you need extra time. On the bright side, I feel like I have a much better handle on Python and implementing test cases, and developing tests to exercise my code. I really wish the projects were data science angled at least- there seems to be a disconnect to application for most of the courses I've taken so far in this program. Bottom line- you will only learn what you teach yourself. There are so solutions released so there is no way to compare your implementation and improve. I felt like whatever I self-taught had no opportunity for correction or growth. What bad habits was I teaching myself? As the projects progressed, you plodded on- carrying all your prior mistakes with you. By the last two projects, I was so stressed I was making myself ill. The course went from requiring 15 hrs a week to over 30. I finally dropped it two weeks from the end, even though I had a decent grade because I couldn't keep up with the time required. The course says you need one semester of college coding before starting- this is highly inaccurate. You need at least 18 hours and they need to have been recent. I have recent Python coding experience and am a competent coder in multiple languages- but it did not matter. The professor was expecting high coding competence through the program coordinators said it was for students with limited coding experience. He seemed genuinely shocked that many of us did not have whatever specific coding experience he assumed so he allowed some group work which I did not have time to do- which led to grade punishment. With the course on a curve, you are punished if you don't come in with his coding experience, punished if you can't work in a group, and then left to rot in Zoom hell for hours if you need help. On top of that, there are constant e-mails warning that all cheaters will be reprimanded- this course is absolutely not ready for the edX format. It's taught by a professor with past trauma or something with cheating students. Discussion is not allowed, there are no solutions or any code for any other implementations separate from the projects that you can learn from. The textbook is in Java and the quizzes are so obtuse- you can spend literal hours studying from multiple sources on the material covered, watch lectures from other universities on the data structures so you can get an additional perspective, and still score higher by guessing. Take this course if you want to be fully humbled and then whipped until you throw up for not feeling humbled enough. Horrible course.

Pros: 1. The lectures are overall good, with clear explanations of theory, drawings on chalkboards, and discussion between Leo & the professor 2. 3. Cons: 1. The 6 assignments make up 70% of the grade and they ramp up in difficulty very fast 2. You cannot work in groups at all. Any discussion of the assignments or quizzes, even after they're done, is considered cheating. 3. The lectures are purely theory - no coding, so if you don't have prior coding experience, you'll have a hard time connecting the two and teaching yourself code. Detailed Review: I should've known better than to take this class right from the first week when the teacher wanted everyone to install linux, but the instructions he provided were so woefully inadequate (and caused many errors during set up) that it took myself and two other people (who had extensive to moderate experience with linux) about 8 hours to work through all the errors and finally get the installation to work properly. The grade distribution is 30% quizzes, 70% assignments. The teacher assumed all the students have a high level of coding experience already, so there is almost zero coding discussion in lectures and he has insanely high expectations in terms of how you learn on your own: - no working in groups - no discussing assignments or quizzes with anyone at all, even after they're done and submitted - googling for ideas on how to code something can also be considered cheating per some of the piazza discussions I saw from TAs and the teacher. So basically, if you don't already have a solid coding foundation, you are forced to teach yourself how to code in this class... BUT you are also scrutinized for how you learn and some of your google research can be considered cheating. The assignments themselves are really tough if you don't have a coding background. Basically, the teacher provides the skeleton of the assignment and you have to fill in one or more classes to complete the code to make it functional. You are graded by an autograder and they have secret test cases that they grade you on. For the most part, the teachers and TAs have not been forthcoming about what these test cases are, but they dock you major points for not getting them. I missed a couple on my second assignment and it dropped my score to a 52% even though the bulk of my code was working. Also frustrating to note is that no solutions to assighments will ever be provided - instead you just get cryptic notes saying what tests your code failed. So you're left in a situation where you did something wrong, but you don't know exactly what you did wrong or how to fix it. By the halfway point of the semester, Piazza had over 1000 posts written in it and it was incredibly difficult to wade through all those posts to find information relevant to your work. Even worse, the assignment instructions are written very poorly and often times you have to search through piazza to find an important change / clarification to the assignment was announced halfway through the week (for example, the teachers didn't include in the instructions for project 3 that it would need to have multiplayer functionality and the majority of their test cases would use multiplayer. So if you just didn't see the piazza post announcing multiplayer functionality and you submitted a perfectly working code only for single player, you'd basically not get many points for the assignment since most of their test cases were for multiplayer). Furthermore, it takes them FOREVER to grade assignments. The first assignment took 11 days by my count. The second assignment was closer to two weeks. People have been so frustrated by this class that they openly criticized the teaching in piazza posts and the best answer we have gotten out of TAs and the teacher is that they weren't aware of the programming level of the average student AND "don't worry if you didn't do well on one of the assignments, there will be a curve". Which really doesn't answer the concerns students had at all. Furthermore, there is a major disconnect between what the teachers expect and the reality of this class - the syllabus states they expect students to spend 5-10 hours per week on this class, but when the reality turned out very different, a TA clarified in piazza that assignments could take "dozens" of hours. For the students struggling in the class, they ask the teacher and TAs for more concrete information on grading and how to improve, and the TAs / teacher always fall back on "there will be a curve". But what does a curve matter when this class is pretty well divided in terms of student coding skill? On the last assignment, 40% of the students scored a perfect score or higher. The portion of the class that already has a very solid background in coding surely will demolish the curve for everyone else, and this is a concern voiced by multiple students that the teacher and TAs seem to refuse to acknowledge. Overall, I despise this class. I expect this degree to be full of difficult classes and I expect I have to work hard. I have a math background, so I always expected that I would need to up my coding game to make sure I can handle these courses. But the way this class is set up feels like the teacher wants to treat students like criminals. Right from the start, they don't want to teach any coding and they are extremely restrictive with how students interact so students cannot help each other learn coding, and they consider much of online googling to self-teach as cheating. I realize the teacher is trying to prevent cheating by being very strict, but in my view, he's being so strict that he's also limiting the learning potential of students. I am of the opinion that, as long as you learn what you need to learn, at the end of the day it doesn't matter how you got there or how long it took you to get there. But this class's restrictions make it seem like the teachers strictly only care about the code, about deadlines, and about the fact that you cannot learn in groups or use outside resources to teach yourself. If you have a strong coding background already, you'll probably find this class to be a reasonable difficulty level and maybe even a "fun challenge". If you do not have a strong coding background, I strongly discourage you from taking this class until you do. This is, hands down, the most miserable experience I have ever had in an academic setting in my life and I regret signing up for the class. Straight up, I would prefer to take the theory-only version of the class over this version. Hopefully the teacher makes some adjustments to make this course more doable for those of us that have primarily non-CS backgrounds, but so far the only adjustments the TAs and teacher have hinted they may do is: - provide video instructions of the assignments to hopefully make all the expectations more clear - get a half-semester course in coding available for students to improve their coding skills I feel the need to say this again, since there has been a lot of elitism from CS students in the class looking down on the non-CS students. Saying stuff like "I thought the assignment was easy" or "you should've known a graduate level course would be hard, why didn't you prepare?" isn't constructive or helpful. There seems to be a big divide in the class between the CS elitists and everyone else, and it makes the entire vibe of the class feel very hostile and upsetting. If you're a person with a strong CS background already, I would guess you could take 10-12 hours on the assignments per week. If you're not, prepare to bang your head against the wall and have sleepless nights, spending 30+ hours on an assignment just to have your score come back as a 50% or lower, to not get any meaningful feedback, and to just be told "there will be a curve". I cannot emphasize enough how much I hate this class. I hope they make improvements to it in the future, but with how non-responsive most of the TAs and teacher have been to criticism from students, I don't have a lot of hope that major changes will happen in the future.

Pros: 1. Learn a ton of foundational programming skills really quickly 2. Programming assignments are fun 3. Instructors are helpful Cons: 1. Piazza is a nightmare. 2. 3. Detailed Review: I write this the day after Dr. Lin posted on piazza saying there were a number of students who plagiarized the first assignment. The first assignment was designed to "ease you into Python" (the Syllabus). The spring offering has about 350 students. The grades weren't great and its become clear a swath of students have no programming experience. Piazza has lost its mind and the instructors are now letting students complete assignments in groups of 2-3 (beginning on assignment 3). I find this concession pretty crazy and here I will explain myself. First, I admit I took two programming courses in college, one in java and one in R. I also did some free coding practice on udemy prior to starting the masters, and I have finished stats, ML, regression and casual inference. With that out of the way, before you take this class please remember its graduate school. Data Science graduate school. The programming is going to be hard and walking into a the curriculum with zero experience is a bad way to start. Second, we are online students paying $1000 a course. Thats crazy cheap compared to students on campus and there are 350 of us. I say this to help people realize that instructors are not going to bend over back wards for you if struggling. We are only getting $1000 of help back. All that aside, if you stick to and do a little coding each day on the assignments they are manageable and office hours have been helpful. Lectures are very big picture and you will be frustrated when its time to code. You're going to do a lot of searching on the internet for nuggets to learn from. Luckily there are an extreme amount of sources. RealPython has been my best friend. Quizzes are reasonable. I you can find 80% of the answers word for word in lectures and the other 20% requires some extrapolation. Please don't mob professor/TAs on piazza. your posts aren't actually anonymous even though it says so. When grades are low the forum turns into twitter real quick.