This review and course summary was taken from the foreword of my AOS course study packet, available on Apple Books (https://books.apple.com/us/book/advanced-operating-systems/id6799153989) and Amazon (https://www.amazon.com/gp/product/B0HDK5CCCJ?storeType=ebooks&sr=8-1):

This study guide consists of my notes for the upper-level Georgia Tech graduate school course entitled “Advanced Operating Systems” (AOS). The motivation for compiling, editing, and publishing these notes was primarily to pass the course; a little more than half the class (over 300 students enroll per semester!) currently receives an A or B each semester, with a B as the minimum grade required if in the Computing Systems specialization, which I am. The notes were synergistic with my coursework; I was able to get an A thanks to these notes, along with dedicated efforts on projects. The proof is in the pudding; I started these notes a month and a half early in the summer before I started the class, due to the large span of material covered in the course, and was able to get an average, passing grade on the first exam (of three) by only reviewing these notes for the topics covered over the course of four days before the exam. The latter two exams took about 10 days to prepare for and get A's on, with other activities going on. The exam format should be discussed in some detail to add context to the utility and purpose of these notes – there are three open-notes, open-internet, open-forum discussion (yes, you can ask and post questions to other students about the exam questions during the three-day exam period) spaced evenly throughout the AOS course. Each exam has questions posted before a weekend, then the students have two days to prepare their answers and a third day to “fill out the form” in the space of an approximately two-hour, proctored “exam” session. The final exam for this course, with an average amount of questions and points, required 5 pages of notes and writing to address all the questions adequately, amounting to a keyboard and memory performance during the exam session. These open-ended, short answer exams are notorious and widely considered the worst part of the class, requiring looking up trivia and facts and logical reasoning based on 48 papers throughout the span of the course. So this relatively concise note packet should serve as a supplement to the lectures and papers, enhancing understanding and making the studying, review, and lookup process that much easier. Recover hope, all ye who enter here – the notes packet and the course are finite, regardless of how they seem on the outset. Good luck! I’ll be waiting for you on the other side!

For more information, check out my Summer 2026 update video! https://www.youtube.com/watch?v=5ZJ4rllLG7o

Lots of content and a nonstop schedule. I wouldn't say the content is difficult, but I've taken GIOS and HPCA and without those two it might feel more challenging.

What I struggled with in this class is that the schedule often has overlap between projects and exams. This of course is not a problem if you can finish projects long before the deadline. This was my goal going in, but unfortunately I was never able to finish projects earlier than the weekend of the due date even when starting early. I did choose to work solo on all so ymmv.

Prioritize projects first, then lectures, then papers. I found lectures tedious and watched them at 1.5x. I only read papers for the reviews and to build answers for the exams. I did not realize that students could discuss exam answers on ed discussion until right before I took test 2. I learned more having to write all the answers without other input for tests 1 & 2, but in reading student discussions it made it a lot easier to locate important sections in the relevant papers for questions.

As far as content, I think the actual systems learned are not that important, but provide critical thinking about how engineers tried to solve existing problems and why their solutions were or often were not effective or used in the long term. People might think this is not useful, but I think this is extremely critical. If you are involved on the frontline of thinking about system development, you need to be able to identify problems, come up with solutions, and consider how your solution might fail or be ineffective. The fact that these are older systems/papers from the 80s/90s is irrelevant, it is the design process that is important. If you try to memorize a bunch of facts about these old systems, then you are not getting the most out of this course.

I struggled with burnout throughout the semester, but my final grade is an A. If you are able to push through the endless content and prioritize well, you will get a B or higher.

I come from a CS background and work as a software engineer with ~3 years of experience

I found the content in this course to be a bit of a letdown. The expectation is for you to read a lot of papers, so the lecture material is fairly high level. I found that a lot of this course covers topics from papers in the 80s and 90s, and even though I'm sure these are super important papers, it felt too much like a history lesson for me to care. There are some interesting topics however, especially towards the end of the course.

The projects were difficult but rewarding, and as long as you have a decent coding background, I didn't find any of them super challenging. However, I did start early on all of them. The last one especially would have been super difficult if you procrastinated.

The exams were pretty easy - the majority of the exam questions are released beforehand so it's fairly hard to perform poorly on them in my opinion.

Overall a decent course if you want to better understand the history of some of the design decisions taken by early OS architects. However, if you want to understand modern operating system concepts, I think this course is a waste of time.

Fall 2025 - Good course overall, Professor Kishore has a lot of passion for the topics which I think rub off on students. There is a weekly zoom call which students can join and take part in polls for extra credit.

I also had good experiences with the TAs.

I enjoyed the projects the most, the second one required writing a paper which took the most time. The 1st and 4th took around the same amount of time. While the 3rd was the shortest.

1st and 4th project - about 40 hours. 3rd project - about 25 hours 2nd project - about 60 hours, mostly due to me wanting to write a very good paper, which might not have been necessary

I think the lecture content is a bit too long. But as other students said some time can be saved by not reading the papers. 80% of the questions are released ahead of time and usually. If a question doesn't get covered in the lecture it will usually be found either in a paper quickly using CTRL+F, or in a hangout session which was previously recorded.

Even with 80% questions released there is only 3 days to answer these questions. So some studying is still required to have a general idea of where to look for an answer. There is collaboration between students for the test answers, usually if a question has a big consensus it's probably the correct answer. For other questions with a variety of answers trust your own answer you found from the material.

(Fall 2025) Solid class. The first portion felt like a review of GIOS/HPCA, and the rest of the course was an overview of OS techniques/innovations presented through academic papers. It improved my system design ability, especially for distributed systems.

The lectures were easy to follow and engaging. Kishore is a great professor. If you have the time to go to the hangouts with him, I found it useful to reinforce lecture topics (plus extra credit points).

The projects were good. My ranking of difficulty (hardest to easiest) is P4 > P1 >> P2 > P3. P4 and P1 took a significant chunk of time while P2 and P3 could be done in a couple days. P1 you build a CPU scheduler/memory manager using libvirt, P2 you implement some barrier algorithms and write a report on their performance, P3 is a introduction/review of asyncronous gRPC, and P4 you implement MapReduce using gRPC. There is an option to work with a partner. I did not and don't think a partner is necessary. The projects are long (esp. P1/P4), but IMO not so long as to require a partner. Doing them solo also helped my learning/programming ability. Getting help on the projects is done through Ed, and it was mostly students helping other students, not TAs helping students like GIOS.

I did not like the exam format. 80% of the questions are released ahead of time on Friday night and the exam is due Monday at midnight. Students can collaborate on the answers to these 80% of released questions. I felt like the exam format encouraged memorizing answers to the 80% of released questions and crossing your fingers for the other 20%. They are also all open response questions so you can't BS an answer you don't know. The exams get easier as the semester continues.

I think the difficulty of this course is overstated. There are really only 4 papers required for the projects/assignments (2 for P2 and P4, and 2 for the paper summaries). There are 90+ papers - reading them all is not a good use of time when the lectures/hangouts review them enough. I was able to pair this course with CN while working full time.

Hardest course I've taken thus far of: GIOS, AOS, SAT, SDCC (yes, the one after this one. The hardest parts of SDCC are definitely harder than AOS, but the average week of AOS was much more than the average week of SDCC). The reason being it's just a ridiculous + consistent amount of content you need to be on top of if you want to maximize the material: multiple research papers per week, projects, lectures, and then tests.

Project 1 and 4 were hard, project 2 was not really hard but it was kinda tedious (so it will take some time), and then project 3 was easy, more like a primer for project 4. If you respect project 4 and really give it a go before the last week/2 weeks, you'll end up fine.

Tough course, Definitely front heavy but the pace slows as course reaches the end. Hang outs are good to summarize the lessons. Stay consistent and put the time in. If you can get past project 1 and exam 1 comfortably. Continue that effort and.. that is it.

Good TAs, Good Course.

In terms of difficulty: DC > Compilers > AOS > HPC > GIOS

DC: Easy to test your code with the DSLabs framework, but Paxos/Raft/sharded KV store is much more conceptually complex to implement than MapReduce in AOS.

Compilers: Concepts are easier to understand than in AOS (don't need to read academic papers) but it's a lot more effort to implement a 5K+ line of code compiler from scratch.

HPC: Concepts are more theoretical and complex to understand, but the grading is really generous.

GIOS: Easier than AOS, in both conceptual understanding and project size.

Background:

• 5th course in the program. Have taken GIOS, SAT, AI4R, CN with A grades
• non-CS engineering degree for undergrad
• work as a devops eng

Time: hw0: 5hr prelab: 5hr lectures: 33hr papers: 18hr; included the 2 paper summaries, as well as reading other papers that sounded interesting, like Lamport clocks, Xen, and Dynamo, as well the MR paper for P4 exams: 46hr; includes time to take the exams, as well as study and prep time P1: 60hr P2: 38hr P3: 20hr P4: 92 hr

Experience of the course: Challenging course, with interesting projects, but didn't give the satisfaction that GIOS did. Spent way too much time with a stupid hidden bug for P4 that ended up leaving me feel burnt out by the end of the course. There was a small period (2-3 weeks) of lull during P3, which had the lightest load and also did not have any exams. Otherwise, the rest of the time felt immensely stressful. This course convinced me that, although it was my ultimate goal for OMSCS, I probably cannot handle the time commitment of SDCC, along with my other commitments in life. Course administration was ok, but could have been improved by adding small but important details into the project descriptions instead of addressing it later in an edstem post. I had heard of Prof Kishore's enthusiasm, but unfortunately, could never make the weekly hangout.

Overall, the course teaches a lot. The focus tends to be on expanding from introductory OS topics like virtual memory, scheduling, and parallel processing into using those topics in a distributed computing environment. The projects can take quite a bit of time, but they are valuable learning. There will not be much handling in learning how to use the APIs for the tools that are used. Be prepared to read through the documentation and learn them for yourself.

All in all, I enjoyed the course and finished with a low A.

Some context: Non-CS background (business undergrad), previously took GIOS, GA and CN. I have a family so I avoid studying on weekends (except for exam week), so most of my studies are done on weekdays. I managed to score above 97 overall for an A.

As with other GT courses, do not come in expecting the theoretical content to be state of the art. Rather, the content taught is meant to be foundational. I.e Lectures and papers are from decades back (circa 1980s).

I personally found the content really interesting as I always believe in learning from first principles. Having a good understanding of the foundations will likely help in understanding how the more modern advance stuffs came about.

To balance things up, the projects deals with more modern concepts such as Virtualization, Distributed Computing, gRPC and MapReduce. I won't touch on the content of the projects as there are ample of reviews that covered those. What I can say is - the projects alone made AOS worth it for me. I did every project alone and as a result I felt that it made me a better engineer overall. So i actually recommended doing the projects solo if possible.

Grades are largely made up of two components: Exams (~42%) and Projects (~48%). The other 10% include stuffs like Pre-lab, Homework, Ed participation, Paper summaries and attendance for weekly "tutorial" (aka hangout).

Exams seems to be the Achilles heel for majority of the student. I did relatively well for the exams and here's my suggestions:

1. Watch (and re-watch) the lectures until you really understand the concept being discussed. Take notes as it will help with revision.
2. Attend/watch the hangout for the quizzes and extra information that Kishore will sometimes share.
3. Attempt the exam questions when released and compare it with what others have shared. I actually learn quite a lot from other classmate answers.
4. If you still have time, look through the previous exam questions.

I actually did not read much papers at all. Yes there are like 46(?) of them, but i only read a couple of them. My advice is to read only if you're interested (which you should select for the paper summaries) but not to prep for the exam.

I also personally find the marking of the exam to be "lenient"; in the sense that they are not looking for certain keywords or format (unlike a certain course) but rather if your answer displays the correct understanding it will be awarded marks accordingly.

Overall, a solid course which projects alone are worth it. It does take a fair bit of time (especially exam weekend) but still manageable if you're consistent with your work. I have to emphasize consistency is the key, as I can't imagine cramming all those concepts right before an exam.

I did not really learn anything useful in this class. The course content is very boring and dry. The instructor Kishore has spent his entire career in academia and none in industry, and you can really tell by the course material because it is entirely focused on old 30-40 year old operating systems that he studied or worked on when he was a PhD student.

For example, the unit about Security - it started by teaching us Salzer's principles of OS security, which was relevant and interesting. Then, we spend the rest of the unit learning about Andrew operating system, something which was developed in 1988 and has zero bearing and relevance in modern life. It seems we learned about Andrew to try to demonstrate some of Salzer's principles, but I surely there are more modern examples to pull from that actually feel relevant to modern state of the industry.

There is not even a textbook for the course - instead, you're just supposed to read academic research papers on the same 30-40 year old operating systems.

Then the exams are very difficult, asking you super specific questions about the implementations of these old operating systems. It felt like I was taking a History of Operating System class, and not actual relevant details of modern problems and concerns in modern operating systems. I went into the class expecting to learn about how Windows Server or Unix Server handles problems of user security, not how Andrew Operating System from CMU in 1988 handled problems of user security.

The projects were fun and interesting and build off of things learned from GIOS 6200, so they were a high point of the class.

The exams are closed notes, 2 hr time limit. 80% of the exam questions are released ahead of time to you though, so you can study those. BUT, you have only a 72 hour window to take the exam, and the exam questions are released to you at the beginning of the 72 hour window, so you cannot prepare in advance for the exam - so instead, you will spend the weekend cramming to study the 80%, then wait until the last minute to take the exam.

If you are anything like me, you'll breeze through the projects and have fun with them, then slog and struggle through the course material trying to prep for the exams. I struggled to stay awake through the lecture videos of Kishore going and on and on about obscure academic operating systems from the 1980s.

If you're somebody who's trying to get a career in academia and wants to work on operating systems as part of a PhD thesis or something, then this course would be a great fit for you. If you're just somebody who works in the industry and wants the master's degree to help advance your career, this course is not a good use of your time.

I have mixed feelings about this course.

The TAs are pretty bad. They are close to absent from Ed Stem. It would have been nice if there was a disclaimer saying "There will be no TA support in this course." With a topic as interesting as Operating Systems, I would have expected some level of interaction from the TAs. But there was none. Zilch. Nada. Only some bare bones comments from time to time. I've been a TA in my past life and I would be ashamed if I were in any one of their places.

To top it off, the first assignment is awful I went into it thinking "Hey if I get my basics and algorithm right I'll be fine." Unfortunately these morons have < 75 IQ and can only grade based on graphs, not code. I lost a lot of points in it without any fault of mine at all. In the end I did manage to secure an A but only because I had a lot of anxiety and I over-prepared for the exams.

This course isn't going to teach you anything about diving deep into an operating system. A more appropriate name would be "Survey of Systems-related topics fro last three decades."

That being said, it's hard to judge the value of such a course immediately after you take it. The benefits are a bit more long-term. If you took GIOS, you may remember the adage "every problem in computer science can be solved by adding another level of indirection." This course really reinforces that. I enjoyed reading most papers, if not all.

I want to take SDCC eventually and was even looking forward to it. But if the same shithead TAs and the level of commitment from them exists over there, I wouldn't be too happy.

Instead of talking about the mechanics of the course, I am just going to talk about succeeding in this class.

I think the difficulty of this course is overblown. It's ~3.5/5.0. The exams are easier than GIOS and the difficulty of the projects is also less than GIOS.

This is a time intensive course. On average the time commitment may be about the same as GIOS, but it is less consistent week to week. Particularly on exam weekends, you will need to devote a lot of time to the class. Therefore, it is important to efficiently utilize your time.

Ways to save time

*Don't attend hangouts: * I attended the weekly hangouts, but got nothing out of them, and I recommend forgoing the 0.5 bonus points. If you have watched the lectures, the hangout is useless, just a rehash of the lecture. If you didn't watch the lectures, you have no idea what's going on, and your time would be better served watching the lectures. The slides released from the hangouts are useful, but they are freely available.

*Don't work with a partner: * I did, and I don't recommend it. None of the projects were very large. The features that need to be completed were small, and working with a partner just adds overhead due to the granularity of tasks. At best with a good partner and can work 20% faster. At worst you get a crap partner and wish you worked alone. My partner was fine but would sleep on PRs >24h which probably brought the benefit to 0%. It's also really hard to pick a partner, it's not like a live class where you have an idea what people are like.

*Only read papers you must: * If a pre-released exam question is not covered by the lectures (and 90% of them are) sure, skim the paper. For two projects you also need to read papers. Other than that, don't prioritize it. IMO reading the papers does not add a great deal of benefit to the course. The lectures summarized the core ideas of the papers, this is the value of the course. If you have time, go for it--or better yet, just reading papers that interest you. Some of the papers in this class are pretty esoteric (with a heavy bias to Kishore's research).

Other thoughts:

*First homework: * This is IMO the most important assignment of the class. Although it is only worth a few points, this provides a preview of an exam. If you took the homework, memorized it and retyped it from memory, that would be an exam. Treat the homework like exam 0, and pay attention to how it is graded.

*Exams: * Think for yourself. Usually there is a collaboration document, it can be wrong. Come up with your own answers and check against the collab document for obvious mistakes. If you believe in your answers and they differ from the collab document, go with them, paste them in the document and move on. It is a lot easier to memorize answers that you came up with and are your words.

*Lecture Notes: * My notes were verbose and comprehensive. Don't think of your notes as something you have to memorize for the exam, think of them as a reference for the class. When the exam is released you can look through your notes and find little details instead of wasting time re-watching lectures. When doing the exam pre-release if clarification from the videos is required, it will be easy to know exactly what to re-watch based on your notes.

*One time extension: * Don't use it unless you absolutely have to. The class moves fast, if you need it, you're already dead.

Overall I enjoyed the class, but think it doesn't deserve its reputation. The exams were more straightforward than GIOS and overall, the class is very reasonable. The teaching team is pretty hands off, but also super chill about things; you don't feel like you are walking between landmines like you do with instructional staff from other classes. I'd take this class again.

Why listen to me? I'm waiting on final grades but could get a 50 on the last exam and get an A. (P.S. Spring 2024)

Note for those looking: In Fall 2023 there was no curve at all, 90+ was an A (though they did round up).

I think the tests have gotten progressively easier which has allowed them to do away with the curve, so keep that in mind during the course.

I really wanted to like this class more than I actually did, because it has so much potential and is uniquely interesting compared to any other class I've taken. It has the most involved OMSCS instructor by a country mile who is not only extremely knowledgeable, but genuine and passionate about the content he teaches. I rate the difficulty a 4/5 because of the amount of assigned readings and exams that consume your entire weekend, but honestly I think most of the pressure and stress was self-induced because I took every aspect of the class so seriously when in retrospect I didn't need to. I rate the course itself a 2/5 not barely of the content and assignments and moreso because I think there are significant improvements on how the course is logistically run.

NOTE: I did everything alone, but I think you can work with a partner for projects 2, 3, and 4. Perhaps me going solo has affected the way I have rated the class.

Pros:

• I love professor Kishore
• Many of the concepts you're exposed to are interesting thought experiments, and the content in general is fun to think about
• The coding assignments are engaging
• Extra credit (showing up to synchronous lectures/summaries, and CIOS completion dependent on how many students complete it)

Cons:

• TAs are not active on Ed, most of our questions were answered by another student (shoutout to him, a big W)
• Sometimes the synchronous lectures would go past 8, which isn't mentioned in the syllabus
• While 80% the exam questions are released during the weekend of an exam beforehand, they didn't actually release it at the said time of 11:59 PM EST (for exams 1,2, and 3 they released them ~2 hours late, 15 minutes late, and 30 minutes late respectively, so just anticipate that if you plan on staying up late to see the questions like me)
• Exams feel like memorization sometimes While I expect some ambiguity with projects, I felt like assignments had a little too much of that and in combination with the lack of TA action on Ed made this worse (there were incorrect instructions in assignment 2 and no support for the setup in project 3 - the provided files didn't even build unless you made modifications to them unrelated to the project).

Tips:

• For exams, find (or create) and work on the shared document that students will collaborate on.
• You don't need to read all the papers in their entirety. Actually, you probably don't need to read any and can get by watching lectures. Some of the required readings aren't even mentioned in lectures or exams. They're interesting and quickly reading/skimming some definitely helps your understanding though.
• Get started early on the projects, but not too early (if I had waited 24-48 hours before coding, many of the roadblocks I had run into would be mentioned by someone else on Ed and would eventually be figured out by another student)

Overall, I recommend taking this class. The exams are painful, but the projects make up for it.

Pros

• Very interesting and rewarding projects
• Some interesting papers
• Material is very relevant to the industry, a lot of it I would consider fundamental knowledge for a well-rounded computer scientist/engineer.

Cons

• Exams only reward memorization, especially with 80% of questions released in advance. Studying for these exams is incredibly boring, except if you enjoy memorizing and regurgitating random trivia.

TLDR: The good: - Projects are straightforward and easy to jump into - lectures are great and informative - no stupid busy work The bad: - class can be a little disorganized, with information strewn throughout canvas and the Ed discussion page - tests are hard and IMO a stupid format - no textbook or similar resource, so reviewing has to be done by re-watching lectures and rereading papers

Overall, this is a great course that is packed with interesting topics related to virtualization, parallel systems, distributed systems, etc. I found the projects actually easier than those of GIOS because they are "simpler" while still allowing you to learn and apply the material in a satisfying way. (I found with GIOS that it was necessary to spend a lot of time figuring out the provided skeleton code and what you were even supposed to be doing - this was not a problem in AOS).

The tests are hard, and if you take this class MAKE SURE YOU ARE ON THE TEST COLLABORATION DOCUMENT. Tests are short answer with 80% of the questions released in advance and you're allowed to collaborate on them. I was not aware of this for the first test and I did badly in part because of that. I am of the opinion that the test format is stupid - memorizing answers to the released questions doesn't feel great.

My final complaint is one that is shared amongst many OMSCS classes, namely that it's disorganized and is badly in need of a Spring Cleaning. There is conflicting information in various places across Canvas and Ed Discussion. Due dates for certain things weren't clear. The Canvas modules are badly organized.

A medium difficulty class. Interesting enough content for the program and enough new for me since I don't have an undergrad in CS. Overall, I do recommend this class for people in the computing systems track.

Projects Easily the best part of the course and some of the best in the OMSCS program so far (this was my 5th class). They're all in C and C++ and follow the lectures very well. There were some environment setup issues in the instructions this semester, but nothing that didn't stop these from being very well designed.

Lectures Pretty clear to understand for the most part, but honestly the content was fairly dry at times. Other times pretty interesting. I watched them all at 2x speed. As most OMSCS courses also follow, it was mostly summarizing research papers from over a decade ago.

Exams Kind of hated the format tbh. They release 80% of the questions beforehand and the other 20% are hidden questions that usually pretty closely follow previous exam questions. This was kind of just an exercise in memorizing your answers to the 80% and memorizing the past exam questions based on your guess of what the content will be. It felt like it was too detailed in terms of memorizing the specific steps from the papers of the class instead of applying them to a new subject. It would be great if the exams were more like IHPC, which were all open note (no memorization) but had challenging questions that aren't google-able.

Pros:

• Kishore is a fantastic lecturer
• Projects are good, Pr4 and Pr3 are autograded
• Material is very relevant to software industry. Although the papers are relatively old, the problems being addressed in them are translatable to other contexts

Cons:

• Not a lot of support provided, Do not take unless you've already taken an OS course that isn't bad (e.g. GIOS)
• Point allocations are about 50-50 between projects and exams, but the class is more exam heavy than project heavy

In terms of difficulty, imo the projects were Pr1 > Pr2 >> Pr4 > Pr3 The projects themselves aren't all that difficult, they felt slightly easier than the GIOS projects.

In terms of actual material that's covered on exams, this class casts a much wider net than GIOS. Exams are take home, usually taking up a weekend (don't plan for anything else). Questions are very involved and require a lot of rote memorization

Generally, lectures are enough to prepare for exams. Papers will help, but rewatching the lectures will also help. Keep in mind that if you're collaborating on a shared doc with the rest of the class, some answers that people suggest won't be right (there's usually at least one correct one though)

The amount of work required to get an A in this class is pretty significant (concentrated in exam prep). The amount of work required to get a B will be much less

This is my 6th class in OMSCS and I have taken GIOS before this. I am not sure how some students are able to double up on AOS and another course because the workload itself is not for the faint-hearted.

The format is 4 projects, 3 exams, 2 paper summaries (you can choose from a list) and two pre-course assignments.

The projects were the best part of the course! I thoroughly enjoyed the last project. What makes it really stressful is that the deadlines are pretty much back to back. Often times, the project deadline might overlap with one of the exams' deadline.

Undecided on what I thought about the exams since it probably takes a lot of stress off the students given that questions were released before. This allows for a lot of discussion regarding the answers. Of course, there are students who don't ever contribute and just leech off whatever answers are given by active students.

So students just end up memorizing whatever answers come their way a day before the exam. Evidently, you can see students only appearing on Slack a day before the exam and asking for the collaboration doc link to get answers. On average, probably only 20 contributors out of a class of ~400? For that, it might make sense to make it completely closed book instead.

Content is fantastic and Kishore is so infectious with his enthusiasm! I think it's a good course to take if you want to get more in-depth after GIOS.

The projects are the only good thing about this class. They’re hard but you learn a lot.

However, TAs were barely responsive on Ed Discussion. Most questions on there still have only another student answering saying “idk I assumed ____”, even questions critical to interpreting project instructions.

There are 3 exams, and their format is the worst I’ve seen. I’d rather AI’s 10 hour long take-home exam. They are long-form questions and you make a list of bullet points for each answer, losing points for anything you fail to mention. They release 80% of the questions when the exam window opens, and the only way to complete the exam within the time given is to memorize exactly what you will answer for this 80%. So the entire exam weekend is spent doing this.

You also have to do 2 summaries of papers during the semester, however the due date for the assignment was apparently wrong and the correct dates were given in a description elsewhere, so I didn’t even get to do them since I missed the “real” due date by the time I started on them. Again, communication in this class is terrible.

For context, this was my 9th class, and I have a 4.0

TL;DR

I was ultimately disappointed with the course and it left me questioning the merits of higher education. For the time I sunk into this course I did not feel I got as much as I should have. While I feel I learned some interesting ideas, I don't see a lot of the concepts covered as practical to my career, which is why I was disappointed.

I'm open to learning about random research ideas, but only if they have a practical tie-in to the field as it stands. While I found value out of the course projects, all the other auxillary assignments and assignments ultimately didn't make the course worth it as a whole in my opinion.

Should I take this?

If it's your first course in OMSCS? I wouldn't.

If you haven't taken GIOS and don't have a solid systems understanding? Take GIOS first, and then decide.

Otherwise, if you're unsure if you should go for a PhD or go into academia in your career, take this class and see if your mindset and goals are conducive to this course's design. If you enjoy the class and the research papers that come with it, you might be well prepared for further education and a career in academia.

If you don't care for either, skip this course and do GIOS if you want to learn OS concepts.

Background

• This is my first course in the OMSCS program.
• I was fairly proficient with the concepts presented in the pre-req check and was a TA for my undergraduate OS course, so I figured it was safe to skip GIOS.

Projects

0. pthread based warmup exercise (C, involves finding 5 bugs)
   Time spent: 10h
1. VM vCPU scheduler and memory controller (C, uses libvirt API)
   Time spent: 15h
   The libvirt docs weren't the best, but once you got over that it was mostly fine.
2. Barrier syncronization primitives (C, uses OpenMP and MPI libraries)
   Time spent: 15h
   Really cool seeing the end graphs and figures, but using PACE cluster sucked.
3. gRPC asyncronous hybrid client/server with threadpool (C++, uses gRPC)
   Time spent: 10h
   Once I got accustomed to the gRPC asyncronous API calls it became fairly simple to handle.
4. MapReduce framework (C++, uses gRPC)
   Time spent: 20h (about 15h implementation, 5h debug)
   Lots of boilerplate to understand. Cool end product, but definitely start ASAP.

Pros

• The projects helped make sense of the lectures and demonstrated most of the lecture topics, which I appreciated a lot.

  • e.g. for Project 2 (writing different barriers) the benchmarks we collected clearly demonstrated performance penalties incurred when choosing one specific style of barrier over another for different types of parallel computing architectures.

• Test questions were distributed ahead of time and collaboration was encouraged among the class.

Cons

• Live weekly hangouts that were mandatory.

  • The alternative options to those who couldn't make it seemed slightly unfair.
  • They also felt chock full of trick questions. The professor wouldn't give enough time to think through the question either before closing the polls.

• The professor is not good at being concise.

  • The lectures seemed to drag on and the mandatory weekly hangouts would often go past the allotted hour.

• Tests. (Not to say tests are good, but these might be the hardest I've ever taken in my life.)

  • Despite having the questions ahead of time and collaboration encouraged, the entire class still found certain questions too vague and difficult to answer.
  • TA's are looking for exact key phrases -- if you touch on the concept but don't use the magic phrase they have developed tunnel vision looking for, then it's questionable if you get points for it.

• The reverance of whimsical research papers

  • Some papers were useful and insightful, like the MCS paper on syncronization primitives.
  • Some papers didn't make sense why they were being covered until it was told that they were the basis of commonly used technologies.
  • Some papers just flat out weren't, like the almost 30 year old papers about distributed memory over LAN.
    • Don't ask the course staff if they were ever implemented unless you want a rude and unhelpful non-answer about how "everything in this course is worth knowing."

I took the class in Spring 2022. The exams open on a Friday and must be done by Sunday. You get access to the questions on Friday night, and the whole class usually collaborates on a giant piazza thread and works its way through the test. I think we learn a lot from the conversations between people that eventually converge on an answer that's right. You cant use ur notes or anything when u start the exam so you do have to memorize everything you worked on and learned over the weekend but this is easy because by the end of the weekend, most things are well understood and its always easier to remember something you know than to memorize something u don't.

Projects are challenging and can be time-consuming but not because of difficulty, I think because of ambiguity of requirements, except for the last project which is a MapReduce implementation (it's clear what you need to do for the project to be correct, but the design and details are up to you which allows some creativity.).

1. virtualization, memory allocation, and scheduling project with a VM API
2. openMP and openMPI algorithm implementations for barriers I believe and some experiments + a writeup
3. gRPC-based multi-tier application. aka a client -> server -> another server. you work on the middleman—kind of like a mini meta-API.
4. MapReduce implementation with gRPC.

learning gRPC was time consuming for me

lectures a high volume! like 3 hours of video a week sometimes

papers are recommended but not necessary. some exam questions get pulled from them so do read important ones or remember to skim them when working on the exam over the weekend.

To summarize, -This class has the best set of projects. -The chosen lecture content is not great for 30-40% of the times as they are too specific to old papers. -Exam weeks are stressful, the question papers are given ahead, yet they are unreasonably hard and is atleast 50% memory based and 50% logic based.

From Non-CS STEM major but took GIOS before AOS. For GIOS, I spent around 16-17 hours a week and got a solid A. For AOS, I spent about 24 hours a week. This is my 4th class.

Projects:

Project 0: concepts check and threads I'm not fond of this homework—just an unnecessary warmup.

Project 1: Virtual Machine Scheduling in KVM(C, libvirtAPI)

Design & implement an algorithm to allocate/deallocate CPU & memory between VMs. I have redesigned my algorithm several times and spent 50 hours. I like the project and learned from it.

Project 2: Barrier Synchronization (C, openMP & openMPI)

Based on the paper and course contents, you pick up barrier algorithms to implement and then write a report. I spent around 40 hours. I wasn't exposed to openMP and openMPI before. It's nice to know. I like this project, and it helps me understand barriers much better.

Project 3: Distributed Service using GRPC (C++, gRPC)

Implement async client and server. The GIOS project 4 prepared me. At least this time, I already knew gRPC. This project also has some subtle parts that require thinking. I spent around 15 hours on it and had fun. It is nice to have a non-heavy project in the mid of the semester. I appreciate it.

Project 4: Implement MapReduce Framework (C++, proto3 ,gRPC)

Implement a simple version of MapReduce based on the paper. Readme is well-written. It is a pretty cool project. I spent around 45 hours. The paper read time is not counted here. This is my favorite project so far in OMSCS.

Note that I did all projects on my own. But you can also find a partner to work together from P2 to P4.

Lectures, papers, office hours, TAs:

1. The content is quite dense and requires time to think and understand. I learned a lot this semester.
2. Besides two mandatory papers, I probably read through another five. There are also several other papers I only read the part I am interested in.
3. I love the weekly meeting with Professor Kishore. He is nice and passionate about teaching. The office hour contents are well-designed with various quizzes.
4. TAs are very helpful and active in the piazza.

Tests

Such a relief the questions are given ahead and allow us to discuss in the piazza! Some questions are pretty hard, and there are no alignment and clues on the correct answers after tons of thinking and discussion. The exam week is stressful.

4th class in the program, previous: GOIS, Applied Crypto, RAIT. Overall, I thought this class was OK.

Pros:

• Projects are doable. You're allowed to work with a partner for projects 2-4 if you want. I did not, but was still able to finish the projects. Project 4 took the longest (they tell you to start early on this one: LISTEN TO THEM), followed by project 1, then 2 and 3. None of the projects are particularly hard, they are just time-consuming.
• Professor is very invested in the class learning. He held office hours every week and was active on Piazza.
• 1% grade bump if enough of the class does the CIOS survey at the end of the semester

Neutral:

• 0.5% grade bump if you attend 10 office hours, OR write summaries of 10 of them. I'm putting this in "Neutral" and not "Pros" because I felt this created more work for those who were unable to attend in person. I say this as someone who did attend in person so did not have to write any summaries. The office hours were held in the evening Atlanta time.
• Tests were released in advance and we were able to collaborate with other students on the answers, though we had to take the test solo (closed everything). Why is this not in the pros section? Because the tests are HARD. The first test highest grade was in the mid-90s, average in the 80s. We were allowed to discuss the answers before taking it because, per the professor, he "wants learning to occur". However, I found that I would more so try to memorize some of the answers vs understand them when taking the test.

Cons:

• We used an older version of gcc and gRPC in the class, which some of us were not aware of until submitting code to GradeScope. Either telling us the versions of everything beforehand or updating gcc/gRPC would be helpful.
• The lectures tend to repeat themselves, as in the professor would explain a concept, then explain it again using slightly different words, then sometimes explain it a third time. I ended up watching the lectures at a faster speed because of this.
• There are a list of papers that you're supposed to read throughout the semester. I didn't do this, I read 3 of them: 2 that I had to summarize, and 1 that was needed for project 4. Students are required to provide their summaries to everyone, so you can probably get away with reading the summaries, though I didn't even read those unless they papers came up on the test or projects.

Overall, this class was somewhat interesting. Due to the difficultly of the tests I placed "hard" on this review for the difficulty, if the tests were easier it'd drop the overall difficulty a lot. If you're interested in distributed systems & virtualization, I'd recommend taking the course.

This class is more of a "Systems Analysis" class than a raw OS class. There is a ton of lecture content, papers to read and fun projects. If you want an A in this class, expect to spend 20+ hrs a week simply due to all the papers and hangouts. The worst part about this class is the expectation of regurgitating very specific implementation details of obsolete or research systems on the exams, which are a good portion of the grade.

That said, if you are interested in system design, studying and learning about design decisions of said obsolete and research systems can be very insightful.

I enjoyed the projects. Projects 1 and 4 took the most time. 1 because of having to learn libvirt and 4 because of the scope of the project (simplified MapReduce framework). Project 2 was a pure algorithms assignment and project 3, which took me less than 5 hours felt more like a breather project. Some of the requirements on gradescope can be unspecified and people in piazza post frustrations, which are justified.

If you don't stress out about getting an A, you can go in depth with just the papers you are interested in and watch lectures for the rest.

All in all a satisfying class and is the kind I would expect when I do a Master's Degree.

In a lot of was I was extremely frustrated with this course. As I got further into the course I found myself a lot more interested in the content and some of my frustration started to dissipate. The earlier parts of the course focused on traditional operating system design and considerations, but the course quickly started to focus on parallel and distributed systems. So much so that this course might be better named as "Intro to Distributed Computing" instead of "Advanced Operating Systems".

If you don't have proficiency with C/C++ or multi-threading, you may find this course extremely difficult. If that is the case I'd highly recommend taking GIOS first before you commit to taking AOS (especially because GIOS was designed to give the foundational knowledge required to succeed in AOS).

Pros:

• Professor Kishore is extremely passionate about the subject and it's almost infectious
• The projects can be interesting
• The lectures pack a ton of background information that comes directly from assigned readings
• While attending office hours are part of your grade, they are absolutely worth attending. I found them more enjoyable than the pre-recorded lectures.

Cons:

• The amount of information feels like drinking from a fire hose, and it's extremely difficult to keep up with readings, lectures, and assignments.
• Grading is not always straight forward and you may find yourself having to argue with TAs to regain lost points.

Exams: The exams are close book and open ended questions only. The test questions are released 3-4 days before the exam is due and students are allowed to collaborate with each other to come up with the best answers ahead of time. Regardless, these exams are still relatively difficult and grading is based on specific key talking points. Not all answers are directly from the lectures/readings, so you will be forced to think critically based on the information you've learned up to that point. You will learn a ton simply through the process of answering the exam questions.

One of those courses where you can see the professor really likes his subject. Having worked as a Data Engineer at Expedia, it was really cool to go in-depth on the theory behind MapReduce, parallel systems etc.

I'll generally agree with the conclusions from Edson's YouTube video below - take it if you're really interested in Systems Engineering. (And if you're willing to spend extra time learning C/C++).

I took this course in parallel with Human-Computer Interaction. In hindsight, probably not the best decision, workload-wise :D.
That said, I managed to get an A after a lot of grinding - here are some tips and tricks, hopefully they'll help someone.

I had a very good experience in the Advanced Operating Systems course. I have to say it's not an easy class and there are a lot of materials to cover. I publish a YouTube Video where I talk in more details about my experience in the class. If you are considering taking that class in the future, you should definitely watch the video so you can have a clear picture of what you are getting yourself into.

The homework assignment are pretty challenging and I did not have enough time to read all of the assigned paper and fully prepared for exams.

I have to say, I have learned a lot of new concept on that class that could help me in future classes ( Distributed Computing), hopefully, I don't get disappointed.

AOS is not a bad course, but I do think it is heavily overrated on this site.

Overall I learned a decent amount, but there is a significantly diminishing return in the amount of time invested vs the amount of learning. I think there is simply too much assigned material that is irrelevant, especially when the topics dive deep into the history of design decisions. It's interesting material for the most part, but it does detract from the high points of the topics. I have learned much more from other courses in the program while committing significantly less time.

The projects were OK. Fun at some points, but overall not very relevant to the material and I didn't have any eureka moments like I did with GIOS projects. Also in contrast with GIOS, the course is significantly less organized. Project requirements were vague and often contained errors that would cause issues in development. It got to the point where I was unsure if issues were due to an error on my part or the TAs, and this is very frustrating to encounter.

I did like that the professor was very engaged in the course and has a genuine interest in the topics.

Thinning out the course topics to allow a deeper dive into the mechanics (not the history) of the remaining topics would go a long way to help this course. I think the biggest contributor to my disappointment was taking GIOS beforehand, mainly because GIOS is so streamlined. I would take this course if you just can't get enough of operating systems. If you have a lighter interest (like me), GIOS is sufficient.

For the first time in my life, I felt out of my depth in this class. The material and projects were challenging, and my classmates all seemed to have years of low-level programming experience. In a small class with no credit given for Piazza participation, I quite often felt alone.

But three aspects of the class came to balance this. First, the Slack discussion was active and collaborative. Second, you were allowed to partner on the last three projects. And third, the professor held mandatory hangouts every week.

The professor obviously loves teaching this class, and his enthusiasm is infectious. Every 5 minutes of each hangout, he will poll the class on a particular concept. The questions were high-level, and yet often less than 70% of the polled answers were correct. Heck - I reasoned - if my classmates are consistently getting a third of these questions wrong, then maybe I do belong!

The professor sets very ambitious learning objectives for this class. But he also wants to reduce the stress as much as possible. To that end, everybody gets a "One Time Forgiveness" to extend their project deadline by 1 week. It seemed like most of the class took advantage of this at some point. And most for the last big Map-Reduce project.

To reach this high-learning / low-stress combination, the professor has been experimenting with the format of the exams. Until 2019, there was a big mid-term followed by a bigger-final. The final has been broken into two parts, so there are now three exams: a big first-mid-term (unchanged), a medium second-mid-term (half of the old final but longer), and a medium final. All exams are non-cumulative.

The professor also implemented a new "open questions" exam policy. We get the exam questions on Friday-midnight, then can take the exam anytime through to Monday. And there is an "open collaboration" exam policy, so we all get together and spend two days hashing out all the answers on Google Docs.

Unfortunately there is a price to be paid for these changes, and some of the exam questions have gone from "easy" to "omg". After seeing the exam questions and the discussion, the class exam average was still only 85.

The exam questions themselves are not only fair and predictable, but also very insightful. Question 1 is on Topic 1. Question 2 is on Topic 2. And the questions always start out the same:

"You'll recall that technology A is designed to do B. Why did the designers use X implementation?"

I was often left wondering - yeah - that is a great question - why did they do it that way?!

We get all of the old exams going back to 2010, and I personally learned the most going through these old exams. I'd strongly recommend finishing 5 of these before attempting the new exam questions. While these old exams are still only the "easy" questions, they give you a solid foundation for the "omg" questions. Because most of the technologies we studied died around 1995, there are few surviving sources describing the implementations of the "omg" questions (the assigned research papers didn't seem to help). In the end, you were forced to choose from the half-dozen theories proposed by your classmates.

Where to start with this course... it has its good moments, but overall I'd say I was pretty disappointed with it.

I took GIOS before taking this course, and the difference in quality and content is considerable. First of all, some of the content overlaps with GIOS, while the rest of it is mostly case-study style learning where you read papers about some semi-obscure technology to learn about its design and why its architects designed it that way. Overall I'd say that compared to GIOS, the knowledge I gained through this course was pretty minimal. That's not to say I didn't learn anything, but this course has GIOS to compare it to, and well, GIOS is just awesome, so it's tough to live up to it I guess.

The projects start easy enough but they ramp up in difficulty fast. If you get a bad partner or decide to do the projects alone, good luck... I had an awesome partner and we could divide the work pretty much 50/50 without feeling like the other isn't contributing enough, and it was still a nightmare. They are not projects in the sense of "here's the input, this is the expected output, make it work". No, these projects are more like "this is a 5 page description of how your program should kinda look like, now figure something out. Oh and it has to pass a hidden autograder and we won't provide any tests". At least you can run the autograder an unlimited number of times... To be fair, the professor and the TAs are very active on Piazza and answer any questions promptly and in depth (most of the time), so it makes life a bit easier for the projects. But that basically means that the entirety of Piazza threads for the couple of weeks that the projects are open are pretty much required reading if you wanna do well on the projects.

As for the professor... this guy doesn't really get the whole "O" aspect of "OMSCS". Mandatory live office hours that affect your grade? WTF? What about timezones? Well, there is the option to watch the recordings of office hours and write summaries, but like... that's double the work then. Also, it is true that the professor is very very involved in this course. And very interested in his students. Like, very very interested in his students. Like, he asked for our pictures on more than one occasion. I'm trying to attribute that to the fact that he's trying to get as close to an "in-person" learning experience, but still, like, that's weird.

The lectures are fine, the professor explains everything clearly and sometimes explains the same concept in like 4 different ways, so there's a tendency to get repetitive, but I guess that's better than not explaining stuff well enough. Except... they're super loooong. Even on 2x speed they just go on and on and on... The thing is, a single "lecture" often spans at least 3 or 4 different topics, so when you think you're done with lecture 5, there's still lecture 5b, 5c, 5d, 5e and 5f to go through in the same week. And the "segments" are often about an hour or more each, so be prepared to spend more than just an evening on the lectures. In fact, for a person who only has evenings to allocate to this course, I found myself spending pretty much every evening either watching lectures, reading papers or doing the projects. Not to mention the days I had to take off work to finish the projects.

The only really good thing about this course are the exams. There's 3 of them and the questions are released publicly when the exam period opens, and can be discussed publicly before you actually take the exam. That doesn't mean the exams are easy, though. They cover pretty much everything discussed in the lectures at least in some way, and even though you can discuss the questions beforehand, unless you're super good at memorizing 50 one-paragraph answers, you pretty much have to understand the topics to be able to write a convincing answer. I think this is an awesome way to conduct exams, since the format gives you no choice but to actually understand and conceptualize everything that's on the exam (which is pretty much everything discussed in the lectures).

All in all, I did reasonably well in this class (got 100% on the projects and 95% and 85% on the first two exams, still waiting for the results on the last exam and last project), but it was hell on earth trying to keep up with all the load, the live office hours, etc... So I probably wouldn't take this course again if I had the choice. I think if the professor got rid of the live office hours, cut out some of the more pointless lecture topics, and provided some sort of public testing system for the projects, this course would be a decent choice. But as it is, it's a thumbs down from me.

TLDR: DO NOT EXPECT TO LEARN MUCH PRACTICAL, MODERN STUFF OR YOU WILL BE DISAPPOINTED. Go in expecting a series of case studies related to software systems design, because that's all it is.

• Most well-made class I've taken so far, and I'm 7/10 done including this class. There's an explicit theme that systems design is 1% inspiration and 99% perspiration, and this class will make you sweat. There's not much breathing time. It's a constant fire-hose. There's so many assignments that nothing's worth more than 16%.

• 3/4 of the projects you can do in pairs, but they're pretty doable solo.

• The professor bleeds enthusiasm for the topic and for teaching. And I think the weekly office hours he holds are what he looks forward to the most at his job. It's hard not absorb some of that enthusiasm.

• You know those systems design questions you get asked in job interviews? This is THE class to take to get better at those. Though it makes no attempt to teach you the state of the art, just the chronology of ideas up through the recent past.

• I love the test format. The questions are posted publicly, then you have the weekend to collaborate with the class, memorize your answers, and type them into an Honorlock session. This means the test questions are hard. They really make you think about design choices, and all the factors involved in a design scenario. Keep in mind, the dark side of detail orientedness (as is required to do well on the exams) is that most of the details don't matter past answering the test question.

This is my first OMSCS course. It's not clear to me how it has such a high rating in OMS Central. Prof. Kishore has a likeable personality and seems to care about his students. I suspect that this is the key reason for the high rating.

Also, I'm not sure if this course should be called "advanced operating systems". A more fitting name might be "miscellaneous systems topics".

Content

The course material itself is mediocre. Material appears to not have been updated since the course's inception. This pertains to both lecture videos and projects.

The lecture videos are presented in a way which is neither precise nor concise. One sentence may be repeatedly stated in several different ways. This is an indication that the presenter is unsure how best to present an idea. The result is that the audience may lose his or her attention when the same idea is re-worded slightly and re-presented again and again. You essentially fall asleep watching the lecture videos because of this.

The curriculum includes some serisouly questionable subjects, ones that are not appropriate to be part of an operating systems course. Examples include Java EJB and NuPRL.

Projects

The projects' starting states have all the same bugs described by past reviews. These bugs seem to get carried forward semester after semeter. It's not clear if it is the TA's or the professor's responsibility to fix these bugs - either way, these bugs aren't getting fixed for future semesters.

The projects, even though poorly maintained, are all fairly simple and doable. As you will see, none of the project really involves working on operating systems or some component of operating systems.

Project 1 (C)

Project 1 requires writing two C programs that make use of the libvirt API to manage VMs. Program one dynamically allocates CPU to a set of VMs in order to balance underlying physical CPU utilization. Program two dynamically allocates memory to a set of VMs.

The libvirt API has a large API surface that you'll have to untangle.

This project will likely take 10 to 20 hours, depending on how far you want to go on tweaking your algorithms.

Project 2 (C)

This one requires implementing a few synchronization barriers. Two for synchronizing threads which share the same address space, and two more for synchronizing processes that do not share the same address space. For the former, you are supposed to use the openMP framework. For the latter, you are supposed to the use the MPI framework.

You will do performance testing of your barriers in the Georgia Tech PACE cluster, which uses the PSB batch job management system. You will likely encounter significant problems with how to specify the PSB job specification in a way that gets you the compute resources you need and the affinity that you need, unless the courses updates the project instruction.

In the end, you write a summary to discuss performance.

This project will likely take 10 to 20 hours.

Project 3 (C++)

This project requires you to write a gRPC server which uses a thread pool you implement to respond to client requests. Each response to a client request invovles first querying a number of backend gRPC services, getting their responses, and respond back to the client with the collective backend responses. You must use the gRPC c++ async server implementation so as to avoid using the gRPC c++ library's built-in thread pool.

If you haven't worked with c++ before, you will find out that all the bad things you hear about c++ are true from doing this project.

This project will likely take 5 hours. If you haven't worked with c++ before, add 10 more hours for the struggle you will encounter with c++.

Project 4 (C++)

This project requires you to implement MapReduce using gRPC, with some rudimentary fault tolerance implemented.

This project will likely take 10 to 15 hours.

TLDR;

Hardest class I've ever taken. Had to withdraw due workload. Professor was great. Content was interesting. Looking forward to attempt again when I'm more prepared.

Background:

Graduated BS CS 5 years ago. This is my 2nd semester in OMSCS. Was rusty on C, working full-time as a full-stack web dev. No experience with systems programming. Took intro to OS as undergrad, but not GIOS. Took this class paired with ML4T.

I have an A in ML4T and an A in this class so far (I think), but the workload is absolutely crazy... This class is like a second full-time job. After my second breakdown, I decided to withdraw and live to fight another day. Looking forward to taking it again after GIOS.

Professor:

Kishore is great. I love the energy he brings to the class. He is passionate about teaching. Really a great example of what an online class has the potential to be.

Lectures:

Very good content, very well explained, but the videos are dense. I liked the quizzes in there.

Papers:

Read the Xen paper for the summary assignment. Other than that, there's really no time to spend on the papers unfortunately.

Weekly 1-hour Hangouts:

Was fun to get to know the professor and see him live, as well as the rest of the class.

Projects:

Long, but liked working on them. Learned a lot, but it consumes any and all free time you have (and don't have) for weeks at a time. So they ended up being draining and stressful, as you start falling behind on lectures and exam preparation.

Exams:

Questions are given ahead of time, but somehow still hard because they are conceptual questions so you really need to know your stuff. Also I found it much harder to formulate answers and visualize concepts when there's no pictures in the questions; only a lot of new terminology, acronyms and concepts.

Tips:

Take this as your only class. Recommend taking GIOS first. If you're rusty or new to anything taught in this class, you're going to have a rough time.

A great class that really is a survey of systems research over the past few decades. There is a ton of material (too much to reasonably master for me certainly) but by the end of the course I had a great appreciation for the path through the research/papers that Kishore has set up and learned an incredible amount. Projects are all interesting and rewarding. Exam questions were released at the start of the exam window which reduced the stress of studying/preparing as you can focus on the material relevant to the questions (still challenging, but undoubtedly makes this class a bit "easier" - which is fine by me as I do not think it impacted the amount learned). Kishore is a fantastic professor and is really dedicated to his online sections. Overall a great course and highly recommended.

Only take this course if you have atleast 20hrs to devote to this course, else You will be the one who won't learn anything and end up frustrated/withdrawing in the end.

This course is a lot of work, but it can be done with less workload.

Such as by memorizing test answers as they are disclosed before the exam and students can openly discuss them.

And making your project partner do most of the work in projects.

But you won't learn much with this approach, so that's why I recommend having atleast 20 hrs to devote to this course for maximum benefits.

Note: 20hrs is an estimate for an average CS grad. If your background is not from CS then you will probably require more time.

Background

• This was my 5th course.
• I took GIOS last semester. If you can pass that class, you have the skill level for this one.
• I'm in the Spring 2021 semester, but figure I'd write a review as registrations open for the summer semester soon.

Projects

Project 1 (40-50hrs - 3 weeks): Run some VMs, use the libvirt API to interface with them, adjust their vCPU and memory allocations dynamically. Going beyond VM theory and using a hypervisor API was interesting. I must've spent 20 hours tuning the memory algorithm alone though. I liked this in the beginning but hated it by the end.

Project 2 (40-50hrs - 3 weeks): Write 5 algorithms for synchronizing threads, processes and nodes. It was interesting learning the OMP and MPI mechanics and testing it on an actual cluster (PACE). We had to write 2 algorithms for threads and 2 for processes, so we could compare their performance. At the end of this, it was just too much work/time - I would've preferred writing 1 algorithm for each.

• Side note: Using PACE sucked. The provided shell scripts to run your code on PACE was only half working. Students were left to correct this and share their own scripts. I'm surprised this wasn't tested ahead of time. I spent a hours before going to the forums and found people saying multiple lines were incorrect and all the changes that were required. At this point, I just wanted to get this over with and hated PACE.

Project 3 (10-15 hrs - 3 weeks): A gRPC project. This is always good to learn. The project was similar to GIOS, so I didn't learn much from it but at least it didn't take 40+ hours.

Project 4 (3 weeks): Haven't done it yet.

Lectures

As others have noted, the professor is a model for those teaching online. He engages students, gets laughs, and is captivating. He takes polls which is how he gives you extra credit attendance points. However, I found there is a lot of overlap between the live and recorded lectures. If you feel it adds much value/time spent, knock yourself out. I felt the lectures were too theoretical and it made watch these very unmotivating.

Exams

Go through the video lectures a couple times and read/reply to posts on Piazza where people give their answers to the exam's questions that are released ahead of time. Clearly this isn't the objective but in all honesty, I just was never planning to read the papers.

Other

• It feels like this course has been adjusted since the previous reviews. Sure, there are a ~40 recommended papers but I didn't read any (accept the 2 required for an assignment) - at least certainly not for the projects. But if you want to be an OS developer, knock yourself out and read the papers.

• Why don't they distribute a VM? You're literally asking 500 students to setup an environment for each project. Just make a VM and save people time and yourself lots of questions on Piazza.

• Although I had/have lots of frustrations with this course, the TAs were always very friendly and helpful. I could typically expect a Piazza response within 30 minutes and this would usually help solve my problem and ease my frustration. Also, the student community was very active and helpful.

Summary

If you're interested in OS, obviously this is a course you should take. If you're interested in general systems, maybe you should take it to reinforce some stuff. TBH, I regret taking it because of some of the major frustrations and time consumption with p1 and p2 and am just happy for it to be over (soon).

Tl;dr

Really liked the course! The course gives a good overview of the various aspects of OS and the various solutions that have been used to tackle big problems in the space. The course expects a fair amount from you, but I think the TAs are super helpful and Kishore is a fantastic prof. The course was very reasonable esp. given covid. I come from a non-trad background with no C/C++ experience and this was my first course in the program. Got an A.

Pros

• Learned a lot
• Great resources
• TAs are awesome
• Kishore was great
• Projects were interesting, taught me a lot about C/C++

Cons

• Probably the "mandatory" weekly hangouts. I missed some and still got an A so no big deal.
• Some HW assignments felt like busy work more than educational tools.

Advice

You could probably skip the papers, although that's where the bulk of the real learning/knowledge will come from. Maybe sample some of the papers that look interesting to you and read those (for your own personal enjoyment), otherwise the projects will take up most of your time. Start early on the projects, ideally the day they are released, no joke.

Overall

A very hard class if you're not already quite good at systems programming. Even more of a firehose than GIOS. I think I liked it but am mostly just glad to have escaped with a B.

If you can't create your own threadpool library in C/C++ you are going to struggle mightily with 3 of the 4 projects.

I was saved by doing four things:

1. getting full marks on the second project (which was primarily graded on the writeup of an experiment, not the implementation)

2. getting over 90% on both the miderm and the final (In our semester, we were provided with the actual test questions on the Friday that the test was released. If it weren't for that I would have definitely either dropped the class or gotten a C.)

3. implementing project 4 without a threadpool

4. getting at least 75% on everything else

My Background

This was my third course at GT. I got an A in GIOS and CN previously.

I've been a software engineer for 4+ year with a background in Java and linux.

The Course

There's a seemingly endless amount of information in this course between the readings, lectures, and research necessary to complete the projects.

There is also a lot of administrative stuff always happening in Piazza - signing up for things, going to hangouts, etc. It definitely didn't feel very asynchronous.

The upside is that Prof. Kishore is incredibly engaged and interested in his students. That's very rare.

The projects are cool if you are interested in the building blocks of modern web applications. However when implementing the projects it felt like I was somehow missing the forest for the trees the entire time.

There isn't much of a curve in this class. In my semester it went:

• 88+ is an A
• 80+ is a B
• 70+ is a C
• 60+ is a D

I think he said he rounded up, so maybe a 79.01 would have gotten a B - still not much of a curve.

I guess overall it's cool to be able to now say that I've implemented a version of map-reduce, but it was a long, hard semester just for that.

This was one of my favorite classes so far (8/10). I think it was helpful having taken GIOS and HPCA before this mainly because those were my first classes using C/C++ heavily. The projects are really good and the material is great for the most part. There are some dated concepts and would have been better if the distributed systems section was a little more involved but I enjoyed it nonetheless.

As many others have said, start all projects as soon as you can. They ended up being much more time consuming than I first anticipated by reading the project description. And there is very little starter code like in other classes. You'll be starting from scratch on most of the projects (except for number 4 but that also is the most time consuming by far).

Prof Kishore is a great teacher and I love how much he's invested in students and trying to get them to succeed. It is clear that he has a passion for teaching and if I think the new Cloud Computing class he is teaching will be fantastic in large part because of him.

There were things I liked and disliked about this course.

Liked:

• The projects were great and I had a blast working on all of them. The first and last ones are the most time consuming but also felt extremely rewarding.
• The professor is great and very involved in the course.
• The material itself was enjoyable.

Disliked:

• I didn't feel like I learned much from the actual lecture content. And getting through the assigned papers within the semester while working full time just isn't possible (or at least very difficult). Overall, as an earlier review mentioned, this is very high level learning if you don't read most of the papers.
• The exams focus on rote memorization more than anything else. I personally hate those kinds of exams but at least the format this semester was different which made it a lot more tolerable.

Overall, I enjoyed the class mainly thanks to the projects and the material being relevant to my interests. Be sure to have a solid background in C/C++ or else I would think the course could easily take 30+ hours/week rather than the ~18 it took me.

Good course, but I think it could use some slimming down in areas.

Pros

• The 4 projects were fundamentally pretty interesting and satisfying, with caveats.
• The later lecture content is especially pretty neat.
• The open question, closed notes format for the tests did a good job of alleviating stress while still getting me to study pretty effectively. It led to some great discussion among the students and I got to see other sides of the questions I hadn't considered. It was an effective way of spreading the knowledge.
• Kishore is one of the most involved professors of any class I've taken in OMSCS.

Cons

• The amount of content is pretty bloated and some of it feels like it doesn't matter very much. While you can safely ignore most of the papers, I think I would have preferred that there just be less papers and lectures but make them matter more.
• The bloat unfortunately extends to projects 1 and 2. While they are still pretty cool, they both have the fundamental problem that once you have the core concept down, they become tedious tuning exercises and the learning stops. Project 2 is especially frustrating because you run your tests on the PACE cluster and can potentially be waiting behind other students in the queue for hours before your code runs.

I would say the projects took enough of my time that it was challenging to keep up with the lectures and papers. I was still playing catchup all the way up to the final.

Make sure you have strong C/C++ skills, they will really help you on the projects.

This was my first GTech class. I came from a math undergrad but have decent experience coding (1yr software dev), primarily with C++. You should be fine if you are comfortable with basic C (including memory management). I had to study a bit at the beginning to learn basic OS concepts from provided lecture recordings, since I was lacking low-level knowledge.

I did/attempted all projects myself (no partner), doing well on all except the last one, due to time mismanagement. I'd advise you not to procrastinate; they provide a long time to work on each project, as well as a one-time one week extension.

Cramming worked decently for the midterm and final. Questions are released early and are specific to various ideas provided in papers. These are summarized/discussed in the course lecture videos and weekly recorded office hours. Some questions require reading the related paper. Answers are sometimes not definitive. Collaboration and agreement among your peers will not mean you have the right answer, for some of the difficult problems. There is no need to read the papers besides for graded paper summaries and some test answers.

Despite paper content seeming to be outdated, the ideas presented may be of use if you want to write systems software. Generally, people probably just use the software and are okay with letting it be "magic" behind the scenes. I feel I've learned/gained familiarity a good amount. I ended up with an A.

We were fortunate enough to have a different course experience this semester. A partner for projects P2, 3, 4 and exams released early. Kishore really is an exceptional professor and makes a great effort to teach you the fundamentals of advanced OS study. It helped me understand computing systems at a much more fundamental level than before the course. Still, there really is too much material and it felt like 2 classes. I think if we had the old format, I would have not liked it, at all.

This class has an absolutely obnoxious amount of work and grading.

For work there are 4 projects, plus the exams, plus a bunch of other small things you're graded on (index card, homework, paper summaries, hangouts attendance and participation).

The actual material is also bloated, covering many mostly-irrelevant and seldom used or highly-specialized systems. The problem is that each of these many (MANY) things come with papers that will have questions on the exams.

I didn't learn anything that was actually useful in the second half of the semester (save for security), nor do I remember anything. You just spend so much time memorizing, that you don't have time to actually get a deep understanding.

On the plus side, Kishore is great and makes a real effort to interact with online students.

The course content was terrific, but unfortunately the professor is very old school. The midterm and final consist entirely of pointless rote memorization about specifics from his lecture. I was stunned to see that a professor could get away with such horrendous teaching practices in this day and age.

However, his lecture videos (albeit too many) were very high quality.

The projects are the only reason to take this course. The final project is a full map-reduce implementation that took a full month to do. Looking back on that project makes me realize how much I had to learn in such a brief period.

Hot take: only take this course if you have the time and willingness to learn C++ and systems.

This course has a very high rating on OMSCentral, but now that I've taken it I think that rating must be influenced by survivorship bias. I made it through (with an A), but didn't much enjoy the experience.

There is simply too much material here. On top of the lectures, almost 50 papers, and 4 projects, the instructor holds a weekly office hour hangout you're expected to attend, and there are attendance marks. I dislike attendance marks under any circumstances (we're adults; paying to take this course), but attendance marks in an online course are particularly distasteful. In my case the hangout was scheduled during a weekly work meeting, and I was rarely able to attend.

Other reviewers have praised organization of the course, but I found it highly disorganized. For example, the TAs attempted to 'correct' the syllabus after the course had started by quietly moving all the due dates up by a week. Only after we noticed and complained on Piazza did they make an announcement (and eventually reverse the decision). Likewise, they initially told us to submit paper summaries to a google sheet, but migrated to office 365 half way through the semester. Strangely, although they directed us to use the new sheet, they left the old one up, resulting in ongoing confusion.

Projects

There are 4 projects in this course. I found them interesting, but also found the project descriptions frustratingly vague. There is generally no description of what is actually required, or what will cause you to lose marks. There's no autograder or test harness provided here either, so expect to guess at what's important. I lost marks on one project for not interpreting the word 'gradual' as the TAs expected, for example. It's very frustrating to lose marks for things you could've done correctly if only the project description had been clear about what was required.

In another mark of disorganization, the projects contain bugs and other errors that have somehow gone uncorrected over the semesters.

Exams

The exams are a short answer rote memorization affair, and again frustrating vagaries abound. Your strategy here should be to vomit out every piece of information you can remember about the topic mentioned in the question, even if the question doesn't specifically ask about it. Just answering the question isn't sufficient. For example, the question may ask "Is it possible to accomplish A using technology B", but you'll lose marks if you don't also explain how A and B work. Expect to open a re-grade request and argue with the TAs to scrape some marks back after the exam.

The instructors do make past semester's exams available, so you can see this in action ahead of time.

Papers

I gave up on trying to read all the papers, electing to focus on projects and memorize the lectures instead. It worked out ok for me, and I averaged 18 hours a week on this course anyway. YMMV.

Grade Cutoffs

The course is curved, which makes it hard to know where you stand as the semester draws to the close. The cutoffs for spring 2020 were:

	A range: 87 and above
	B range: 78 and above
	C range: 63 and above
	D range: 55 and above
	F: less than 55

In the end, I think the knowledge I gained form this course was worthwhile, but the design of the course made gaining that knowledge more difficult and frustrating than it needed to be.

TLDR: A lot of content on tests, projects good.

I enjoyed this course. It started off seeming very easy, but got more difficult as deadlines approached and I realized how detailed the midterm would be (and the final covers even much more). The projects were fun for me, especially the third and fourth (four total). If you have some C/C++ experience, this is a good course to get more confidence. Graduate Intro to OS was very helpful to take first.

The downside to me is the number of readings was, well, high. Somewhere around 45 papers are to be read during the semester, and most of them are foundational but also from an earlier time in computing. I enjoy newer research papers with tech I can relate to, so for me in general these were less enjoyable and more difficult to digest. Still worthwhile, I think, but more of a slog.

The midterm and final were difficult, being nearly completely composed of free-form text answers that can be easy to slip up and miss points. Also the scope of information from the papers adds to exam prep. The good news is that the paper highlights are covered in the lectures so that is where the best "bang for the buck" is at. Also there are previous exams with answers that are provided, so you might find that is a better approach.

My advice to you for exam prep, myself having a short attention span and some impatience for watching video lectures, is to slow down, pause, and/or rewatch the parts that you haven't understood to get the lectures right the first time. They are pretty long so rewatching them will take some time.

Something to note about the projects, unlike the other classes I've taken which use Bonnie or some other provided test harness, is that in this class you build your own (or hope someone else will share theirs). It is something to consider as this adds to the time commitment.

Overall I'm glad I took this course and recommend it. Just don't slack.

Excellent and perhaps the only course on distributed systems in the OMS program.

Projects1 and 4 and superb! Projects2 and 3 are lighter but interesting. Projec3 is a good buildup for projec4

Make the most of the paper readings. There are around 45 papers to be read. Target to read alteast 30 that you find interesting.

Exams can be prepared from previous exams. These questions help you not only from an exam point of view, but also for solidifying understanding.

Helpful to have taken a previous OS course and C programming background helps.

Based on the reviews on this course, I expected much more. The sheer number of papers assigned could easily push the time commitment past 30 hours a week if a student were to read them all, but as most have noted, you can largely skip reading them. Even skipping papers, the lectures are long and are difficult to get through. The content is broad and I think it tries to cover too much ground.

Grading exams/homework is based on the student writing keywords and not necessarily showing understanding of the concept. Likely, this is because of the large class size, so I don't hold it against them. Project requirements are vague. Be sure to ask what policies need to be implemented because it cost me a huge percentage of my grade.

Ultimately, I had to end up dropping the course, so you can take this review with the grain of salt it deserves. The main reason I wanted to write the review is to offset the glowing reviews of the class that I don't feel conform to reality.

I honestly didn't like this course very much.

Cons:

1. Repetition from GIOS.
2. Very high level learning. The concepts in this course are studied in a capacity where you 'heard about them once'. Not really getting expertise in a reasonable set of things.
3. Absurdly large number of papers, to the extent that smart students resolve to reading no papers.

Pros:

1. 2-3 of the projects were fun and I learned stuff. The other 1-2 projects where duplicates from GIOS almost...

This course was so boring I crammed all my projects and exams the 1-2 days before the due date.

There is lot of paper reading. Be prepared for it. Also, prior knowledge on c/c++ helps a lot. The assignments are fun and teach you to write distributed services using grpc.

General

• Teaching team is helpful. Professor is engaged during office hours.
• 4 projects, 2 exams. 42 assigned papers (I didn't read any).
• Projects 1 and 2 are in C, Projects 3 and 4 are in C++ (GRPC).
• Almost no extra credit available.
• TAs and other students are responsive on Piazza and slack.
• Course material could have been better and updated. It felt more like a case study class into different OS technologies. First half of the class is more focused on OS concepts has overlap with GIOS. Second half is more focused on distributed systems.
• You need about half the assigned time to complete each project so there is some downtime in between projects. Use this to catch up on lectures.
• I took CS6200 - GIOS right before taking this class. Having some OS background/C/C++ experience helps a lot.

Exams

• Exams are tough and require some detailed knowledge.
• Watch the lectures to prepare for the exams. Don't bother reading the paper's for the exams!!!
• Practice exams from 2008 are provided and these are very helpful. Go over all of them as there are several repeat questions.
• The exams focus on details and keywords. Use the practice exams to note down keywords needed for different questions.
• Try to memorize as many past exam answers as you can and then just regurgitate it during the exam.

Projects

• 3 weeks given for each project but this semester, 4 weeks were given (due to an error in the initial syllabus dates).
• Assignment instructions are a little vague and you have to figure a lot of things out on your own. Make sure to read the instructions carefully though for information on what will be tested.
• No Bonnie!!! Makes testing much harder. Some students do provide test harnesses (but sometimes these are a bit hard to use).
• No detailed written README's required.
• Minimal starter code given.
• Project 1: Memory Coordinator and CPU Scheduler - Use libvirt API to schedule virtual cpu and memory resources. Interesting project but takes some time to understand the API. Time Required: ~20-30 hours. I spent about the first 2 weeks working on the project on/off.
• Project 2: Barrier Synchronization - Easiest project. Implement pseudocode / logic specified in barrier synchronization lectures & paper. Time Required: ~10 hours.
• Project 3: Vendor/Client GRPC using threadpool - Create a simple grpc server-client to get product prices from a server. Most of the time spent on this project is figuring out C++ (I found C++ to be much harder to use than C!). Time required: ~20 hours.
• Project 4: Map/Reduce GRPC - Implement map/reduce using grpc. This was the most challenging but the most enjoyable project. The hardest part of this project is learning C++ and figuring out where to start and what is required for each file. Use async server and sync server to get started - once you get your grpc comms working, it's much easier to proceed. Use the example grpc c++ client/server programs on the grpc website to get started and then modify as needed. There are a lot of implementation details to account for so use Slack/Piazza to discuss with other students. Time required: ~40-50 hours.

This class has an absurd amount of papers that are required readings, and the lectures are extensively long. I'm not exaggerating, it takes a week of full time study to read each paper and watch each lecture that is required for the course. There were multiple moments throughout the semester where I was actually agitated at how much of my time was being wasted by watching and reading the ridiculous number of lectures and papers.

Topics of the course are tangentially related at best. You will be reviewing and studying random technologies, their design and implementation, and their pros and cons for distributed system design. This class at times doesn't feel like it has any sort of central theme, everything just seems to be pieced together. Students are expected to be able to regurgitate random facts from papers and lectures and points are rewarded if specific terms and definitions are used in the answer to exam questions.

After each exam, I immediately dumped everything I learned from my brain as I most likely will never use the information I was required to memorize for this course. I feel like taking this course has completely wasted my semester.

Difficult class with a heavy workload if you want to do well. Projects are rewarding; very C and C++ heavy. If you aren't familiar with C you'll struggle. A lot of detailed lecture content that can be overwhelming but a lot of good stuff there. Difficult exams.

This course covers a broad range of operating systems topics. I took the course as an elective for some one looking for more experience with C and C++ and parallel programming concepts. The distributed topics were beyond my interest but the projects were very interesting.

The structure, support, and topics are all well done. The professor is an expert in the field and seemed very willing to engage with students.

My struggles in the course were mostly with the exams. I found the amount of material covered by the exams somewhat overwhelming, although I had some significant life events going on during the semester.

I enjoyed the projects. The libvirt API took some getting used to that was beyond the concepts at hand. You definitely want to be comfortable in C and C++ to do well on the projects. I found project 4 on MapReduce to be very fulfilling but read the spec carefully to get the best grade you can.

This is a very C and C++ heavy course. I personally had experience in C++, and i still found it a little challenging. Not impossible, but a good amount of time was spent on the projects.

The exams were really content heavy too, with hours and hours of lectures to go through. But i found it worth it. The content is top notch, and you get an incredible insight in the inner workings of your computer.

It's also funny how the canvas page was under construction all the way.

Projects require you have strong C and C++ skills. The exams are close-book and need to memorize a lot of details covered in the lecture.

Here are some tips to get a good grade in this course.

1. Start early for projects
2. Solid C and C++ skills for projects.
3. Use the previous exams to prepare tests.

Although the course content is hard, it’s not hard to get a good grade. Professor gives a very huge curve.

This is my first class in this program. I took this with CS6340. I strongly recommend only take this course in a semester because of the high workload. Although I got a B and passed the course, I don’t read any assigned paper and not gain a deep understanding of the material. If you want to get most of this course, please read as many as the assigned papers as you can. Ask questions during office hours and discuss them with professor.

This was an interesting course and professor Kishore and the TAs are very involved and helpful. The topics are wide ranging and some are more historical while others, like locks and barriers directly apply to daily work if you do OS development. The projects are very interesting, but be sure to start early as they take a lot of time. Having some knowledge of C and C++ before going into the course definitely helps a lot as there is no time to ramp up. You are expected to go in knowing how to implement projects in those languages.

Advanced Operating Systems is a great course providing a very broad overview of operating systems technology. It is very enjoyable, but it is very time consuming.

You must know C and C++ reasonably well to do this course. The first project is a pretty hefty project in C where you have to interact with a relatively awkward external library to manipulate virtual machine resources. This particular project also comes with no boilerplate code written for you. The last project is big C++ project. Whilst it comes with boilerplate code written for you it still isn't very easy and is time consuming. Therefore, if you haven't programmed in C AND C++ before, you will really struggle.

The course consists of:

• 4 projects (first 2 in C, next 2 in C++; projects 1 and 4 are hard, 2 is medium, 3 is easy)
• 2 exams (midterm and final)
• 2 paper summaries
• A warmup homework consisting of questions + some pthreads code (to test your readiness)

An important thing to note about this course, is that whilst it is structured around a particular set of very specific technologies and solutions in the OS space, that is not what I felt the course is really about. The real lesson is how to do systems design. The specific systems considered are just case studies (though particularly important ones). Therefore, despite the age of some of the papers that formed the basis of the material the content is still relevant, because design principles are timeless and extend beyond any particular solution. The professor emphasises this point several times throughout the lectures.

Having said that, the exams are just rote learning and they test you on the details of all the technologies and not on system design. In some way, this is nice, because if you prepare well it's easy to get really high marks. To prepare, do the past papers which are released a few weeks before each exam. My advice is to simply go through all the worked solutions and write them in your own words (even if you had to look at the answer). The worked solutions often point out which key terms must be mentioned to not lose points. Pay attention to this! The graders are encouraged to be flexible, but missing key terms will lose you points so make sure you know what they are.

The course is based on 45 papers. You are supposed to read them, but I'm pretty sure most people don't. You only need to read 2 of them (for the paper summaries, though that's only 2% of the grade). For exams, past papers and their solutions are much better preparation. However, the papers still have value, because they go into much more depth than the lectures. Here is some advice for minimising the time spent on the papers:

• don't bother with the review questions - they require you to really understand the guts of the papers and are very time consuming
• skip the evaluation and related work sections in the papers - the evaluations made more sense in the context of the time the papers were published
• don't read them before the lectures which cover the same material - I recommend reading them at least one week later as revision

The one downside of the course for me was that the weekly hangouts were in the evenings of US time so I couldn't attend (1 AM in Europe). Since the professor is very active in this class I feel like I missed out on that. The recordings are made available though.

Excellent course! It's a lot of work, with 4 programming projects, two paper summaries, two small pre-work assignments, participation credit, a midterm and a final. The video lectures are excellent. The projects are hard but fun. Your hand isn't held through this course, and a ton of material is covered, with a certain expectation of prior knowledge and/or quick learning. I recommend taking GIOS first, particularly if you don't have strong background with programming or systems work. The tests are hard and there are lots of papers to read.

Finally done with this class!!! This is probably one of the three classes that focus on advanced topics in the OMSCS program. The other two are Introduction to High-Performance Computing and Reinforcement Learning. Basically, the upper-division undergraduate classes are pretty much the same as the entry-level graduate classes. Probably those graduate classes will additionally require students to read papers and write papers. But after those classes, you will have a chance to tackle graduate classes on advanced topics. This class focuses on advanced topics on computer systems. Professor Kishore is awesome! I really like him, and he is always jovial and answers students' questions during office hours. Super recommend it!!!

Overall, I found this to be a really rewarding class. For the most part I enjoyed the projects and believed they contributed to me understanding the material better. Only project I wasn't a huge fan of was the first one cause I found myself spending more time on understanding the kvm api than actually implementing my algorithms. However, the last project was one of my favorites I have done in the program to date.

There are a lot of papers and you definitely don't need to read them all but I believe a lot of my learning came from them. Also, the class was really well ran with TAs being helpful/responsive and Dr. Ramachandran hosting weekly office hours and dropping in on Piazza from time to time. If you enjoyed GIOS or have an interest in distributed computing I highly recommend this class!

Tough course, but I enjoyed it. Learned a lot. C/C++ experience will help you a lot - I didn't have much so spent a lot of time picking C back up.

Projects are relatively fun, and you will get a lot out of them. Be prepared to spend a lot of time on them. Lectures are dense.

Professor was amazing. Enthusiastic, readily available. Props to Kishore.

Lots of readings, but students write summaries as an assignment so you can read the shorthand if you'd rather not read 100+ pages of OS papers published 30 years ago. I'd not recommend you skip all of them, but this helps in a tighter week, or when studying.

This was my first course, but I've taken a few now and this is still in the top half of my favourite courses. I don't think I'd recommend as your first course unless you really want to dive in to a busy workload.

I took the course Fall 2019

OVERALL: Great course, has a heavy focus on foundational distributed systems concepts, which are huge right now if you want to really understand what's going on behind Cloud and Edge Computing.

TEACHING STAFF: Responsive and helpful. Prof. Kishore has clearly put a lot of effort into this course. I would like to see it continue to develop further as Cloud computing only becomes more ubiquitous. Weekly office hours with the professor, daily office hours with the TAs if you want them via BlueJeans, therefore there is no excuse for not getting the help you need to succeed.

MATERIAL:

• Academic readings cover the breadth of computer science, from the 80s to ~2007, plus additional optional readings.
• There is a lot of reading. While you could survive and get >= B only skimming the papers, I would recommend carving out time during a morning commute or right after work to chip away at them, as the body of knowledge they want you to absorb is well chosen and will really help you strengthen your overall knowledge in OS.
• Prior exams with solutions are released for you to study!
• Lectures are really good (maybe not great), and deliver the needed concepts in a short and concise format.
• HINT: Use your classmates paper summaries (all links are shared to the class in a spreadsheet) to quickly review the academic readings!
• A good supplemental resource by a former student for the second part of the course, can be easier to digest then some of the lectures, is in the link below:
• https://www.researchgate.net/publication/299535414_Illustrated_Notes_for_Advanced_Operating_Systems/link/572bd90008ae057b0a0958c6/download

PROJECTS / EXAMS

• Exams are fair and not cumulative. They are difficult, but if you watched the lectures and study the provided resources they do a good job of testing your understanding of the course concepts.
• Projects are 3 weeks each, and varied from 20 - 50 hours of work for me (a more experienced C/C++ coder could likely shave off 10 hours).
• P1: Coding in C. Virtual Memory and CPU management. I thought this was the MOST difficult, but a fun challenge.
• P2: Coding in C. Implementing core OS algorithms. The easiest, but still a fun exercise!
• P3: Coding in C++. Distributed comms via gRPC. Lots of fun
• P4: Coding In C++. Builds off P3 concepts, and i'll leave the rest for you to discover. The 2nd most difficult after P1 in my opinion, but some called this the hardest

FINAL NOTES: If you are unsure about this course, take CS_6200 Intro to Grad OS. If you can make it through that, you'll do fine in this course.

Need to study hard to get good marks on the exams. Some of the projects are boring and they are in C or C++.

Really interesting course that provides you a pretty thorough understanding of systems engineering. Course covers both OS and distributed systems.

Strongly recommended to read as many papers as possible.

This has been my favorite class in OMSCS.

Projects:
4 projects, all difficult, all worthwhile. The TAs did a great job supporting the class in helping us figure out what needed to be done. The project descriptions could have been a little bit better though. There's a lot of room for different approaches and any time I asked the TAs if something was okay, they'd say sure and to include it in the README.

Tests:
The tests were very hard, but we were provided with every previous test dating back like 10 years. You can just study the last 4 (suggested by the TA) and do well on the tests. The papers aren't a requirement, but it helps to read the ones that you want to bolster.

Professor:
Probably the nicest and most attentive professor in OMSCS. Was always at OH even while traveling or the week his house was robbed. It's crazy how dedicated he was.

TAs:
Best I've seen.

I took this class way back in Fall 2017 and I missed writing a review for this earlier. Most of what I write here are based off my memory and I apologise if there are some inconsistencies.

The concepts were interesting and there was scope to learn a lot. My current job requires a good understanding of OS concepts but despite that, I found the course hard. The projects required a good knowledge of C++ and they were long but interesting. You will need to understand he concepts well to do well in the projects. Some of them involve analysing the CPU, Mem utilization numbers closely to identify and correct environment issues if any.

The TAs were responsive but I found the need for a couple of regrade requests on the projects.

There was a lot of theory to be learned and the midterms were especially long and hard. The finals were a little better but the questions needed a good understanding of the concepts.

The grades were curved and the TAs provided a "One Time Forgiveness" option for resubmission of the projects after the deadline. Also there was scope for extra 0.5% bonus grade. So, although this interesting course was hard, there was scope for improvement. I wouldn't recommend clubbing this with another course (especially if you are already in a full time job)

I really wish I had more time for this course.

There were a TON of readings for this class. The good news is that you're not going to have to do all of them in order to do well in this class.

Really loved Professor Kishore and the whole crew. Really stellar class. Definitely a great class to take right after GIOS.

I will warn you that you have to start on Project 4 early. It is quite time consuming and quite difficult.

There was a decent curve for this course. I think I would have gotten a solid B without it. With it I got an A.

My first class in the program and a great way to jump back into academia!

I started out reading papers during my morning commute and watching lectures at night, then doing project work on the weekend. This is fairly sustainable, but the workload ramps up considerably as the semester goes on, both in terms of reading/watching/coding.

Working ahead, especially on paper reading, is a great idea if you can do it early.

Highly encouraged to use the prior exams as a study guide as you approach the exams themselves, to focus in on what will likely be asked about. But it would be difficult to subsist entirely on this -- memorizing answers won't work well without a foundational understanding via the material.

The projects themselves are fantastic and practical, but be prepared to write a lot of C/C++. I hadn't written in either language professionally, but I managed (and now feel much more comfortable in both!) Test harnesses are not always provided, but in my term there was always some friendly student to help put together harnesses and sanity-checks.

My workload ended up being highly clustered into weekends, especially by the end, but since there's always a project ongoing and always a ton more reading to do, if you can keep a disciplined schedule you can have a smooth ride.

intense, fair, and worth doing.

This course is HARD. You will need a lot of time for it.

There's a LOT of reading but you will learn so much. It's the kind of class that really feels like it defines this as a graduate program.

It's a challenge but you'll learn a lot and definitely be happy you took it.

This is was my first course in the program and it was pretty rewarding in terms of what I learned and how I performed. Though it requires a good amount of work to be done for projects and assigned readings. In fact, I am glad I did not pair it with any other course.

The course covers the OS principles, its history, and its relevance today. It’s pretty interesting to know how the latest technologies of virtualization and cloud have its basis on principles from the 80s and 90s. The videos explain the topics well and have assigned papers for further readings. I must have only managed ~30-40% of those (some 40+ papers are provided at the start of the course.) The midterm and final questions are not MCQs and require some memorization as answers are to be given in bullet points/essay form. However, the previous year papers and solutions are quite helpful in understanding the pattern. From lectures and previous year papers, one tends to figure out which research papers are more important from exam point of view, though others are equally important from a learning perspective. Midterm and finals are 42% of the total grade. Grades are based on a curve.

There are 4 projects to be done and they require good C/C++ skills (C for projects 1, 2 and C++11 for projects 3, 4). Even with knowing C++ for the last 9 years, the projects were not easy. Project1 was quite difficult, with many test cases to cover and Project4 required writing a lot of boilerplate code(~40 hrs of work, 800+ lines of code). However, all the projects were interesting and offered something new to learn.

Prof. Kishore is a great instructor who teaches very passionately and the lectures explain the topics very well. Office hours happen once every week. I could not attend any live but videos are recorded and shared for later viewing. The TAs are also pretty responsive and helpful, I was pretty surprised that they accepted my request to reassess my midterm solution.

Overall it’s a great course with lots to learn (you would not be writing your own OS here if that's what you are expecting but you will learn a lot about OS principles, virtualization, distributed systems, etc.) Advise to anyone who is interested in taking this course - be prepared to work hard, DO NOT start the projects late, brush-up on C/C++ skills if you are not using it on daily basis, it would not be easy learning it on the go. And try to follow the schedule provided for watching videos, I missed the schedule after the midterm exam and I had to slog a lot towards the end.

This class is more like introduction to distributed system than advanced OS. There are lectures about historical OS architecture at the beginning, but then it jumps into distributed system topics. So if you expect a class like where you implement a simplified version of OS functionality, this is not for you.

Assignments are hard and time-consuming, so be prepare to start way before the deadline. There are 4 (+ 1 extra credit) and all in C / C++. Also you have one more ramp-up project which gives you 5 pts or so at the beginning. Exams are certainly difficult and require too much memorization to me. The previous exams provided were very helpful but I don't think it was useful learning experience, rather it was just like studying and spend so much time purely for grades. Also this class gives you so many additional papers to read, while you need to pick only 2 among them and submit your summarization. I doubt that many people read all of papers which were listed in our syllabus.

Due to so heavy workload, I gave up fully absorbing some part of lectures which actually I am interested in.. my fault, but I think it'd be helpful if the class gave me more focus on them. Also I assume not everyone is interested in exploring architecture of very old systems (while the idea is still valid in this era) in a shallow but rapid way.

Overall, I certainly leant some but ended up in just keeping my focus on getting grade B+. Depending on how much you can allocate your time in this class, YMMV. But I don't recommend taking this class as one of a pair with another class.

Actually took this during Fall 2018, but the option isn't available in the dropdown at the time of writing this review.

I took this as my 7th class in OMSCS, and definitely enjoyed it. Most of the grade came from the 4 projects:

• Implement hypervisor CPU scheduler and memory manager (C)
• Implement and improve various concurrency primitives (C)
• Implement asynchronous server/client with gRPC (C++)
• Implement the MapReduce framework with gRPC (C++)

I disliked the first project, but thought the other three were great. Going into this class, I had some C experience but no C++ experience (but had dabbled with Rust, so I understood issues of ownership), and had no trouble picking up enough C++ to be productive. I thought the projects were interesting, useful, and appropriately scoped (re: amount of work, time allotted, etc.).

There were a lot of readings for this class - I didn't have time or energy to read everything, but I read a lot and learned a lot from those papers. This class uses the actual research papers that introduced a lot of the concepts central to distributed computing and operating system design in the '80s and beyond, so it was interesting to see how those papers had influenced the landscape of today's operating systems.

The lectures were fantastic. It's very obvious how much Prof. Kishore cares about the subject material and the students.

I definitely recommend this class. It could even be a good first class, if you're feeling ambitious (though it might be wise to start with IOS first).

I took Intro to OS the semester before and can say that the topics covered in AOS don't really overlap with those in Intro to OS. There is no hand holding in this course and projects can be difficult to start (2 in C, 2 in C++) simply based on the project description. There are a lot of papers to read for the course and unfortunately, its hit or miss whether you read the correct ones for the midterm and final. The video lectures were done quite well and I felt like I really took away a lot of useful practical knowledge as well as an intuitive understanding of how to think through certain concepts.

The professor for the course really knows his stuff and the material is really interesting focusing on distributed systems. It is very much recommended to have a strong understanding of C and C++ since the projects use this. (Projects are kinda hard but exciting as well).

Lecture videos and past exam material are also instrumental for the two exams which are administered via proctortrack.

There is quite a bit of assigned reading on this course with each student having to make 2 paper summaries. Extra credit is offered for piazza participation and one extra project.

I would highly recommend this course for anyone in the omscs. Beware of the effort needed though time wise for the projects and reading papers. It would definitely help to take GIOS first as well :-)

AOS is the closest we have in OMSCS to a dedicated distributed systems course. The course is about 30% OS, 70% distributed systems. For this reason, I think this class is very important for anyone in CS to take until we get a proper distributed systems course.

The workload is comprised of:

• 2 exams, the final covers around twice the material as the midterm
• 4 projects, the last project being twice the work as prior projects
• weekly lectures
• 46 papers

The course is back loaded. The workload ramps up considerably in the last 4-6 weeks.

It's a survey course, so it covers the seminal systems research papers over the last 4 decades to the modern age. There is a lot of information here. If you read and understand every paper, as Professor Kishore recommends, this course easily hits 20+ hours/week. I started to suffer from information overload, and skipped the last 20 papers.

Fortunately, reading the papers isn't necessary to get a good grade. Watching the lectures and reading the prior exams is enough to do well in the midterm and finals. I still highly recommend reading the more interesting papers though, if you can. You will learn a lot.

The projects are tough, but really good. I found them far more relevant than IOS (you use grpc for instance, not ancient rpcgen). Writing barrier algorithms was probably my favorite. On the downside, the projects are far less structured than IOS. The requirements can be a little vague, and there is no Bonnie for testing your project. You have to figure out the tests yourself, and be confident in your solution before submitting it.

There is no hand holding in this course! But it's a really great course, and my favorite in OMSCS so far.

I just finished this course on Fall 2018. Generally it is a good course and the professor Kishore is an OS expert.

We are required to: watch the lecture video, read 2 assigned paper, finish 4 projects (project#4 needs lots of time), midterm and final test without books.

You can get most out of the course if you can read all the 40+ papers during year 1980-2010 (but it is nearly impossible as it consumes too much time).

Projects are challenging and require both C and C++ skills.

For midterm and final tests, you should read the previous tests provided by the course, and they will be quite helpful.

This was my first course in OMSCS, and although this class is known to be difficult, I found it to be very valuable and enjoyed Prof Kishore's enthusiasm. I had very little experience coding in C++, and I had never coded in C before. The first two projects were in C, while the last two projects were in C++. I put it in a lot of hours into this class, trying to learn C/C++ as well as trying to succeed on the projects. Because of the extra effort, I did really well on the projects. My favorite projects were Project 2 (C) and Project 4 (C++). For Project 2, we had to use the libvirt API to create a CPU scheduler and memory coordinator to manage virtual machines with varying resource usage. For Project 4, we had to create an implementation of the MapReduce using gRPC - this was the biggest project in the class and was also the final one. They gave us 4 weeks instead of 2 weeks to finish it, and I think I spent 3 weeks total on the project. I found the exams to be difficult because you basically had to memorize a lot of information. This class covered several different operating systems and algorithms that were developed decades ago. Old midterms and finals were already on T-Square, so if you had to time to go through all of the old tests and skim through the research papers, then you would do fine on the tests. I definitely preferred the projects over the exams though. The class is curved at the end though, so as long as you start on the projects early and score really high on them, and not completely bomb the tests, you can get an A in the class.

Great course, but very difficult and time consuming if you want to learn everything in this class.

Midterms and final are difficult, but end of course is curved fairly significantly. Project 4 will take you a long time, half of the projects in C, half in C++. Worth reading and learning a bit of C++ if you have only worked in C, like me.

One of my favorite if not my favorite course so far.

As mentioned by other reviewers, this class is broad. It focuses more on distributed systems and the contributions of theoretical operating systems than the details of current, commercial operating systems. The test questions are very similar to previous years' questions. I made quick passes through the lectures, memorized the three or four previous classes' tests, and got a B on both the midterm and the final: that was above average for this class. Course grades are curved or scaled after all of the test and project grades are in.

The part of this class that I really enjoyed was the projects. I've got a moderate amount of C/C++ experience: three or four classes in recent history plus some self-study. These really stretched my skills and helped me improve my ability with these languages. The final project (MapReduce) took me about twice as long as the first project. I was able to finish the first project with about two days of solid work (8-10 hours per day) and the final project with about four days. Your experience will vary.

There's one hint I wanted to add that I didn't see below: guess on the tests. If you're not sure of the answer, then make inferences from the question, flesh out an answer from whatever dim memory you've got of the subject, etc. I did so, and was rewarded.

Material was very broad and somewhat high level, focussing more on 'recent' OS developments and concepts, rather than focussing on lower level implementation details (more low level kernel info would have been awesome, but I do appreciate that at that point you are getting into specifics rather than concepts). The course itself was very hard and was certainly a challenge to do on it's own with a full time job. The exams are pretty hard and require you to go beyond the lectures and read the assigned papers fully to be able to interpret details.

Survey course so material was more broad than deep.

First half, up to midterm, is spent going over the design of older operating systems. Second half on a variety of algorithms and "libraries" that served OS functionality (barriers, GMS, LVRM, things like that).

Four projects. The amount of time you spend on projects will directly correlate with your knowledge and comfort level in C/C++. Other than the first project your algorithms/design approach will essentially be handed to you, and the point is to either implement the logic or learn a framework.

While you can skate by not reading the papers, this will end up hurting you in the end. Some of the complexities of the material is glossed over in the lectures only to be exposed in the readings. Though if you correlate the "hot topics" of previous midterms/finals with the papers, you'll get a good idea of what papers are more important than others.

Overall this is a difficult class but certainly doable. It's reputation of being a "weeding out" class is fair. The expectations of students is also fair. If you are prepared to spend time studying, doing the projects, doing the readings, and otherwise engaging with the material you'll do fine.

As others have noted, there is a ton of (very dense) reading material and the projects will take a good amount of work and effort. This was my first course of the program. While it was very time consuming and challenging at times, I'm quite happy with what I gained from the course and how I performed.

Some notes for students looking / about to take this course:

• Give yourself plenty of time for the project work. They can be time consuming, especially the latter projects. Especially if you're not familiar or comfortable working in C and a Linux (or unix-like) environment. A lot of other students seemed to struggle with the basics of settings up the environments needed to complete the projects.
• For midterm and final definitely use previous midterms/finals as study material. Most of the questions are derivatives of previous years, or sometimes the same just worded slightly differently.
• Read the papers! Read over every paper at least once to help gain insight into the topics discussed in the lecture videos. And read the papers before the lecture videos.
• Final course grade is curved. Everyone seemed to do mediocre or not-great on the final and midterm exams, but doing well on the projects and completing the rest of the assignments will help ensure a good grade out of the course.

This course was very informative, but required a lot of work on the projects and especially on the assigned readings.

This course covered a lot of OS principles, both historically and relevant to today's environment. It was interesting to learn of many concepts that were "ahead of their time" and just now coming into mainstream given cloud and data center technologies.

The projects were slightly harder than average difficulty and required good knowledge of C++ (in particular C++ 11). Coming from a C++/embedded background this was not too difficult, but given some of the Piazza posts many had problems in this area. Most projects had "multi-threaded" attributes, so a good understanding of threads is a good thing to know coming into the class. Nonetheless, all the projects had a high "learning value", introducing us to several technologies I haven't been exposed to (but expect to put into practice).

The assigned readings were also voluminous, with many of them supporting the lectures. Plan to spend countless hours reading these papers. Several details of the papers were asked on the midterm and/or final exams, so this is not an optional component of the class. Most of the papers were actually quite informative, though some went into a lot of details and performance evaluations, which could've been summarized in just a few sentences (I mostly just skimmed these sections and got the necessary information our of the summary).

By far, the most challenging aspect of the course were the midterm and final exams, which together comprised 42% of the overall grade. These tests were quite simply "hard". The tests did not exactly focus on the facts learned during the course, but instead on whether the student understood the concepts/facts and could make additional deductions on those facts. The exams, while still performed in Verificent/Proctortrack were all essay type questions. Even the True/False questions required an explanation in order to get credit. The exams were definitely comprehensive over the material.

The lectures were actually quite good. The professor took the time to convey key concepts, including examples and details. Of course, his lectures were primarily an overview with examples of the assigned readings. The TAs were quite helpful and responsive on Piazza.

Perhaps the only negative (I consider the "difficulty of the course a positive) was that the projects took a long time to be graded. At midterm (i.e., time to withdraw), only about 30% of the grades had been posted. This may have been caused by significant events during the early part of the semester (Hurricane Irma, Harvey and Katia) that impacted a lot of students (and in the case of Irma the Atlanta campus). A special 1 time "late forgiveness" policy was however, introduced to accommodate those impacted by these storms. I was a little disappointed in that the course did not go into more "kernel level" OS details, but stayed a little higher level detailing how OS support newer technologies such as security, data centers and distributed computing systems, which seems to be more of the trend.

I would definitely recommend this class to anyone interested in distributed systems. Don't be misled into believing that the course is just an advanced undergraduate OS type course. You'll learn a lot in this course, but you'll also work hard to do well and be glad you took it (after it's over).

A lot of reading, and very long lectures. The material is not that difficult, however, there is a lot of it, so expect to cram and dump for the two exams. I do not think reading the papers is that necessary, but recommended if you have the time. The projects were ok, but the requirements were sketchy and there were no tests at all. When you turn one in you have no idea how good it will perform. The projects for Fall were: VM scheduling/balancing, Barrier Implementations, GRPC/Threadpool, and Map-Reduce. All the negativity assigned, the professor is very knowledgable, helpful and the production value of the lectures were great. The professor even attended office hours.

A time consuming yet intriguing and relevant course for distributed applications; not for C and C++ beginners. Coming into the course, I had only undergraduate CS experience with C and C++ and I was able to complete the assignments. However individuals with no C or C++ background would have to spend even more time debugging and learning C++ pointers, structs, and templates. Also take notes as you go, there are many in depth lectures and reading assignments to cover; more than average.

Fourth class in the program (previously taken IOS, SDP, IIS). I agree with the general consensus of the reviews already posted here. The projects are difficult (would be extremely difficult if your C/C++ background is very limited). Tons of papers to read. The exams are also difficult, though previous exam solutions are extremely helpful. Exam questions don't seem to strictly repeat, but tend to cover the same concepts.

The workload isn't extreme. I had some experience in C/C++ and most of the projects took 20-30 hours, with the exception of project 4, which is a huge project and took me well over 40 hours. I generally spent 6ish hours on papers and lectures per week.

Overall, the class is informative, well-run, and the projects are useful and interesting. I enjoyed the class very much and wouldn't hesitate to recommend to anyone.

This was my first course in the OMS CS program. I only took one course this semester, and I am thankful that I did. This course was very intense, and very interesting. All projects were done using C and C++. I suggest a good working knowledge of C/C++ or it will require a lot of extra effort for projects that are difficult in themselves. The lectures are very well done, and very informative. There is a lot of information and a lot of fine detail in the lectures. On top of the long project assignments, there are 15-20 papers that are required readings. A close to average Midterm score can be achieved without reading the papers, but just read the papers. The exams themselves are entirely essay based, 25-30 questions, and are quite difficult. The course requires a lot of work, but I am happy to have taken it.

This course was easily the most difficult course I've ever taken, but it's well worth it. Prepare to read a ton of papers, code some awesome projects, listen to brilliant lectures, and learn an absolute ton. I had been writing file systems for about 4 years prior to taking this course and I learned a crazy amount.

Highly suggest this course, but be prepared to work.

Don't take this course as your first OMS class. If the intent was a weeding out course this is it.

It's been 20 years since I took an OS class. The content covered in the first two or three lectures was about the extent my brain could take. Thank goodness you can re-watch the videos. I filled up a spiral notebook in the first 3 weeks.

At the time I took the class the white papers were "recommended" reading. That should be changed to required reading and you better start reading them daily. Download all of the previous semester(s) mid-term and finals early to get a good idea of what to expect.

I got a 48 on the mid-term. Ended up withdrawing from the class and was lucky to make it before the deadline somehow. A friend stayed in and ended up with a 57 and got a B! I am sure the class has good content but what a shock as to how much was flowing from the pipe. If you aren't sure about the Adv OS then take the Intro to OS. Both of them count toward the requirement.

Tough course, the materials are very dense and cover a lot of topics. The topics mostly come from papers published 20-30 years ago but are still relevant (some are the foundations) of modern operating systems.

Projects are interesting but require solid foundation in C/C++. You wouldn't want to spend time familiarising with C/C++ while the projects itself require significant time from design to implementation to testing. Plan to spend at least 30 hours to finish each of the project. At least one project requires you to start from scratch without any template. The good news is grading is quite lenient and often TAs forgive small mistakes or inaccuracy as long as the codes reflect your understanding of the materials.

Piazza is moderately active, questions about course materials are usually answered during office hours. Prof Ramachandran is a very passionate teacher and he monitors closely the class in Piazza.

The video lectures explain most of the concepts very well, however there are a lot of details not mentioned in the lecture slides. My advice is to print the lecture slides and take notes on the details from Professor's speech. These notes will be very useful in the exam preparation.

There are tons of papers to read, most of them are the details behind the course materials while some are supplementary. I wish I had more time to spend time reading those papers, as throughout the semester I only managed to read ~30% of them. However if you watch the lectures, you should be able to do ok in exams.

Exams are, as others have stated, brutal. The midterm average was 58. The exams require good understanding of the course materials plus very good memorisation. Some questions from past exams reappear so don't forget to review them.

The grade is curved hence the grade will be relative to others'. Overall I enjoy this class and I recommend this class if you like low level stuffs and ready to spend at least 15 hours a week.

I decided to jump into this program with both feet, taking 6210 and 6290 in my first semester. AOS was very difficult because of the breadth of the material. But I got a tip early that the sample midterms and final are the best resource for studying. I literally memorized the answers from the sample finals and managed to get an 84 on the final (after a 59 on the midterm). With good project performances, I still squeaked out an A in the class. In-depth C++ knowledge is really crucial in this class, because the projects required complete design, implementation, and testing, not just modifications or debugging to existing code.

Difficult class (especially if you have a demanding job as well) but well worth taking if you want to understand the low level details of operating systems. There is a lot of content so making sure that you actually stay current with the class is very important (this is not a class you want to push off work). Learning how to read academic white papers is key to passing this class. Figure out which papers are heavily emphasized and concentrate on really understanding those papers. Make sure you have a strong C background or take the time before taking this class to really learn C. C++11 is required for the last 2 projects but I was able to finish those projects without any problems with just my C background. Make sure to start the projects as early as you can as that is key to making sure you have enough to complete the projects and address the edge cases.

Writing this mid semester to help others with registration decisions.

You need Linux running on your own metal for this course.

You need serious C chops.

You need passable C++.

Do not count on any compute resources (VMs or GT cluster credentials) being provided.

If these things sound new to you, get them ready before the semester starts, and start every project early to get past logisitical and environmental challenges.

Great content if you make it past those undocumented hurdles.

Demanding yet rewarding at the same time. The curve at the end got me an A.

The material was very interesting, and I definitely learned a lot, but some of the test questions seemed like they required more memorization of facts from the lectures than application of concepts.

Very interesting topics. Very interesting programming assignments. Tons of reading.

-It is a tough course. Requires on average 20 hrs per week and could easily reach 30 during projects. -Requires a good knowledge of C. Make sure to freshen your C skills before project 1. lynda. gatech. edu/ has some good beginner courses. Do check them. -Projects are released early and you have around 2 weeks to complete them. Always start them early and keep a close eye on piazza. A lot of good tips will be coming from your peers. -You need to keep some notes/summaries from lectures. Otherwise you will quickly get overwhelmed by the range of topics covered. Bhavin Thaker has created some awesome notes but covers topics form second half of course. Do check them https://www. researchgate. net/publication/299535414 -For mid and final exam, start early and keep a day or two only to read past papers and their solutions. Some of the questions/topics will be repeating in past papers and you need to focus on them.

I won't be exaggerating if I say this will be one of the most challenging courses you'll face in the program. I didn't know what I was getting into until the classes started, but quickly I realized this was going to be tough.

There's more material in this course that what you can cover without going nuts. The lessons are long and complicated, and each one comes with a bunch of scientific papers that you need to read and understand. I found the material fascinating but reading and learning the content of the papers will probably take some getting used to.

There are two exams in this class. Both are closed notes and for each one you have to understand a ton of content. The questions are not limited to single or multiple-choice which make the exams even more complicated. My class did very poorly on both exams, and we had to wait for a generous curve to pull our grades up.

I scored 57 out of 100 on the first exam and an incredible 75 in the second. These, together with solid grades on all the projects, gave me all I needed to finish with an A. Participation in the class was also a big factor, so I recommend you make yourself visible as much as you can.

By the way, be ready to code a lot. The projects were amazingly interesting and complicated, and we had to code like crazy to finish them. Any previous knowledge of C will certainly help you out here, but I although my C was very rusty, I was able to pull through after some long nights.

Not everyone was lucky on these projects, and a big portion of the class wasn't able to even find the solution to some of them. I'd recommend starting as soon as you get access to the project description because you'll need every minute you can get.

On this course you don't work on teams, so your success or failure is entirely on you. That being said, make sure you collaborate with everyone else in the class. That was one of the reasons I was able to finish all the projects and end up with an excellent grade.

Excellent course if you like learning system internals. You will learn a lot if you follow lectures and read 25% of the papers. If you read more you will gain even more insights. Professor and TAs were great. Programming assignments took their fair share of time but if you know C then you should be able to get them completed. Plan to spend good 20 to 30 hours on each assignment. Exams take time to prepare. Overall I liked this class and recommend it highly to those who have time.

PS: Don't mix it up with another course in the same semester if you are working and have a family. Good luck!

This is a wonderful course with very good content. Projects are very time consuming. Check out the videos on Udacity before signing up. I did not get a chance to go through the papers completely and relied on video lectures for most parts.

I am writing this review after dropping right before the due date of the first project, roughly a month into the class. Mainly had to drop because a newborn and toddler in the house made it almost impossible to get any work done.

That said, this class had a lot of required reading. Not the most interesting material to read through but it is scientific papers so be prepared to read papers several times. I think on average there were 3-4 papers per week. The first project seemed reasonable but a lot like the projects in IOS (which I took Fall 2015 and did very well in). You will fight with the autograder a lot and instructions were fairly vague. Good help from Piazza though.

From looking ahead before I dropped there is A LOT of material you are tested on in the midterm/final study guides that comes directly from the papers. This might be the reason that the test grades are so low.

I was excited to take the course but after spending just over a month in the course I'm glad I dropped it. Definitely information overload from the papers and trying to digest those left me exhausted when tackling the project. If the instructor trimmed down the readings a bit so you could focus on the lecture material and projects (where you actually learn IMHO) then this could be a good class. Until then I will not be signing up again.

Projects were a major pain, people did awful on the midterm and final, but somehow the polling shows a ton of people got As in the class. This should tell anyone that this class is broken.

If you start this class, don't drop it, because chances are you will get scaled to an A or a B. Here is a link to a grade distribution chart that showing there are very few Cs, Ds, and Fs given. http://critique. gatech. edu/prof. php?id=RAMACHANDRANUMAKISHORE#CS6210

This was my first class and I would consider it garbage. Yes, I learned a good bit and the concepts in the projects were good. Our class avg on the midterm was a 56. 5 and the median was 57. 75. The grades on the final were mostly C's. Even with such awful grades, I would say they were very gracious in the grading. I got a 77 on the midterm and a 73 on the final, and if they had graded them correctly I would have done much worse. I flat out didn't read the papers, and only studied the videos and my notes on them. I also didn't do the paper summaries and I somehow only got 30% on the message board participation. Actually there were people who posted hundreds of times and were very helpful that only got 2/3 of the participation points. Anyways, I got an 83 unscaled and somehow got an A in the class. Anytime a teach has to scale this much and has such poor test grades, the teacher is doing a poor job. From what I've read, I don't expect other classes to be such a mess though.

Its a great course. I have had previous experience with OS's and I learned quite a lot. The course requires consistent effort. Not much room for slacking off. I allocated about an average of 2 hours a night. The class consists of 4 projects, a midterm and a final. The course work is a mixture of lectures and academic papers. In order to do well, you must read and understand the papers, which can be long and dry depending on the topic. There are lots of papers to read.

The projects were interesting and not trivial. If you are well versed in C, then there wont be a big problem. If not, then you should probably get some practice.

Tips to do well,

• Listen to the lectures
• Read the papers
• Take lots of notes
• Start studying for exams at least a week in advance
• Start the projects as soon as possible.
• Participate in the Piazza forums

Hard course, huge workload, a few hard concepts, project specs unclear.

TL;DR

Operating Systems have evolved to meet user needs and system developments, and this course examines important developments operating system design, recognizing the influence of hardware advances. The student views lectures, read academic papers, constructs projects, and sits for midterm and final exams (also a brief homework, two paper summaries, and forum/class participation).

The material is expansive but interesting, and the student learns about important developments in systems, including parallel and distributed systems, hardware improvements, and network speed.

Lectures: cover important topics and explain important concepts, watching twice may help identify and understand more important topics/ideas. Professor clearly knows the material.

Exams: Midterm and final were humbling, vast amount of data, require precise details, previous midterms/finals available, most questions recur, focus on those topics.

Papers: read (nearly) 40 papers (required and optional), plus other relevant papers; learn to efficiently read and understand academic papers and glean important content, reread important papers.

Projects: require Linux (ubuntu VM), and good C programming skill; userthreads - learn about user space threads, scheduling, context swaps, signals, locking; barriers - learn about MPI, OpenMP distributed computing, barrier synchronization, write performance summary; web caching - learn about RPC, caching (LRU, LFU, LRUMIN), measure performance, test case bias; reliable virtual memory - learn about transactions and log structured files.

Projects take 30-60 hours each. Papers average 2. 5/week (2-4 hours each). Study for midterm and final (20-40 hours each). You will learn enough about systems work to decide whether the area interests you. I reread many papers, and watched most lectures 2-3 times.

Project specifications were ambiguous, students shared tests, share the test case writing workload, typical online challenges (questions, feedback), test proctoring had problems. I took 2 days off to study for finals, and 2 other days off to work on projects.

This class had a huge workload; there were project deadlines and exams every other week the semester, it seemed like. I took several days off of work during the semester to study for exams and work on projects to get them done in time. Workload fluxuated between 10 hrs and 30 hrs per week.

The material is really good, though. They cover all of the fundamental concepts, at some level, that are needed to create a large scale web distributed application, from threading to memory management to filesystems to network distribution and concurrency...

There are a ton of papers for this class. I spent a lot of time trying to read them all for the midterm, but didn't do as well as I'd have liked (although i was average for the class). I spent more time taking previous exams for the final and didn't read any of the papers, except to find solutions to questions, and did really well. I don't know that the same strategy would have worked for the mid-term, but I'd consider it next-time through.

Stay away from this class if you have a very busy work schedule. I was able to manage without much prior background in C but it took a lot of time. There are a lot of papers to read which is good and bad. Good, because you learn how to read papers quickly as you have so many to deal with. Bad, because they are time consuming. I think the biggest bummer for me was having a closed book mid-term and finals. I think that was just a huge waste of time cause you end up memorizing things which are just gonna be retained for a short duration. I liked the content though it can be surely improved.

The projects were actually OK, but you absolutely have to start at least 2 - 3 weeks in advance of the due date because you'll be coding in C and the low level nature of the language makes it very easy to make silly bugs, so plenty of testing and debugging time is needed.

Papers - yes there are lots of them, but I only skimmed through about 1/3rd of them, most I didn't even bother to read... but I did watch the video lectures thoroughly and took lots of notes as well and this was helpful because the instructor does a good job of covering the core concepts of the papers.

To prep for the midterm and final, I went through the review questions they posted on T-Square. This takes a while because you have to commit a good deal to memory, so make sure you go through these and also all of the previous midterms and finals (which they also post on T-Square), at least a week or two in advance of the tests.

Finally, to prep for the course, I would strongly advise that you brush up on your C coding. You don't need to be a guru, but make sure you have your dev environment properly set up with a decent IDE, and especially know how to debug programs. I didn't have to use valgrind for any of my projects thanks to the copious amount of unit tests that I wrote, but for the final project I did use valgrind to help me locate a bug. So it can only help to be familiar with that tool.

Make sure you also participate in Piazza - those are easy points you don't want to give up ;-p

Good luck to everyone!

This course is extremely difficult if you are not a well versed C programmer. The time commitment to carry the reading work load and lecture material is not to be underestimated.

This is a tough class as many have said. I think the hardest part is of course the mid-term and final. It really does require knowledge of about 36 white papers in order to answer the questions on the exams. I came across 3 questions on each of them that i had no idea what paper they came from, let alone what they were referring to. I spent days cramming, and re-watching the lectures.

The projects are not impossible, but are very time-consuming in order to write, debug and get to pass auto-grader, and corner-case testing, however, given enough time (2-3 weeks) you can complete them. I completed 2 of 4 with A's but they took 40+ hours to get that over 3 weeks. I am a novice C programmer, so that was my downfall. I'm sure others with a high level of C programming did them in half or less time, but they are covering subjects and APIs that we are given and forced to use, that come with no instructions, we had to fumble about them to figure out how to use them correctly.

IOS will help, if you are not fluent with C. Overall this is definitely one of the harder classes in the program, BUT I did learn a lot, and I'm a better C programmer because of it.

OH one more weird thing... the PIAZZA participation grade (3% overall), seems to be based on an algorithm of Days logged on, posts read, and contributions. The number one contributor gets a 3, everyone else gets something less. There were just a few days difference between our top two contributors (600+ posts each), and one got a 3, while the other got a 2. 9. I had 87 days, 479/607 read, and 58 contributions, and scored a 1. 2 out of 3 points.

I took IOS in Spring 2015, AOS in Fall 2015. IOS was a good basis when you're not already familiar with C and systems programming. Every lecture walks students through a single paper, explaining the concepts and adding historical, academical context. The selection of papers is very good, it's a journey through landmark ideas in systems research. Reading all the papers was impossible for me with a day job and hobbies. I resorted to reading the abstract and summaries (provided by peres as part of course requirements) for about three quarters of the material. The grading of projects and exams seems fair and forgiving. The projects are tough and require recognizing challenges and coming up with your own designs for them. Also you have to write your own test code, which can be a substantial part of the project. It is always recommended to start working on the project 2-3 weeks in advance to be able to ask questions on Piazza and also just to sleep over it and find solutions to problems. They are definitely not "just doing the exercise". The course requires a bit of investment, but offers tremendous learning opportunity. I was also constantly drifting off into the subjects covered while browsing through Wikipedia, research papers and technical manuals.

Challenging course, especially for those who are not used to reading and learning from a bunch of technical papers -- the whole course is based on a set of 40-50 technical papers in the operating systems arena. Instruction videos were good, covered the content well. The papers were mostly interesting. Student evaluation:

• Tests - two tests that make up 46% of your final grade are brutal if you don't have an eidetic memory to remember all the content of all the papers. On the final, of 49 students participating in a pole, only 1 thought they got a 90+, 4 thought they got an 80-89 and down, with the largest group < 59.

• Projects - four projects make up 48% of your final grade. The projects were challenging if you aren't a good C programmer, but not overly so. They were a bit under-specified which made it hard to know for sure you were doing things the "right" way. Much of our discussion on Piazza was in trying to interpret what we were supposed to do about edge case X or edge case Y.

Hoping for a strong curve....

If you programmed in C/C++ for at least 2+ years professionally, the programming assignments are not difficult at all (most are toy programs), but I'd imagine it's be different for people who wants to learn C at the same time. The TAs are very responsive and helpful on the forum compared to computer networking which I also took. The video lecture are not succinct enough for my taste, I feel like they can be 30% shorter. The midterm & final tests are not that useful, you'll soon forget the memorization you cramed during the tests. Also, even you understand 100% what is said in the video, unless you study the past exams, you'll not know what you need to remember in order to do well in the exam. For me, I never read the assigned paper (typical academic paper that don't get to the point, 10% of them are well written, the others are painfully boring to read), I just prepare flash card from past exam paper, spent one solid week+ to recall all the answer before the mid term and final and got A in both tests. A great 70-80% of the questions are repeated from past exam. If you can score 50%+ for the rest of the new questions (which they also give you study notes without the answer key), you can easily get a solid 80%+ score in each test and secure your A.

Overall I liked the class. I thought the projects were great. Definitely should go into this class with some C experience (or don't be surprised when you have to learn it). Exams, like others mentioned, require a lot of memorization. They gave us review questions just before the exams which you should definitely spend many hours going over and over and over again. My biggest complaints are the long delays in grading time and lack of participation in Piazza.

The wide time range is because I tended to complete the projects in one continuous rush once starting them. Other than that, there are a lot of lectures to get through and papers to read, but no hard deadline for them other than the exams. I'd recommend getting as much done ahead of time as possible, but the class offers a lot of flexibility with the time demand. I'd never written a line of C before taking the class, but was familiar with C++. The projects took about a weekend each, but every hour of that weekend. I spent far more time in the first half than the second half after realizing how questions are effectively recycled for the exams from past terms. They provided us with review questions and past exams with solution keys. Use those to guide what you memorize in minute detail and you can cut down how much you need to study.

Disappointed by the content so far. Rote exams, with little insight required. Projects are fun. Detesting all over again the online exam format trying to draw diagrams with computer tools. Will update this again later. This is not what I thought would be Advanced OS and not learning something useful. This course has precious little to do with advanced operating systems concepts and more to do with 1) history of OS concepts, and 2) applications sitting on top and using OS resources and applying computer science concepts of data structure and algorthms Advise you to scan through the videos as soon as you get access and decide if the content is worth it. https://www. udacity. com/wiki/aos/video

I had trouble coming up to speed with C (as well), but as the course went on, my skills improved. To me, the projects were more difficult because of the language than because of what they were asking for. The lectures (videos) were terrific, but I found that it was a large amount of content, and as the first class I've been in for quite some time, it was hard to get back into the mode of learning.

I really enjoyed the projects- they were fun, if not a little time consuming. The exams were tough but fair and they did provide a lot of study material. The exams covered some material that wasn't explicitely covered in the lectures, so you need to keep up on your reading. A lot of the material was older (some papers from the 1970s) but it does give a good foundation to relevant topics. I guess I found some of the lectures and material a bit tedious, but overall enjoyed the class.

The assignments were fun, of fair difficulty and useful to the learning process; it helps to know C in advance. The tests are difficult and sometimes seem focused on minutia, but if you invest time into study, you are given all the necessary tools to do well (everything can be answered between the papers and the lectures, and sample tests are given so you know you're going in the right direction). It's going to take a lot of studying, but if you do well, you will have truly learned a lot from the course.

Professor Ramachandran is great educator. He delivers lectures in clear and logical manner, so even if in progress you have some questions, by the end of the lecture it is all clear. Projects in C could be overwhelming for someone without experience, but not impossible. All what is on exam is covered in lectures, and sample midterm and finals are given, so it is very clear what is the scope and the format of the answers expected. Highly Recommend.

I'm a C# coder, so getting up to speed in C took some time, but I had a lot of fun learning how to code in C. It was interesting coding in a way that one would just take advantage of a library in C#. Definitely get started on your assignments early.

The course material was very interesting, and I will be applying what I learned in this course to aspects of my job. I didn't get into the papers in great detail, I found the lectures provided a great summary of the papers.

If I had one complaint about this course, it would be that the assignment turnaround was a slower than I'd like.

You might be in autograder hell for some of the projects. Pay little attention to students who say they studied only 5 to 10 hours a week. It's a lie. You can't even do a good job reading and taking notes for papers in that much time. Of course, you can memorize/parrot all the material in the videos (including the pecuilar pharses) and get an A, but you have to ask yourself if that's what a quality graduate course should be about.

There are two distinct components to this course and your grade. First the projects. There are four of them. They are interesting and challenging. You will need a strong understanding of C to do well. If you are a C guru expect to spend about 10-15 hours for each project. If you are weak or new to C this time estimate could easily be trippled if not more. The second component is lecture and reading material. It is complicated stuff. You could easily spend 20 hours a week understanding and trying to memorize all the academic paper assignments. The two exams will quiz you on this material and you honestly need like a photographic memory of the material to do well on the exams. Considering the average mid term grade was a 50%, I don't think many of us have a photographic memory.

There's a lot of content to cover and its diverse. My mistake was taking it easy till the mid-term, because of which the rest of the semester required putting in 4 hrs per day during the week and pretty much all of the weekend. This despite enjoying the course and doing generally well on the assignments. Could be because I'm coming back to studying after 16 years too. Tip: Download the videos and watch them at 2x speed in VLC.

Definately had to relearn C to succeed. The rest is videos, papers, flash cards, and test prep.

The workload is flexible depending on how deeply you want to read the papers. The video lectures are more or less sufficient for the exams, the paper reading is more for personal gain(and 1 or 2 for the projects)

I discovered too late in the semester how helpful the papers were. There was a large spike of time spent on some of the projects, but that might have been because I had never seen a line of C code before.

The class content can be time consuming if you don't have any background, but the coding assignments are the time consuming part. If you are a master of C (or at least competant), then you should be fine. About 2-3 hours of class content, 1-2 hours of reading papers (depending on how fast you read and comprehend some of the papers are hard to get through), and 2-8 hours of coding per week depending on the assignment.

test require a week to learn in advance. some assignment took me more than 20 hours.

In retrospect, I didn't have the prerequisites to take this course and it took a while to get up to speed. I studied hard and did well. You need to know the material pretty well to do well on the exams. On the other hand, it was literally, the best course I have ever taken. I loved it.

I loved this class, specifically the projects! I thought they were exactly what I was expecting out of a CS master's program. If you can figure out the autograder on the first project (GTThreads) you'll do fine. I spent SIGNIFICANTLY LESS time on the other 3 projects. Also, do not overthink the exams. They really are 'just parroting' (like Brad Cain says above) back what is in the lectures and the previous midterms that are given to us to study. Also, I think that the name of this class should be 'A History of Operating Systems'. It's really all about the innovations in OS design over the years and NONE of the operating systems that we study are still in use today. Again, REALLY great class, I enjoyed it thoroughly!

Great class. Prof Ramachandran does an excellent job of building intuition on operating systems. The projects were challenging but very satisying once you are done with them. Definitely brush your C knowledge otherwise you will spend uncountable hours trying to debug a seg fault. Pro tip : go through the exam solutions from previous semesters verycarefully and you will do very well in the exams.

Taking course in Fall 2014 and putting in a lot of time. First assignment (of four) took me about 75 hours and I have a feeling I still didn't do very well. (I am still waiting on the grade. ) Getting ready for the midterm exam now and feel like there is an overwhelming amount of material. Challenges that may be case-specific: Working a full-time job as well; Low - Medium experience coding in C

I thought the assignments were quite interesting (especially the first one) but not too hard, probably because I've done quite a bit of C coding and system programming. I found the lectures and papers to be not terribly interesting; most of the material is from the mid-1990s, although the section on VMs was pretty good. The tests are unimaginative... if you can parrot back what you saw in the lectures, you'll do fine. (Contrast with CS7641, which had very challenging and interesting tests. )

Good course with enjoyable lectures. Lots of papers to read. 4 assignments in C. Not a lot of feedback from instructors, unfortunately. We didn't start getting our assignments back until after the midterm, and my last programming assignment wasn't graded until after the final. However, the course materials includes a number of previous exams and their answers, to get a feel for the kind of answers they expect on the tests.

I enjoyed the programming assignments, although I can't imagine trying to pick up C at the same time. The autograder was quite glitchy, a major time sink. Hopefully that's fixed now that it has had a few semesters. The exams were terrible exercises in memorization, no real analytical thought involved. Time commitment spiked around exams.

I've learned a ton in this class, and have greatly enjoyed it. The exams were frustrating because you basically have to memorize an absurd amount of detail and regurgitate it. You must be good at C or be able to pick it up quickly to do well in the class. The projects were my favorite part, and have taught me a great deal about operating systems.

We can divide this course into three main pillars: Papers, Projects and Exams. Projects: Heavily dependent on C and linux command line tools. So, if you are not familiar with C, consider learning it before the class. Projects itself are interesting and challenging to solve. The time provided is fair. Paper: This class has a lot of papers to read, be prepared to read 15+ papers. Need to understand every detail ( check next paragraph why ) Exams: You need to memorize past exams questions and majority of detailed information available in some papers. Tip: Start the projects as early as possible !

Hours got lower per week as I came back up to speed with C. However, because the midterm was brutal for me, took more time near the end to study for the final which may have not been necessary. Better safe than sorry. Undergrad was back in the mid 80s for me so needed a little ramp up time as well. I concur with Andrew Wolfe with the exception of reading hours. I required more hours for reading per week.