Grade distributions are collected using data from the UCLA Registrar’s Office.
This course is a *MUST* for anybody who is considering a career in handling systems of scale. The course gives a beautiful peek into the discipline of distributing computing across several machines which is a reality today for almost every service globally. It gives an understanding of the different protocols, mechanisms, principles that go into designing production systems. Many of the decisions that are taken in systems are based on trade-offs, resources at hand and there is no unique answer to all the problems which is where this course proves its might.
The assignments make the students very well prepared for real projects one would be doing. Assignments are very easy once you spend time on understanding the material clearly and analyzing different decisions that are taken and scenarios that can occur during execution. I personally found the slides, class and the examples really helpful in being able to visualize and understand different scenarios that occur in distributed systems. A proper reading will give completely clear way to solve every assignment in the class. While the complexity increases as the assignments progress, it's a matter of being able to understanding that anything can fail at any time.
Assignment 1 is very easy and gives an intro to go language which is to be done solo. Assignment 2-4 are to be done with a partner/solo and require understanding the protocols clearly from the class. I can see how they can get confusing if the material is not understood properly, but otherwise they should be pretty comfortably solved.
Professor Netravali is probably one of the best in terms of conveying the various principles that go into designing distributed systems. Rather than just saying that this is the protocol and this is how it works, he actually spends time on explaining why we need different protocols and what sort of situations demand what trade-offs. I personally found him to be very helpful in clarifying any doubts and explaining some concepts in more detail. TAs could have been better, but given the pandemic and online classes, I understand that it's hard to find good candidates specifically for a course like this which needs very clear understanding. Regardless, the professor did an awesome job in helping the students and accommodating things for us during this time.
Overall I think this design is very good in terms of understanding distributed systems and actually building them with the assignments. But be prepared to spend time understanding the concepts so everything will be smooth as butter!
Professor Netravali is a really intelligent and engaging professor. His lecture slides are clear and his presentations were very effective and to the point, not wasting your time with unnecessary fluff. He is passionate about what he teaches, and it's a shame he won't be teaching this course again for a while (due to research he's doing).
The projects do need to be refined, though. The later projects are very difficult and ambiguous in various ways, and the translation from what's on the lecture slides to the assignment implementation is a bit rough. Understanding the concepts in the lectures, like Paxos, don't translate to immediate knowledge of it in code, and I felt like the discussion sections were not very helpful in that regard.
Plus, they are deceptively difficult. You will read at the bottom of the spec that full credit will be given if all test cases in the code are passed. Seems simple, right? Well, turns out it's a lot more complicated. Just understanding those test cases, how they work, and how to make your code work with them is a challenge in and of itself. But you also have to pass those test cases consistently; each test case is tested 5 times during grading, and you lose almost half credit for a test case if it doesn't pass once out of those five times. This can be a problem if you have a slight mutex locking error (like I did) that means you pass almost every time when you test it, but not when the TA tests it. It was an important learning experience for me, I think, but it was nonetheless far from ideal, and the project spec could have been a bit less ambiguous about how to search for errors like this.
I don't know about other students, but I personally found the single exam for this course (midterm in week 8, no final) to be a bit stressful and difficult. Considering we didn't have any practice questions to work with beforehand, anticipating what would be on the exam was a bit hard, and the exam turned out to be much more difficult than I expected.
Overall, Netravali is a great professor, and you'll learn a lot, but be prepared to work hard and deal with a somewhat frustrating learning curve. The midterm and last few projects are nothing to scoff at.
I took this class during Spring quarter of 2020, so the class was entirely online. Overall, I felt that the course material is interesting, but there are some flaws with the actual execution of the course, as one would expect from a brand-new class like this one.
The class has 4 main projects (done in Go) and a single midterm (week 8); there are no other homework assignments. The first project is a solo starter project, but 2 through 4 are partner projects (or you can choose to do these alone as well) in which you implement a key-value store using several different distributed system schemes.
Project 1 is fairly simple, but 2 through 4 all take a significant amount of time. What's worse, the spec is generally a bit vague, and while you are supplied with the test cases that will be used to grade your submission, trying to understand them is brutal. They look a bit like the code you're taught not to write in CS 31; there are no comments anywhere, the variable names are a bunch of seemingly-random letters and numbers, and the code is impossible to decipher. It's a bit of a shame, since the idea behind the projects is very interesting. I really wanted to enjoy them, but I spent far too much time pulling my hair out while trying to figure out why my code failed a particular test case 5% of the time.
While I was able to get full credit on all the projects, beware that part of your Project 3 implementation is used for Project 4; that is, if you don't get full credit on the former, you likely won't on the latter either. This is a bummer since each of these is worth 20% of your grade.
Since this quarter was entirely online, it was a bit more difficult than usual to seek help with course material or projects. There was a class Piazza page, and the professor and each of the TAs had virtual office hours. Personally, I found the Piazza page to be generally unhelpful, as every question I asked would either not get a response at all, or I'd get a very ambiguous answer.
Personally, I did not find it useful to attend discussion, so I stopped attending after a few weeks.
The class lectures are quite good. The professor's slides, while a bit difficult to decipher without watching the lecture video, are clear if you have watched the video. They always contain useful examples of the concepts being covered, and overall I really enjoyed the course lectures.
The midterm is the only exam in this class (that's right; there is no final). It's a very late midterm (week 8) so it covers a lot of material, but the plus side is that everything after the midterm is case studies which are interesting and obviously won't be on an exam. Overall I found the midterm to be pretty decent in gauging my overall knowledge. The professor was kind enough to give us several hours more than the original 2 hours allotted for it, and I thought it was an interesting exam to take.
Overall, I would say I enjoyed this class. I thought the class lectures and midterm exam were fair, and while I enjoyed working on the projects, I really did not enjoy spending hours debugging my code due to the cryptic test cases. While I found that getting help was difficult in this class, I think it's not the fault of the professor or the TAs as we all adapt to this online learning scheme. I'm sure the class will only continue to improve as it is offered more times in the future, so I'd recommend it.
This is one of the best courses to take at UCLA if you're interested in learning how real systems deployed in large companies work at scale. You learn quite a few concepts that have real-world applications, and might even give you a step up in cracking systems design interviews at tech companies.
Prof Netravali is extremely patient and has a knack for explaining hard concepts in an approachable manner. The assignments need to be taken seriously, and starting to work on them at the last minute is a bad idea. However, listening to the lectures is sufficient to get through the myriad challenges (there are quite a few) you'll encounter when solving the assignments.
Overall, this was a really fun course, and I would recommend this to anyone who wishes to learn valuable knowledge that'll stay with you for a long time.
CS 143 with Professor Netravali was my favorite CS class that I've taken at UCLA. Despite the remote circumstances, things went very smoothly. The assignments were quite difficult but accomplishable. It was clear that Professor Netravali's highest priority is ensuring that his students are really learning (and I learned a ton).
The first 7 weeks or so are focused on theory, e.g. Lamport clocks and Paxos (Paxos is a critical topic). The last 3 weeks ish are focused on case studies of real life distributed systems such as Amazon Dynamo, Google Spanner, Microsoft Azure Storage, and several others. There is one exam which was in week 8 but no final exam, and it was fair and on-topic.
I feel well-prepared to go into industry in this field and to read academic papers on the topics we discussed as well as others/The lectures are very organized and useful. I would highly recommend taking this course if you are interested in the subject. It is a good class to take senior year or late junior year in undergrad. If you do take it though, beware of the time commitment of the assignments; they pushed me to my limits even when working with a partner.
Best Computer Science class I've taken at UCLA, with a genuinely passionate Professor who cares about students understanding the concepts, and honestly probably going to be one of the most applicable classes to industry (I've heard this from upperclassmen who've taken this course too).
The projects in the class are really interesting and extremely relevant to what's being addressed in the course material. They really require you to think in depth about your designs in order to understand why you might fail test cases. They're fair in that all the test cases your submission will be tested on are given to you directly (however the test cases are nondeterministic, so you have to really understand your design and the purpose of the test cases). The median for most projects was 100, but quite a few people struggled with Project 4 since it was extremely open ended without as much guidance as previous projects. Projects 2-4 you can do with a partner (has to be the same partner for all 3 projects), but Project 1 is individual - a MapReduce assignment designed to familiarize you with GoLang. I won't lie I probably had the toughest time with Project 1 even though it's meant to be the easiest, just because I wasn't used to Go yet.
The exam was also pretty fair in all honesty (I ended up doing not so hot due to misreading a question), but Professor Ravi took the time to individually address incorrect answers to correct individual misconceptions. You can really see how much he cares about the students understanding the concepts.
TA Discussions/Office Hours for the class weren't super helpful, but all the instructors were really responsive on Piazza. 'd definitely reccommend going to Ravi's Office Hours - he takes a lot of time to make sure any misconceptions or confusions you have are cleared.
Case studies in class were really interesting too, talking about mechanisms and systems in popular use today (MapReduce, PAXOS, AWS Dynamo, Azure Storage, Google Spanner).
Did this review contain...
Thank you for the report!
We'll look into this shortly.