Reviews

Pros: 1. Projects are interesting 2. TAs are helpful 3. Good coverage of subject matter Cons: 1. Uneven work distribution throughout course 2. Unclear grading practices 3. Difficult to understand what is being asked at times Detailed Review: I took this as my first MSDS course. I had done very well in my undergraduate data structures and algorithms course, which used C++. I assumed this class would be easier, or at least on par in difficulty, because it used Python instead of a more difficult language. I was wrong. I was able to earn an A, but the final weeks in particular had a very heavy workload. The first four assignments are somewhat challenging but fairly straightforward. The last two are a complete curveball. I was only spending 5-10 hours per week during the first several weeks, but the time commitment increased drastically for the final two assignments to around 20-25 hours per week. I personally think it’s a little unreasonable to back-load the course like that, especially since it became difficult right around the holidays. Plus, it's a 3 credit hour course. I don't think the workload should ever extend beyond 12 hours/week at the most. The final two assignments were a Flux Equilibrium Clustering (FEC) algorithm and a Bounding Volume Hierarchy (BVH). The instructions for the FEC assignment were sparse and very ambiguous. The TA provided a worked out example of how the algorithm was supposed to work a day or so before it was due. I don't want to share too much, but there was a detail on the handout that didn't seem to match his worked-out example. I was able to figure out what was going on, but it was frustrating. I see now how it could be argued that was what the handout meant, but I think it could just as easily be argued the other way. I think the project description should have been more clear. The BVH assignment wasn’t bad conceptually, but it was a massive project. From a time-management standpoint, I felt they could have had us implement just the BVH class and provided the class dependencies. Instead, we had to write everything. No test cases were provided either. It wasn't quite as ambiguous as the clustering algorithm because the handout descriptions were a little more clear, but I would still prefer spending less time figuring out what it was that they wanted specifically. Despite the difficulty, the assignments were the best part of the class. They were interesting and genuinely useful. I just felt the last two could have been more reasonably scoped. The assignments are graded using an autograder, with all test cases hidden: you only ever see the name of the test you failed. Fortunately, I tested my code thoroughly and never lost more than a few points, but it’s hard to learn from your mistakes when you don’t know what they are. At times, it feels like the goal of the class is less about teaching and more about screening out students who aren’t strong programmers. The lectures also aren’t as good as people make them out to be. They take a long time and don’t cover much depth. Honestly, they feel more like entertainment for the professor than an effective teaching tool. They mostly only cover theoretical aspects with little to no practical examples. The professor seems angry that anyone would ever want him to demonstrate something in python instead of pseudocode. I’d rather just read a book or a transcript of the lecture because it would be more time-efficient. Most of the quiz material isn’t covered in the lectures anyway, so independent study is required to do well. Other reviews mention a very generous curve. I was within the traditional A range without any curve marginally, but I don't think they do generous curves anymore. From what other students said, you should expect them to follow traditional grade cutoffs more closely now. A little bit of wiggle room if you're in - or + territory, but not whole letter differences.

Pros: 1. Low overall time commitment, by far my lowest total hour count of any course in this program (~120 hours total) 2. Good practice with compiler implementation through assignments 3. Cons: 1. Low time commitment is due to unengaging lectures that are not necarry to watch to do well 2. Programming assignment 2 took just under half of the total hours spent on this class 3. Detailed Review: This course is good to get your feet wet on compiler design and implementation basics. However, advacned topics are brushed over in lectures, and not throughly tested in exams -- so difficult to prioritize really learning the advnaced topics given time constraints of concurrent full-time work. I found the lectures to be unhelpful. The programming assignments themsleves were well-written, and Ed discussion was well-attended to by both the professor and TAs, so lecture were not needed for success (also: unlimited GradeScope submissions). The lectures were not needed for the exams, going over the optional weekly assignments was sufficient, in addition to going through the past years' exams that are provided. Because assignments makeup 60% of the grade, and 90% is the cutoff for an A (at least in Spring2024), it is not terribly important to do well on the exams to do well in the course. I spent roughly 120 hours on this course total, with ~80 being dedicated to programming assignments, ~25 being dedicated to studying for the 2 exams (via going through the optional weekly assignments and old exams), and the balance speeding through the lectures. I did spend about 50 hours on the second assignment, which is essentially writing the core of a compiler, stopping just before object-oriented syntax handling. The first and third assignments (first = simple warmup to the "assembly" used in this course, third = adding object-oriented syntax handling) were both extremely manageable. Even though the second assignment took awhile, course materials are relased in 2 batches (beginning-midterm at start, through final released at end of midterm), so there's plenty of time to get it done. Overall, solid course if you want to try writing a relatively simple compiler. This course would be more meanignful if you take the time to self-study the advanced topics touched on in the lecture. Otherwise, extremely manageable on a constrained schedule (work, life, etc.) -- I'd recommend taking this course in the summer, if it is made available.

Pros: 1. Second half is mostly review of the other DS courses 2. Shorter than most other courses 3. LFs/TAs were helpful Cons: 1. Extremely fast paced at the beginning 2. Somewhat strange exam proctoring rules 3. Detailed Review: As many other reviews note, the first two homeworks are the hardest part of this course. I'd recommend reading the first three chapters of the textbook before starting the lectures, and I suggest watching Ben-David's lectures on youtube covering those same chapters. Klivans's lectures were good, but very dense, so supplementing with other sources for the first two homework assignments was needed for me. If you can get past that grind at the beginning it should be smooth sailing for most MSDS students as the second half is mostly review that hits on various topics from other courses. The homework also gets shorter and generally much easier as the course goes along. It is probably a good idea to save this course to the end of your program of work. It is not an introductory course into ML or statistical learning. You can build a foundation in ML by taking the other courses the degree program has to offer first. I took it as my ninth class and pretty much every class that I took before helped me be prepared for ML. As others have noted, it is also a fairly short class (only 8 weeks). I don't believe that schedule changes wether you are taking it in the summer vs the fall or spring. This makes it a pretty ideal summer class to take. The rules for exam taking was kinda strange. You had to record yourself with a webcam and record your screen, which I thought was fine. The exam was open book, BUT you had to print everything out. I ended up printing ~150 pages of notes between the two exams, which just ended up in the recycling bin after I took the test. Felt pretty wasteful and pretty unnecessary since we're recording our screens so it's pretty clear what notes we are looking at. I thought the exams were tough but fair. Average score for both were in the 70's.

Pros: 1. Lectures clear and engaging 2. Material applicable to almost anyone designing or assessing studies that try to prove that something causes something else 3. Assignments were useful to generate deeper understanding of material Cons: 1. Answers to assignments often depended on some obscure detail or were debatably correct. This impacted grades and was a general nuisance 2. R virtually required for some assignments (I couldn't muddle through in Python, though I tried, and my Python's pretty good) 3. Peer grading Detailed Review: Lectures were engaging. I felt I learned a lot and actually understood the material and how it could be relevant in the real world (unlike, say, the regression course). The curve in the end was quite generous - I got an A with an 87% (not sure where the actual cut-off for A/A- ended up being). Would have saved me a lot of heartburn knowing that curve from the beginning. As others have notes, the answers to the graded assignments were nitpicky, debatable, and sometimes incorrect. In many cases, credit was given after the fact for some problems. To be honest, I *liked* thinking about the little details and how they could impact the validity of the study. But the fact that the answers were binary (you're either right or wrong) stinks. For these sorts of problems, I'd rather have free response where I could explain my thinking and have the professor grade me based on how I thought things through. But with the staff:student ratio, that's just not possible. You get what you pay for at $1000/class. Overall though, I really liked the class. I think future students will too if they can avoid fretting too much about their grades. Oh, and you can probably just barely get away without buying the textbook and rely on your fellow students copying necessary extracts into Piazza. I bought it, but if your money is super tight, you might choose this route.

Pros: 1. Good overview of OS 2. Helpful TAs Cons: 1. Moves a bit slow 2. Doesn't cover a ton of advanced topics Detailed Review: The class is overall decent. The professor is knowledgeable and seems to want to teach, but can be extremely dry at times and has some long lectures. The textbook can be helpful if you want more knowledge. The first half of the course felt like more of a review basic intro to OS concepts and the course didn't get into anything all that advanced until the second semester. Projects are doable but not all that interesting. They'll take a bit to do if you're new to C. The xv6 projects will mostly consist of trying to understand the xv6 kernel and trying to find random edge cases that were briefly mentioned in a piazza post. TAs were generally helpful and usually got back in a reasonable amount of time.

Pros: 1. The class goes over a wide range of important topics including Simulation-based Inference 2. There are very good materials and support in this class Cons: 1. The first half of the class was very math notation and proof-heavy 2. The skills built in the class for the statistical software used, StatKey, aren’t very transferrable 3. The textbook is very dense Detailed Review --------------------------------------------------------------- Pros: I was impressed by how many topics were covered in this course. Some people might find the topic load a bit overwhelming, but I thought it was very comprehensive (in terms of frequentist statistics). I also really enjoyed the focus on Simulation-based inference because of how flexible that sort of analysis can be. I hadn’t ever been taught those more modern techniques until this class. The class itself was very organized and I appreciated the effort there. The class provides lots of handouts and lecture notes to reference. The support on edX was also great. When I had trouble, it almost always seemed like someone had mentioned the same exact issue on the discussion boards. The discussion board community was great for this class. I often contributed and was happy to know that others did as well. Cons: The first part of the class was frustrating to me because I had difficulty reading and interpreting the mathematical notation. Even though I learned the material and knew what to do conceptually, the mathematical notation hindered me. In my undergrad program, I didn’t have a big focus on notation or proofs, but that knowledge will definitely help in this course because it isn’t taught explicitly. The course uses a statistical software called Statkey (https://www.lock5stat.com/StatKey/). The software is great for solving problems in this class, but I wished the class would have taught these concepts in R or Python, where I’ll be employing these statistical methods. I suppose I could whip out StatKey in the middle of a team meeting and upload some datasets to get calculations, but it isn’t very convenient or automate-able. I tried to refer to the textbook a few times when I had questions, but I never got very far. The textbook itself is very dense and I didn’t find it helpful. Usually, I just Googled my questions and found YouTube videos about them when I could.

Over the summer, this course is very fast-paced and expects that you come in with a reasonably strong background in linear algebra already. Also, each week the content tends to build on itself, so you need to be really engaged from the very beginning to get the most out of the class. In a non-exam week, I'd typically spend 6-10 hours reading the textbook, watching lecture videos, completing quizzes, and doing the homeworks. Pros: 1. Interesting course content, provides a good intro on practical linear algebra and numerical algorithms 2. Material is relatively self-contained (you don't need to supplement it with many outside sources) Cons: 1. The notation used can be tricky if you haven't dealt with it before. Ask questions on 2. Course staff can be slow to respond on Ed, it's better to ask questions live in office hours 3. Not sold on how useful this course will be in the real world 4. Grading can be harsh and/or ambiguous: expect to be docked points on homeworks/midterms for seemingly small errors, so be careful and double check your work Overall, I'd say you get what you put in when taking this course. If you really want to dive deep into the world of numerical algorithms and linear algebra, you can do that by deeply studying the textbook and doing optional exercises. You can also do the bare minimum work and get by, but you may not actually take away much from the course apart from the Theory credit in this case.

Pros: 1. A fairly comprehensive review of ML methods and their applications. 2. Low work-load and easy to get a good grade. 3. Hands-on examples with Jupyter Notebook to get you started. Cons: 1. No in-depth coverage for any of the specific topics. 2. Reasonable intro but no discussion over state-of-the-art techniques or research oriented discussions. 3. Questionable quiz format, and the final project is too open-ended. Detailed Review: This is an easy class that you can expect to have an overview of ML techniques applications. if you are new to the field and want some inspiration and try hands-on examples, this could be an interesting ride. If you already have an ML background and just wanted to see how advanced techniques are applied, it might not be the best for you. The lectures are recorded by the professor (covering concepts/slides) and the lead TA (covering examples/Jupyter Notebooks). There is no coding projects but you will have an EdX quiz to complete for every two weeks or so. This is 60% of the final grade. The quizzes are easy as the answers are mostly coming directly from the lectures/labs but I don't enjoy the format. Specifically, there are a lot of multiple choice questions for choose-the-only-correct/incorrect where the options are taken from the lecture/lab transcript with some words dropped/twisted. The end result was a proofreading task that it doesn't help you much with understanding the concept but rather forces you to rewatch lecture videos to find the verbatim source and compare. There are also times that the sentences are altered in a way that they become confusing, ambiguous. The TAs seems to be planning/running the quizzes and they are generally reasonable at making corrections though. Overall, the TAs are responsive online and reply timely to Piazza posts. The final project, the rest 40% of the grade, is a 10+ page project report paper for which we were given a MS Word template, where we were instructed to format with 12-pt Times New Roman and 1.5-line spaced. As a regular LaTeX user and having authored and co-authored a few CS conference papers, this came as a surprise. The TAs did later acknowledge that students could use LaTeX as long as they conform to the format requirements as asked on Piazza. In terms of content requirement, the guideline was very broad and no rubric was posted. Project groups up to 3 people each group are allowed, but the TAs noted that the expectation for groups are higher than individual submissions (but again, without clear guidance). I heard that the grading won't be too stringent though.

Pros: 1. General regression topics covered are applicable to a wide range of problems 2. HW assignments and lectures are of reasonable length Cons: 1. Class content is not put into real world context 2. Order of presented material doesn't always flow well week to week 3. The sample code provided in the course is garbage 4. The notes were riddled with errors (first iteration of the course - hopefully non issue in the future) Detailed Review: This course really opened my eyes to the breadth of topics covered in regression and how complex (but useful) this knowledge could be. The professor does a good job of covering a wide range in relatively short amount of time but there are lots of "holes" left to be filled knowledge wise. A lot of "expertise" building though will require extracurricular activity and the course did not provide much in terms of finding resourcing for that. This course will also be a struggle for those who don't have basic programming skills (in either R or python) already developed. The sample codes provided by the lectures lack annotation or clear variable naming and can be hard to follow. This course was very much a "math" course. It does not touch on real world example problems, nor how to select/deploy models in working environments. The course content was very "backloaded" with the 3 last weeks containing the hardest (and probably most useful) content. It was also condensed roughly into 2 weeks during the summer semester. Homework wise - it is a mix of multiple choice and peer grading. This semester had no exams (all HW-based grades). Peer grading could be harsh depending on the competency of your grader. Difficulty wise - this course falls between Probability and Machine-Learning. Piazza got very difficult to navigate as weeks started to overlap. Instructor replies were sometimes useful, and sometimes not.

The course is a basic introduction to android app development, no more no less. The professor's lectures are interesting, but it isn't entirely needed to watch them. The project is broken down into weekly assignments which generally take a few hours to do, and 4 longer projects which usually can be knocked out in a day or two, except for maybe the last one. The administration of the course was a bit fustrating at times, with it taking months to get feedback for grades, but overall a decent course, if you want to learn the basics of android programming.