Distributed Computing

To be honest, getting B on the course might be easy since getting 62% overall alr gives you that.

About the latest review prior to mine, i don't think that the last project only costed 15 hours and you alr got 82%. I spend more than 50 hours, code hundreds to a thousand LOC and only got 72%, given that too many edge cases for different parts that were not initially accounting for, hence may need to redo certain parts. I have 4 years of experience in backend development with Spring, solve a thousand of leetcode problem in java, hence my coding ability in java with the Collection framework is not at the beginner level.

Mid-term and Exam-wise, I think that it depends, you can still study hard but unfortunately get low grade since you may focus on slides, lecture videos while the exam questions focus on the original papers.

In my opinion, you still can get A if you do the bare minimum for programing parts 3 and 4 which are the main culprits for student depression (5%/5% p0 + 10%/10% p1 + 8%/10% p2 + 5%/15% p3 + 5%/15% p4 = 33%/55%) while getting full marks for participation (5%/5%) and full mark for exam (40%/40%) since cut-off for A is 82%.

Regarding the contents, i find the first half useful since it makes you reasoning things well and will sharp your mindset into thinking what failure models you may get into, what should be done to prevent that during your system design/technical discussion. The second-half is more about the case studies and does not leave much impression on me.

I took this course in Fall 2025, and it covered topics I’m genuinely passionate about in distributed systems. I finished the course with an A (88%). Overview The course starts relatively slowly with lectures, followed by Project 0 (intro), Project 1 (client–server), and Project 2 (primary–backup replication). The lecture material is good, and both the required and optional research papers are excellent (long term). Many are still highly relevant in industry today (saved and reading them now after the course :) ). Working knowledge of Java is needed to do well IMO as a good amount of coding/debugging is needed. The real challenge begins with Project 3 (Paxos) and Project 4 (KV Store). IMO, Paxos is the harder of the two. I worked on the projects almost every day, and while demanding, the experience was rewarding. Running tests locally (macos) helps with time and quicker iteration. That said, there are some notable downsides: The DSLabs framework has a steep learning curve. Even by the end of the course, I didn’t feel I fully understood all of its internal workings. Some tests are extremely strict, especially with tight timeouts and DSLabs-specific requirements (e.g., running with --checks for idempotency, checking correct equals() / hashCode() behavior for search tests, etc.). It’s worth noting that passing all tests is not required, and the grading curve helps significantly.

Pros A wealth of high-quality material, especially valuable if you already have experience building software components from the ground up. Project4 reference implementation helps and didn't find it confusing. Well-structured lectures with a great selection of research papers. Exams are easier than AOS, fully objective and with sufficient time. The trade-off: each question carries more weight, so mistakes are costlier.

Cons The test framework for Projects 3 and 4 is rigorous. Must start early and invest time understanding readme.md and DSLabs framework.

Final Thoughts Overall, this is a strong and rewarding course for students interested in distributed systems, especially those who enjoy both theory and hands-on implementation. If you’re willing to commit time consistently and don’t get discouraged by test failures, you’ll learn a lot.

That said, I think the course could benefit from leaning more clearly toward either learning (theory) or implementation, rather than straddling both as heavily as it currently does.

FYI this review is actually for Fall 2025, but it won't let me select that as an option.

To be honest I was a little disappointed in this class. The lectures seemed not as good as other classes I took like AOS, HPC, and HPCA. But I think it does give really good foundational principles for the theory before distributed consensus and the architecture of cloud systems. The projects teach you PAXOS really well, but I feel like they are almost to heavily focused on PAXOS. The last project didn't seem useful for learning. It was essentially redoing parts of the last 2 projects, but was easier this time because you had already done them and knew how to debug them. But it still took like 40 hours.

There is a curve, but they don't announce it. I had a 85% and got an A. You can easily get a B in this class doing ~10 hours a week. The last 3 projects take a lot of time, but only if you are trying to achieve an A or 100% on them. To get a B on them is relatively easy. For example I had ~82% on the last project within ~15 hours of coding. I spent another ~20 hours debugging (and found and fixed a lot of bugs!), but my grade didn't change. I didn't pass any additional tests I just got closer to passing them.

The midterm was easy I got a 87% only studying ~5 hours. The final I got a 67% doing about the same.

I was disappointed in the tests too. I felt like a lot of questions were vague and ambiguous. They don't give any feedback so you don't know what you got wrong or why. They don't really provide any structure to let you know what they think is important in the lectures. For example AOS gives questions to answer for every reading and nearly every other class had quizzes throughout the lecture to make sure you understood core principles. DC just has a lecture and you take a test. No notes, no suggestions of what you should know. It's really odd.

In general my new job is working on a distrusted system and starting to work for designing towards cloud infrastructure and this class helped with the learning the foundational principles so I'd still recommend it. Maybe a 3.8/5. But I think with some small improvements it could get to like a 4.6/5. I don't think this was a good of a class as AOS or HPC. It's also not as difficult as HPC at all. It really isn't an academically challenging class, the projects just take time.

This is undoubtedly the hardest course in the program. A generous curve helps quite a bit.

Projects

The star of the course. They were revamped over Summer 2024 and the course framework is much closer to the publicly available implementation. This makes a student's life much easier. There are still a few tests where the Gradescope configuration is slightly different than the local one. So they fail on Gradescope but pass locally.You have no idea why they fail and the only feedback is something vague along the lines of "optimize the implementation." It's annoying for a completionist type of person. But at least the test score distribution is much more forgiving than what's publicly available.

If you don't have a working implementation of Paxos, you are going to have a hard time on the final project. The TAs did provide some kind of black box version of Paxos so you can try to focus on the distributed KV store, but it had tons of kinks.

Lectures

They are super dense and packed with a lot of information. To get the best value, you should at least scan the accompanying papers. The subject is challenging and IMO the professor has done an excellent job of covering a wide variety of topics. No set of lectures are going to be perfect for all students and I would have loved for some other topics to be covered in place of what's in the material. I found the MIT 6.824: Distributed Systems lectures very helpful, especially on Replication, Raft, and Distributed Transactions - which is what the projects are based on.

Exams

They are pretty weird. I didn't really know how I performed. In one, I ended up doing way better than I expected, and in another I did way worse. I don't think there was a substantial difference in my level of preparation and understanding of the topics. There's always going to be an issue with multiple choice questions where you can't elaborate your thinking, especially in a topic as complex as Distributed Systems.

TAs

There were one project-led office hours for each course. They answered a few questions on Piazza, but otherwise not very involved.

P.S. The mods on /r/OMSCS are some of the stupidest people on planet. Unbelievably low IQ morons who cannot read English.

This class is brutal, but also extremely fun. I got a B in the class (only B so far) but that was because I had to move during a weekend of one of the assignments and didn't have time to fully do the assignment (bad time management on my part). The theory/lectures are actually pretty easy to follow but the assignments get exponentially harder.

Assignment 1: 3 hours Assignment 2: 8 hours Assignment 3: ~40-60 hours Assignment 4: 80+ hours

Wasn't able to get perfect on assignment 3 or 4 ~75% each project. Had I gotten perfect on assignment 2, I would've gotten an A. Very easy to get a B, still very possible to get an A. Put 15 hours/week because I probably spent ~15-20 hours on the lecture materials throughout the entire semester.

I really enjoyed this course. It was the hardest class I’ve taken, but also my favorite. Coming from an ML background, distributed systems were entirely new to me, so I found each lab consistently challenging—except for Project 4, which stood out the most. That project brings together everything from the previous assignments and builds on it. Getting all the components to work together smoothly was a nightmare at times, but incredibly rewarding when it finally came together.

Project 3’s Multi-Paxos was particularly interesting. If you can correctly implement Multi-Paxos, you can definitely implement Raft—a more common and arguably simpler consensus algorithm that achieves the same goal but streamlines several components.

Project 4, which deals with horizontal partitioning and balancing shards across groups, was also fascinating, though it involved a ton of coding.

This course made me a much better debugger. It taught me that my first instinct is often wrong, and the real bug is usually in a completely different part of the system than I expected. That’s just the nature of distributed systems.

It also showed me how deceptively simple distributed systems concepts can seem in theory—but implementing them well is a completely different beast.

Pro tip: Learn how to use the visual debugger early. It’s a super useful tool for Projects 2–4. I didn’t really start using it until Project 3, but wow—it made catching bugs so much faster than digging through logs or stepping through a traditional debugger. It’s not something you’d typically have in a real-world system, but it’s an amazing teaching tool that helps highlight where and how things can go wrong.

Lastly, this class is hard but totally doable if you’re willing to put in the time. You’ll often find yourself spending hours making sequence diagrams to track down where your implementation went off course—and those hours are worth it. They’ll save you many more hours of aimless debugging. This class rewards planning and modeling your system up front, unlike others where you can just code and fix things as you go.

I come from a non-CS background and honestly, this course is NOT as hard as people make it out to be. I thought it was gonna be hell, but I handled it fine while also taking SDCC and still had lots of free time during the week. No, I'm not some exceptional student (still super early in my CS career), the difficulty is just way overrated. Labs honestly get easier over time. You just have MORE to implement with each one, but as you will see, the patterns are exactly the same.

My takeaways for future students:

1. Your biggest tools: Read all the tips and advice from the DSLabs slides + Learn to maximize the visual debugger. If you get comfortable with that, the difficulty and stress of this course basically gets cut in half.

2. Master the fundamentals: The sooner you can wrap your head around idempotency, deduplication, and AMO/ALO semantics, the sooner the protocols start feeling repetitive and much easier.

3. Time management: Obvious one, but still worth saying. You get a LOT of time for the labs, and the exams are open-book and mostly multiple choice. Pace yourself and you'll be totally fine.

I’m on track to getting an A in this course. The midterm and final exams are open-notes with provided lecture slides and paper readings, which makes them manageable.

In Fall 2024 semester, they allowed students to work with a partner for lab 4 to help with the workload, but I chose not to.

I found this course more challenging than Compilers, which primarily focuses on correctness. DC requires attention to both correctness and performance, especially in labs 2-4. Strong system design is crucial to passing the autograder tests.

Workload-wise, this course is about twice as demanding as GIOS. While GIOS assignments took me 2-3 days each, labs 3-4 in DC required 1.5-2 weeks each to complete as a full-time student. Labs 0-1 took only a few hours, and lab 2 took a few days.

I’ve marked this as 1 hour/week to counter exaggerated claims of 100 hours/week. I realistically spent 20-25 hours per week, especially in the second half of the course.

This was a very difficult course and I struggled on the projects. Despite that, it was extremely rewarding. It opens your eyes to the world of distributed computing and gives an idea of why it can be so challenging.

Yes, the projects are hard. But the grading definitely compensates for this. For projects 1-3, it is very doable to get full points. For project 4 and 5, with some effort, it is possible to get at least 50 - 60 percent of the total points. Exams are fair, TAs are helpful and there is a lot of student collaboration on the Slack channels.

I put in close to 20-25 hours per week since I had a lot of other constraints. You get what you put into this course. 20 hours a week was more than enough to get a high B. I can understand that putting in 25-30 hours might be required to get an A. Even experienced developers will have a hard time with this course. The more you put in, the more you get out of this course.

At the very least, I understand why the major software big-tech companies want applicants to have this knowledge. I would highly recommend this course.

One feedback is that the lectures could have been better. The lecture content is very vast and pertinent to the course, what can improve is the way in which it is presented. Courses like GIOS, AOS, HPCA and HPC set the bar really high for quality lecture content. I felt this course missed the mark slightly.