This was my first class in the OMSCS program. I come from an engineering (Non-CS) background but currently work as a software engineer.

This course helped me understand a lot of the fundamentals behind how our software works in conjunction with hardware. I mainly code in high-level abstraction, so learning C & C++ was a good exercise to understand how things are managed under the hood.

For the most part, I spent around 3-4 hours watching lectures & taking notes every week. The only other grade are the projects - which were high intensity for short intervals for me.

I didn't really track the estimates for how fast I completed each project, but I started each right when they were released and worked intensely on them until I was just about complete.

For project 1, that was the hardest project. Took me around 25 hours to complete. For project 2, understanding the project requirements were difficult for me and took around 18 hours. Project 3, although easiest, was difficult for me to understand well because it's the only project in C++. This project took maybe 12 hours.

The exams were difficult but I stayed consistent to my lec studies, so they weren't took difficult to study for (I also did very meh on them).

All in all, other than the weeks where I worked intensely on the projects, it was nice to learn the theory and facets of OS throughout the semester.

I have finished my GIOS course during 2024 Fall. I got 80% and still ended up with A (prob due to the participation credit). I spent around 15-20hrs per week on avg. I am EE major in undergrad and learned basic C/C++ during graduate school. Belows are my likes and dislikes about this course:

Likes:

1. Projects are well structured and designed to help you understand basic OS better 2.TAs and peers are very nice and helpful, especially in Slack. I am active on both Slack and Piazza and i think that's why I got A with 80% score.

Dislikes:

1. The lectures are not very well explained, especially the second half of this course
2. The exams are not very well-designed for me. Too many memorizations and does not help me understand the course better as the projects. Also, the exams weigh 50% of the total score (too high!), which is even higher than 3 projects in total.

For midterm exam, I only got low 50s (20 lower than the lower quantile, I do not what happened lol). For final exam, I just achieved median score 70. Overall, I feel the number of the questions are too few so that if you missed one question and it will cost you 15 score or even 20 score! Also, i feel some questions are not very emphasized in the lectures so I did not pay too much attention to.

For projects, i got 100/100 for all of three. I do NOT feel the last two projects are easier than the Project 1 like others(people may spend more time getting familiar with C/C++ in Proejct 1 instead of project itself). In terms of design and understanding, Project 3 and 4 are more difficult than Project 1 to me. However, they all cost me about 60+ hrs to finish each.

GIOS was a great class with medium difficulty and a pretty high workload. I'm glad I had a bit of background in C/C++ beforehand, but the projects definitely leveled up my low level programming skills. The lectures were super high quality and I feel like I came out of the class understanding a lot more about how computers work. Definitely take this if you haven't done an undergrad level operating systems class, or want an intro to multithreaded programming.

Undergrad in CS(didn't take an OS class), couple of years in the industry. Found the class challenging, especially project 1 and the exams, especially the final. I ended up with 79.25 which was curved to a B. I believe the cut off was somewhere in the low 60s for a B and low 80s for an A. So the class is definitely doable, even if you have no experience with C which was the case for me. I would rate the projects in this order from easiest to hardest. project3, project4, project1.

Coming from a non-computer science background and having this as my first class, this class was very good at setting a foundation for what academic cs classes should be like. As it's easier to write the negatives out, I'm sure the rest of this review won't align with me giving this class a 5/5 so make no mistake: this is excellent class has excellent TAs. The content is invaluable to anyone with an academic background that hasn't done any academic cs.

As with a lot of cs, the material itself is straightforward, but the devil is in the details. If you've never actually opened sockets, sent data out via buffers, etc. (like me) this class will be difficult on an implementation level. I would imagine if you already had a lot of Linux C experience that this class is fairly straightforward and not entirely different than an operating systems course that someone would find at an undergraduate level.

Projects: They are conceptually straightforward with a good amount of boilerplate to get you started. The one con I will mention is that the projects are essentially all or nothing - my implementation of project 3 part 2 worked locally for every test case and check that I could throw at it, but it didn't pass the hosted tests when I would turn it in. Because of this I essentially got 0 points for that part even though I had a 95% working piece of software. I suppose this is an unavoidable part of a massive online program. Even with this however I still got an A, so that class is very forgiving in that sense.

Tests - I think the concepts that are taught would be better suited to a large multiple-choice exam. Not a few multiple choices and then a few middle school math word problems. It's easier in this current form but doesn't feel quite right.

Background: Non-CS bachelors, working as a software developer for 3 years. Ended up getting an A.

This course was extremely useful as someone without the standard CS academic background. It helped me understand and become conversant in many different aspects of CS, and is great first foundational course that I'm sure will help in all the courses to come. It's not easy, but I didn't find it quite as challenging as I anticipated based on reviews.

An earlier review says that they felt they "leveled up" by taking the course, and I echo that sentiment - I feel like I have a much better idea of what I'm talking about when it comes to lower level software concepts now.

Let's break it down:

Lectures: A bit outdated, but they touch on fundamental CS concepts that are still 100% in use today, so it's not that bad. The professor does a good job and the concepts are clear and intuitive. You get about ~2 hours of lecture material per week, and usually a paper to skim - try to keep up on these even in the depths of projects.

Exams: I got a high 80s on the midterm, and a mid 90s on the final. I studied pretty hard for these, at least 2-5 hours a day for a week until I took the test, maybe more. They aren't easy, but they are fair - use omscs-notes and other resources to summarize the lectures instead of going through them again, read their practice solutions, and think about what core concepts they really want you to know. Focus on the math problems from the lecture, they're fairly simple calculations and will always show up in some form on the tests. I found you don't have to focus too hard on paper details - the lectures cover the relevant parts of the papers. Focus only on the papers that come up a lot during lectures and on the practice tests - everything else can be ignored.

Projects: The big timesink. I got high 90s on project 1, 100 on project 3, and 100 on project 4. Another reviewer complained that it was like inheriting a big codebase and having to dig through it to find the relevant parts and ignore the rest. My response is yes, that's how software development works - at least here, they tell you which files to focus on, where to put your code, and which files have been abstracted away for you. In this field you will encounter obscure codebases routinely and have to learn it fast - this is important practice. Digging through documentation is not a chore, but a practical part of the job - treat these projects almost like practical work experience, and you'll see your whole mindset towards them changes. And you need a good mindset - these projects are long. I put ~60-70 hours into project 1, ~50 hours into project 3, and ~30-40 into project 4. They aren't necessarily too difficult if you have a solid grasp of C and know how to read documentation efficiently, but the time comes from reading documentation, the codebase, and using slack/piazza to carefully figure out requirements and solutions.

Overall - It's a very hot/cold course in terms of workload - during projects you pull 30 hour weeks, but if you hand them in early you can find yourself spending 3 hours/week just keeping up with the lectures. The material is very valuable - the lectures teach you fundamental OS and computing concepts, while the projects are more like system design work projects that will test your understanding and build your development muscles. I should also mention the course is well run and the TAs are very solid.

My advice - start each project EARLY. I mean it - the day the project drops, at the very least you should be reading the instructions and fetching the codebase from git to poke around it. Each project gives you four weeks - if you wait even just one week to start, you have wasted 25% of the allotted time - that can be devastating. I ended up finishing each project in about 2 weeks, so that gave me 2 weeks to either rest up or begin studying early for the exams. If you hand everything in last minute, you will find yourself immediately having the midterm/final bearing down on you, with not enough time to study - a recipe for disaster. The course is paced so starting projects early and finishing them early takes a LOT of the pressure off, so please do so. Finishing project 1 early gives you a ton of time to prepare for the midterm - finishing project 3 early gives you some true rest time, as there are no exams afterwards and you can chill, I had two weeks where I put in 3 hours for the entire week - finishing project 4 early gives you prep time for the final.

Another piece of advice - learn C before you take the course, especially pointers. Just do Beej's guide to C programming and Beej's guide to network programming (most of the former, especially pointers - the latter you can just read the first six chapters and be done). This will help a LOT with the projects.

Learn C beforehand, keep on top of projects immediately, put a decent effort into studying for exams, and this course will not seem so bad for you. I felt pretty relaxed the whole way through, which I mostly credit to the above.

This was my first course in OMSCS. I am from a non-CS background and had no knowledge of computer architecture. Initially, I spent more than 20 hours every week watching lectures and solving quiz problems. The lectures are very straightforward and provide a good foundation even if you come from a non-CS background. The professor did a good job in covering such a vast number of topics in a more concise way. The final exam preparation can be quite stressful as the syllabus covers all the chapters, including midterm; however, if you keep good notes, it will be easy to brush up and recollect what you have read. Revising the lectures at the end can be quite a nightmare. TAs are very helpful in answering any question that you have, and attending office hours can give you a sense of what you are learning. Regarding the projects, if you have good proficiency in C++ and watched the lectures thoroughly, then you can finish each assignment in 15-20 hours. For me, it took 30+ hours for each assignment, as it demanded manipulating complex C++ code. Overall, I liked the course material and the class lectures. At some time I feel it is bit outdated as it doesn't talk about today's high-end servers and GPUs.  I ended up getting an A. If you want to get a basic understanding of computer architecture and its hardware, go for it. 

The lectures are good, they are well structured, educational, and pretty intuitive explanations. They are relatively easy to watch, and focus on the theoretical. The exams are pretty true to the lectures, although they sometimes test you on minute things from the lectures that I think don't really matter and shouldn't be tested on.

The projects, however, are completely awful. They easily take 80 hours each, and most of the time is reading documentation. The instructions are pretty high level, and most of the work is reading the codebase, trying to understand how everything fits together, deciphering the meaning of variables and how functions interact, and figuring out what code is missing. It's like the projects are a machine with missing parts, but you don't know which parts are missing, and you don't even know what the other parts do or how they work. On top of that, you have to spend many hours reading documentation for the libraries and standards you use, like gRPC, POSIX, etc.

For project 1, you should read all of Beej's guide, and then somehow absorb as much as you can so that you can use the same plug-and-play code without flat-out copying the guide. So your project will end up being over 50% boilerplate code, but you will be worried the whole time that it might be too similar to Beej's guide and will be flagged for plagiarism, even though this code is very standard and boilerplate and everyone's code will look extremely similar.

For the second project, you want to watch the whole 1hr youtube video in the project instructions that shows different IPC libraries. This will be very helpful.

Overall, this course is very difficult, but not for the reasons that a course should be difficult. The coding was like inheriting a codebase with minimal documentation and having to figure out how everything works. The lectures are basically no help with the projects. It was more about will power and learning to read complicated codebases than it was about OS. I think I might get an A, if not definitely a B, but I regret taking this course.

My background: a non CS major working a non CS job. I have a 1 year old and my wife also works full time. I had zero experience in C or C++.

Because of my background, this class absolutely destroyed my life for 3 months. I spent easily over 100 hours on project 1, 80 hours for project 3 and 50 hours for project 4. I will end up with a B for the class mainly from burnout. Didn’t work too hard on last project and test.

All that being said, this was the most interesting class I have ever taken and would recommend it to anyone that didn't take the undergrad equivalent or wants a refresher.

Simply a must-take course. I took it hoping it would be a “level up” experience and that’s exactly what it was. It’s hard, it’s a grind, and it doesn’t let up at all, but it’s worth it. You’ll come out of this class feeling like you can conquer any computing problem that’s thrown at you.

I felt that the course thought the core concepts of Operating Systems very well and in depth. The projects were also really good for getting more experience with the lecture material. Textbook is recommended but I never used it, and I didn't read the recommended articles/readings either and still got an A. If you're inexperienced with C and this is your first OMSCS course, the first project will likely be the most intense (For me it took twice as long as the other projects). Exams really just test how well you learned the lecture content. Use the provided Slack group as it's very useful for troubleshooting project issues.

It's a very solid course that is true to the title. I wanted some foundational knowledge of Operating Systems and this course gave me exactly that. The lectures are quite well-organized. The professor holds regular office hours and is genuinely interested in the subject. Grading is reasonable, and there is a generous curve for those who need it.

The downsides are:

• Project documentation. The project asks for things that can be improved on for extra credit, yet they don't improve the horrible documentation. It's not fun trying to figure out how the handler function is supposed to behave and it really teaches you nothing.

• TAs. They are nearly absent from Piazza. Slack interactions with them are mostly horrible with a few exceptions. Some of them have sort of a weird complex. Not only are they snarky and condescending, but I realized a few months later that they have no idea what they are talking about. Being a "Head TA" and still being a clueless jackass is really a feat.

I am taking a point off solely because of the moronic, terrible Head TAs.

All in all, this was a solid course, and I would recommend it to anyone considering taking it. It teaches some foundational concepts in CS and has a good blend of lecture content and projects. It is difficult, yet manageable with good study habits.

It is particularly well-suited for an early course in the program, because of its helpful Slack community.

Pros:

• The projects are easily the biggest strength of this course. They are well-designed and teach you a lot. There is also a great Slack community where you can bounce ideas off each other. If this course didn't have projects or the Slack, it would be 3/5.
• The lecture content is sometimes unorganized, and had many small errors (see below), but is generally pretty good. These topics covered are important and will make you a stronger software engineer.

Cons:

• I never see anyone talk about this, but there was a huge amount of errata in the course content. It irritated me quite a bit, especially considering this is content they prepare only once and reuse indefinitely for all future semesters. Why not take the time and get it right? There was constantly incorrect content in the lectures (sometimes with errata noted in the text underneath and sometimes not); incorrectly configured (practice) quizzes; strange typos and inconsistent formatting in the project code. It boggles the mind. It just doesn't seem like the level of professionalism you should expect from a top-10 CS school.
• The exams are annoyingly trivia-heavy. I spent a lot more time studying the content than working on the projects.
• TAs are generally not very helpful or responsive on Piazza.

Advice to those taking the course:

• Read the K&R C book before taking the course.
• Join the Slack.
• Do your best to keep up with the weekly lecture content.

Video version: https://youtu.be/gReO33VcgHk

This is a great course, especially if you've never taken an Operating Systems course before. It's very comprehensive and covers topics like system calls, processes vs. threads, multithreading and mutexes, pipelining, memory management, inter-process communication, virtualization and remote procedure calls. Lectures are clear and contain useful metaphors. The two exams are fair and emphasize problem-solving, so while there were relatively few questions they took me the entire time to complete.

The projects are only loosely tied to the lectures and are much more practical. You mostly work one level of abstraction up, so instead of working at the kernel level, you use C code to make system calls to the operating system. These projects were probably the most challenging of any I took in OMSCS. Project 1 took me about 90-100 hours, Project 3 took 70-80 and Project 4 took about 20 hours to complete the first half (I didn't do the second half due to burn out). I highly recommend getting hands on experience with C programming, especially debugging with tools like valgrind or gdb, because that was the biggest time sink for me. If you already have experience with C or C++, you can probably expect to spend about half as much time on the projects. Also, don't waste your time aiming for 100% on the projects, there are a few hidden edge cases that took a disproportionate amount of time to pass.

I think the quote "Nothing good comes easy, and nothing easy is good" applies to this course. As someone who didn't do a computer science undergrad, it definitely made me a much better programmer, but I also felt pretty burnt out at the end (outside life events also contributed). Still, I highly recommend this class to anyone, unless you took a very similar course in undergrad.

Background: non-CS undergrad, 1st OMSCS course Likes:

• Lectures have high production quality, are bite-sized and easy to digest
• Rewarding projects
• Active Slack channel (just reading discussions there helped me a lot with projects)

Dislikes:

• Midterm and finals are trivia-ish in style and do not test your understanding

Remarks: To echo another OMSCS student: this course actually consists of two mini courses - 1 in OS theory, and 1 in systems programming. If you are not familiar with C (like I was), be prepared to spend a lot of hours. I focused too much on projects (the systems programming mini course) and thus neglected lectures and papers (the OS theory mini course). I should have paid more attention to the OS theory mini course as it weights more (exams are 50% of final grade) and is more interesting. However, the exam format and style are a big disappointment.

Background: non-CS bachelors degree with no relevant work experience. Completed a very basic C course on coursera prior to semester starting.

This was my first course in the program and I am happy that I took it. It was hard enough to build back some good study habits/discipline, but not too hard. The projects were fun and interesting, and I'm definitely a better engineer now after taking this class. The reason I am giving this class a 4 star rating is because the lecture material is so dated. I believe they're about 10 years old now.

Overall, I finished with a 95 in the class. The cutoff for an A was 84 iirc, and around 74 for a B I think.

I highly recommend this course for anyone coming into the program without a traditional background.

This was my first course in the program, I spent on average 15-20 hrs/week and received an A (above 90 on projects, mid 70s on exams). I have a degree in chemical engineering but work FT as a SWE. I came in without a background in C. There was a lot of information that set a good foundation going forward in the program, and in general I feel that I've filled in a lot of gaps in my lower level knowledge just from this course. The projects were challenging but not unreasonable, setting aside the time early on and being thorough with your design before implementing is important. I found the exams to be more memorization based and not particularly challenging. There is a wide breadth of topics but it did not go too in depth on the actual implementation. This is a great entry point for individuals without a computer science background.

It was a great class to learn the basics of C and setting up environments for dev and debugging. You would learn all about threads, IPC and RPC so if you think you will be dealing with any of these in the future you MUST take this course or you will have a difficult time understating what your collogues are talking about. The course has a midterm and a final both closed book and very difficult (50% of total grade), I got 70 for both and I studied pretty decent for both. There are 3 projects, each at 15%. These are your chances not to stress over midterm and final later on. They are about multithreading, IPC and RPC. If you spend time on them you can get 100% but needs time. One piece of advice, make sure your environment is setup in the first week of class and remember each project has multiple parts, the first part is for you to learn how to use a tool (like gRPC) but learning a tool is just to get you started for the actual parts coming after, so learn them fast and just enough. I personally didn't have time to study during the days so made it very hard for me but even with my tight schedule i was able to get an A but that said, i worked hard at nights so do not expect an easy A or even an easy pass in this class.

I feel like this course's difficulty varies a lot from person to person. I was a CompE undergrad with prior C/C++ experience, so the projects were not a steep learning curve for me. The content overlapped with my OS and CompArch undergrad class. Many topics were only covered on a surface level but provided a good segue to later courses.

I spent about 10-15 hours on each project. What worked for me was starting in the last week, as by then Slack and Piazza would be filled with clarification questions that ideally should have been addressed in the project's description! However, do try to understand what you are implementing as early as possible.

My exams were in the 60-70 range as I didn't study as hard as I should, but since I finished all projects, I still walked away with an A. If your main concern is the letter grade, I don't think this class would be too difficult.

Overall, if you're a CS/CompE undergrad, I think this course might be skippable since the content overlaps, and you might not gain as much educational value from the projects as non-CS students would. However, if you're like me and just want a refresher or an easier semester, feel free to take it.

This class was a good first class, but I came in with decent C knowledge. I procrastinated on the final project (and I had no C++ experience), and it really bit me. I still ended up with an A, so I guess that goes to show that you can bomb a project and still be ok after the curve. Exams were easy in my opinion, but some people found them pretty difficult. My main piece of advice is to start projects early and use the resources recommended by TAs and other students in the Slack channel.

This was my 7th course in OMSCS. I do not have a CS background or undergrad.

I have to admit this course threw me off at first. I was very confident going in because I have a knack for learning new programming languages very quickly and excelling at them - I'm sure many of you can relate. I have 4.0 in the program and have taken many other difficult courses without too much struggle. I thought this one would be the same - especially given the "intro" title.

For me, I spent more time on this class than any other. If you do not know C programming, you will struggle at the beginning. Fluency in modern languages like Java or Python will not completely translate to you quickly understanding C.

For the non-CS background people reading this, when you program in C, you really need to understand how memory is allocated on the stack and the heap - many modern languages handle this for you. If you don't have a good grasp of memory allocation, I strongly suggest you search YouTube for videos explaining stack vs heap and what parts of your program are allocated to each.

Project 1 was very hard for me. For the first time in my life, I was facing down an 8 am deadline the night before with code that came nowhere close to passing the auto-grader. I wish I had taken all the advice and learned C programming in advanced.

Because I was struggling and frustrated, I initially hated the content of this class. But as the course continued, and my grasp of the C language improved, the course got easier. I ended up getting an A thanks to the curve.

Looking back in hindsight after the frustration has passed - the content of this course is really good. This class covers a considerable amount of an undergrad CS degree. So if you are like me and feel like a "CS imposter," this class will fix that.

In my job I get pulled into interviews for developer positions, and I have started to ask interview questions derived from this course because I now understand how critical these fundamental topics are to success as a developer.

The course material was very useful and practical. My current role is as an embedded software engineer and I have been able to put some of the principles to work right away.

The workload for this course was much heavier than I would have expected. One good thing is that the projects are typically made available 4 weeks before their due date. Overall, I found the projects to be enjoyable, just too much work for one three-credit course.

There is no textbook for this course, but several interesting white papers are provided as reading requirements. Most of these are more than 15 years old , but they are helpful at providing historical context with regards to operating systems and the concepts generally still apply.   Only the first half of the course actually focuses on operating systems. The second half of the course focuses on cloud and distributed computing.

To be successful, you will need to be able to write code in C and C++. Many of the projects build upon work done in the previous projects or parts of projects. In order to avoid rewriting the same code over and over again, create abstractions and focus on implementing one piece at a time, rather than doing everything at once or using really long functions.

Some of the projects do not directly relate to the course materials, which was frustrating. They are there to prepare students with practice and background ahead of the main portions of the project. However, everything is graded, so to succeed students need to write a lot of code.

The TAs were generally responsive. Although sometimes they could be condescending when responding to students (many of which already have many years of work background in software development).

There are two exams, each covering around half of the lectures. To prepare for the exams, students must review all of the lectures and white papers. The TAs do provide some crowd-sourced class notes from previous semesters, which are very helpful in preparing for exams. To prepare for exams, I would recommend taking notes as you go, reviewing all the class notes and reading the white papers highlighting any information that you think might help for the test. Some of the test questions were on obscure details from the white papers, such as recalling and comparing specific benchmark tests. Even with a lot of studying my test scores were in the low B range. Fortunately, the projects use gradescope and by starting earlier and refining their work, most students should be able to get 100% on the projects.

Background: Non-CS. First course.

This course is life changing. It made me someone from only being able to solve algorithm problems or fix easy software bugs to feeling confident in saying "yes, I code, at least sometimes." If you have a better background than me then it should be doable with less time.

Because of the slack community, it gets even better. This is where you make friends and discuss future course or even career plans. I would still take it as a first course even though it's a little too tough sometimes.

Don't worry about the documentation or exam. There's a generous community (if you care about learning and the projects) and a generous curve (if you care about the grade) to make up for some shortcomings people complain about, and the flaws resemble what you will need to deal with in real life more so it's even better.

Project2 is the best. Don't miss it.

Grade: 90% (A) 100% on autograder, lost some points from readme. 8X% on exams

This was the first course I took in OMSCS. I do recommend it as a first course because it is challenging enough to force you to re-learn good practices for keeping up with coursework.

I work in SW development, primarily in C and Java. I have only done a bare minimum amount of C++ programming back in my undergraduate days. I took this course as a refresher and to help me re-learn how to be a student. I worked full time while taking this course and I spent about a month on business trips. My biggest challenge was time management. It wouldn't have been bad if I was not traveling so much. I didn't sweat the actual material because it was largely (not completely) review.

Projects: My biggest and only complaint is that the project requirements and specifications were distributed and vague. The git hub pages posted most of the information and a general sense of required end behavior, but some of the specific behavior could only be confirmed through documentation placed inline with with code and/or piazza to clarify gaps in the specification. I had to use gradescope with every project to make educated guesses on what behavior they were truly looking for based on the test cases I was failing. This - guessing my way around vague requirements - ate up more time and brainpower than actually implementing the code.

That being said, the projects were non-trivial and pretty fun to work on. There was enough room for creative freedom to make unique choices in the project in terms of how to implement certain behaviors, backing data structures, and overall data flow.

Do you need to know C: Yes. It will make your life easier. Projects eat up your time due to the complaint mentioned above. Spend your time and brainpower fighting with the vague project documentation and not learning how to code. C is not a language you can improvise your way through. They have memory sanitizer and Valgrind checking your deliverables for memory leaks. The code has to work and it has to be well written.

Do you need to know C++: Not really. I barely remembered anything about C++ from undergrad, but I know OOP very well and I know C very well. I was able to BS my way through C++ coding with that knowledge, and you can too. It does make the last project take a little longer to do, but I don't think it's worth learning C++ over.

Project 1: Had three different sections total, I spent 1 weekend per section. 1 day to code, 1 day to test. (~ 20 Hrs. Total) Project 2: Part 1 ~6 hours; Part 2 ~20 Hrs. Project 3: Part 1 ~ 8 hours; Part 2 ~30 Hrs.

We had 4-5 weeks to do each project, so 20-40 hours over that many weeks is not bad.

Coursework: The videos are a little bland. Having some learning questions in the middle of a module helps a lot to break up the monotony and I wish there were a few more. However, the material is always organized well and the videos are very easy to understand. Ada is great. I recommend watching a few videos from a module at a time. Avoid watching them all in one day or letting them pile up for multiple weeks. One week in the semester there were two modules for the week instead of one. That was not fun. Don't fall behind on these if you can avoid it. It is not fun to catch back up.

The readings are covered mostly by the lectures, but if you need to do well on exams because your project scores aren't perfect, reading those will help you squeeze some points out. If you have perfect project scores, you can get away with not reading 70% of them, and skimming the rest. They have favorite papers they like to ask questions about while the others don't get so much attention.

Exams: These sucked - they are very challenging. There are no short/long answer format questions so you either know the material or you don't. It is possible to get a good grade, but you need to do all of the readings and pay close attention to the lectures. I had excellent project scores so I wasn't panicking over a couple of bad exam grades. Exam 1: 75 (curved), Exam 2: 65 (not curved).

Final thoughts: If you kill it on the projects, this course isn't difficult. The curve at the end is generous. I got an A for a good amount of effort on projects, a minimal amount of effort on tests, and watching lecture videos seriously.

Background

Math BA from top US university, 4 years experience as a data analytics professional. Most professional experience is using Python to develop internal tooling for analytics teams. This was my first class in the program. To prepare I did the first part of nand2tetris, worked through all of K&R C and read through beej a couple of times. I also skimmed parts of OSTEP (which I highly recommend).

Structure

One lesson per week every week except for one week, where there were 2 lessons. Each lesson is roughly 50-90 minutes and varies significantly in difficulty. Lessons cover a broad range of topics, including threads, IPC, RPC, scheduling and cloud computing. There are also papers assigned each week, some of which are quite challenging.

45% of the grade comes from three projects, all of which are challenging. The first two projects are in C and cover multithreading and IPC. The last project is in C++ and covers RPC and DFS.

5% of the grade comes from participation. If you participate basically at all you are getting full credit.

50% of the grade comes from the midterm and final. These are both very hard and require a lot of studying to do well on.

Workload

I spent 60 hours on P1, 40 on P3 and 40 on P4, then about 60 hours total on lectures, papers and studying across the course of the semester. All in all, this averages to ~12 hours a week, but there were weeks that were 20 hours and weeks that were 1 hour.

The Good

• The lectures are mostly very good. Some topics could be better explained (for example, consistency models) and there are many, many errata. But overall I was really happy with the quality of instruction and the professor is great.
• Class discussion on Slack was great. You get a really great opportunity to connect with other students from all over the globe.
• The projects were very fun once you figured out what to do. You get to build some stuff that's actually pretty cool.
• For someone without a CS background, this class provides a really great overview of how some lower level mechanisms work.

The Bad

• Although there were some TAs who were good, there were some who really were quite rude and condescending. At some point I got too anxious to ask questions any more because the TAs would give you some snarky response that made you feel dumb.
• The project READMEs are horribly written. A lot of the difficulty in this class is artificial, because if the projects were properly documented they wouldn't be hard at all.
• Awful clarity regarding what is actually required for projects to get full marks. P1 and P4 were really bad in this regard since both of them have edge cases that are super difficult to deal with but you are apparently supposed to ignore. I spent a lot of wasted effort on these points and was a little salty about it afterwards.
• The exams are worth too much relative to the time commitment required for them and are probably a little too challenging IMO.
• Piazza was not helpful at all.

Advice to Future Students

• Get really, really comfortable with C. Even if you feel like you know C, practice more before the class starts. K&R is pretty great for this.
• Don't neglect C++. A lot of other reviews state that this project is easy, but I found it to be arguably the hardest because I had never written any C++ code.
• Study consistently throughout the semester so you don't have to cram for the very challenging midterm and final. Also, don't underestimate these exams as they are quite difficult and are worth half your grade.
• When a project opens, start it immediately. Read the README and the codebase multiple times before writing any code.
• Use Slack! It's like half the value of this course.
• Don't listen to some of the doomposters online about this course. It is challenging but absolutely doable.

Summary

This is a good, not great, class that could be great with some updates. That being said, I think if you don't have a CS background you should absolutely take this class as it will make you level up a lot as a programmer and CS student. If you have a CS background and a strong OS background, this class could probably be skipped. After taking this class I feel pretty confident that I can complete the program with enough hard work.

This was my first course in OMSCS. For me, it was a great re-introduction to programming in C, and I learned some new things about operating systems. If you work in this area, or you recently took a rigorous undergrad operating systems course, you can probably skip this one and go straight to AOS. But if you're like me, and you've been working on web backends for the last few years, and you want a relatively gentle, well-organized introduction to OMSCS, this is a great option. In terms of time commitment, I took this course on its own, but doubling up would have been manageable. Next semester I'll be taking HPC.

Overall: This course is well organized and teach mostly basic knowledge in operating systems. This is a coding-oriented course. Nearly half the grades come from coding project. If you want to easily get an A in this course, it's recommended you have some C/C++ knowledge and have Linux programming experience. If you do not, well, be prepared to spend more time on coding and debuging.

Projects: There are 3 projects, first is in c, about transferring file through network. Second is in c, about use IPC to transfer file between processes. Third is in c++, about implementing a distributed file system. All the projects use address sanitizer, which is a tool to track errors such as memory leak, so you have to pay special attention to allocate clean the resources. The autograder is fair, not too strict, not too easy to pass. The most valuable advice is to start early on each project and do time management as many of other comments has already mentioned.

Exams: It's not hard, most of the problems are discussed in the quiz between lectures. It counts another 50% of the grades.

Other: The slack channel is very useful, the peers are very willing to help and respond quickly. Do not use piazza unless you want to get an answer after you have already figure this out by yourself.

Drawbacks: While the course provides some papers for students to further understand the contents discussed in the class, it does not have a closely related book to help students understand the topics discussed further. In comparison, CMU's 15213/15513 Intro to Computer Systems has a detailed, close related book and tons of useful practice problems to help students better understand the material. Clearly this course is not as good as CMU 15213 (from every aspect: lectures, projects, exams), but it's enough for a non-CS students to get some insights on how the os work.

Background:

• First course in the program, non-CS engineering undergrad.
• some exposure to C++ from community college courses taken as recommended pre-reqs
• skimmed through K&R C book over the summer
• about 7 years of exp as a test engineer/devops engineer/release eng

Time: Probably spent 15-25 hours per week. I didn't time myself methodically, but it skewed towards the lower end during exam study weeks or the first 2 weeks after a project was released and skewed towards the higher end the 2 weeks before a project was due

Exp:

• Exams felt fair, and reading through https://www.omscs-notes.com/operating-systems/welcome/ was adequate preparation. I also concurrently read through OSTEP and enjoyed it. The class material roughly covers the same stuff OSTEP does, but OSTEP presents it better imo
• Projects were interesting, but a pretty big time sink.
• 1st project had a bunch of edge cases that it felt like one needed to figure out from cryptic clues from the project description or from gleaning from the gradescope test results
• Project 3 was fun and it was cool to learn about IPC, although the project felt a bit contrived
• Project 4 sounded cool at first. The concept of RPC is pretty neat, and I liked how the class projects progressed from socket programming, did a side-quest with IPC, and went to RPC. I didn't really enjoy working with gRPC and protobuf
• I think I spent around 50-60 hours overall per project.
• I wish the course could have had projects around more "traditional" OS mechanisms, like implementing a shell or a file system, and left the more distributed stuff for future courses like AOS, SDCC

Overall, a recommended course. I feel a lot more comfortable with C programming, pointers, and working with memory. And it forced me to read OSTEP and learn about OS.

Definitely a great class. you will learn C, C++, grpc, sockets, multi-threading. Just a note.. its not just projects. Consider spending time on mid-term and final. They help you to get an A.

This course was hell for me. I came into it not knowing any C, so all the project were 3x harder. The C prerequisite is not a joke, so if you have time before taking this class, please take some C refresher courses so that you're prepared.

Even though it was hard, it was equally rewarding. I was mainly a Python programmer, and learned so much about "actual programming" through this class. I know how threads work now, what a SIGINT is, how cloud infrastructure works, and much more. Definitely take this class if you don't have CS background, but would like to have some. It covers a bunch of topics at a high level, enough to get you out of your comfort zone, but not enough to overwhelm you.

To get an A, just make sure you do well on all the projects (~90-100), and aim for the mean (~70-75) in exams.

I took it during summer, and there were 3 projects. The 2nd project is not given during summer. Each project is worth 90 points, the rest of the 10 points come from the project readme. Each project is worth 15% of your grade. Pr1 - use send and recv in a client and server, make them multithreaded Pr3 - use interprocess communication (IPC) in a proxy and cache Pr4 - use gRPC, and figure out callbacks for a simple distributed file system

The readmes are simple to make and easy to get a high grade in, just follow these tips - 1) describe implementation pros and cons, 2) describe your code flow (preferably in a diagram), 3) describe how you did testing, 4) cite your references.

There are two exams - midterms and finals, each worth 25% of your grade. Take these seriously. Just review the midterm reviewer they provide, and find a decent reviewer for the final. Get a grade close to the mean, and you'll be fine.

The last 5% of the grade comes from participation - they always give this, plus extra credit if you're active in forums/Slack.

Ended with an A grade thanks for generous grading curve. Project scores were 99, 100 & 68, exam : 78 & 70. Over all 82.2%. I would not repeat about projects what others have already said. The course is relentless so pairing with another course is not advisable. For P1 I spent 2.5 weeks, 9 AM to 6 PM and then some in the evening (as I was in between jobs). For P2, I spent 1.5 weeks with lot of late nights from 9 PM to 3 AM . I kind of gave up on P3 and spent only 1 week with about 45-60 hours. I am lucky to escape with an A. The TAs were really helpful. I thought at P1 I might have to withdraw but they extended the deadline by 2 days and that helped hit 99 what otherwise would have been subpar 70.

• get knowledge of TCP and UDP protocols if you have not taken computer networks.

• Start each project early, specially P1. This project is a beast. You want to leave more than 1 week for multi threaded portion of this project. Specially if you are new to thread based programming.

• Do not underestimate P4, the C++ projects. This is the project I screwed up because I did not know C++.

• Do not leave less than 2 weeks full for any project. P1 takes more like 2.5 to 3.5 weeks.

• While you will be mostly buried in projects, do not leave the lectures to the last moment, Midterm comes fast after P1 and so does final after P4. Make it a point to watch atleast one lesson (like P3L2) each week.

• For exams dont sweat too much , I only watched lectures once, made my own notes while watching and compared them to OMS notes. Lastly, solve the practice questions twice. Do not attempt the exam without solving the practice questions. Infact you will realize practice questions is all you need for the exams, specially for math problems.

• While things sometimes may seem insurmountable, the hard work will be totally worth it. You will learn a ton!

Good luck!

I took OS in undergrad (albeit during COVID, so I kind of stopped participating in the second half of it), so I have an understanding of the ways an operating systems class could be run. In my undergrad, a majority of our projects were adding features to Xv6. Outside of Xv6, there were a variety of other assignments like making a unix-like shell, reading from FAT32 filesystem, rpc work - which like any good OS course, was a lot of work.

GIOS discusses these topics in lectures very well (honestly better than my in-person undergrad lectures), but had 3 assignments. They focused on multithreading, IPC, and RPC. As such, I think I remember the most about these topics, but feel like I’d be quick to forget things like scheduling, how memory is structured, COW, if not for my undergrad course. If I took this alone, maybe more knowledge would have stuck, but I did well just by watching the lectures, completing the projects, and skimming the readings. The professor is nice and the TAs are good. There is a fairly generous curve (based on fiddling with canvas, ~81.6 for an A).

This class still stands as a really good and interesting one that does a solid job of introducing you to operating systems. I was able to learn about memory/RPC and distributed systems, concepts which I had ignored when COVID hit. For students from a non-CS background will definitely have the additional component of “learn c” that will make the class much harder - but in my opinion, GIOS on the level of a junior/senior level undergrad class; a must take for people with 0 knowledge of operating systems, but probably a skip to AOS for someone who has had marginal exposure to these topics.

This was my first course in the program and I'll be starting my third in the fall. My undergraduate degree is in electrical engineering. At the start of the program, I had a couple years of professional experience with software development , but I hadn't developed anything more than simple programs from scratch in C or C++. Even with that experience and a couple of relevant courses in that EE curriculum, my overall knowledge of CS was still patchy.

C and C++ knowledge are prerequisites for the course and you will struggle without them unless you're a wiz a reading documentation and picking things up on the fly. Once a project is released, you should be starting work immediately. Previous students have made some python test scripts available for testing. Prior to a GS submission, running these is tremendously helpful and can save you from wasting attempts. My #1 recommendation for the projects - START EARLY. When details of a project are released, start dissecting them ASAP because it may take some time to lay out a design and begin with implementation

Overall:

I really enjoyed the content of this course and lectures were of high quality. Use the slack channel! It is much more active than Piazza and you should really leverage both while asking questions or looking for answers to general problems in the development process. I waisted a lot of time (especially on the first project) to solve issues that resulted from ambiguity in the project spec and had already been clarified on slack. Read the project specs VERY CAREFULLY

As someone who is interested in writing high-performance software, I found it very valuable

This was easily the best class I have ever taken in my academic career. Period. It is incredibly well organized, extremely well designed, and (as an Engineer) incredibly fascinating.

To be clear: if you are coming in with little to know C knowledge, or *nix knowledge set, this class WILL BE CHALLENGING. While I came in with a solid *nix background, I had almost no experience with C. So projects 1 & 2 were incredibly daunting. I can’t say exactly how many hours project 1 took me, but I would guess well into the 100+ range; Project 2 as a bit “easier” since Project 1 really forces you to learn and understand the C programming language.

Project 3 I found to be, honestly, the most challenging of the bunch, as it moved us to C++ and GRPC for completing it. Part 2 of this project will absolutely push the boundaries of even experience programmers, so be ready to commit to it!

As for the lectures, I found them to be very well done, if a bit of a “knowledge crunch.” I would definitely expect that a few of these lectures you will need to rewatch once or twice, simply because there is so much content to take in. Mid-term and Final were tough, but fair. So long as you read the papers, and do the lectures, you should be fine.

Overall, even though this course is difficult, I cannot speak highly enough of it. I came away from my semester feeling like I had 10x’d as an engineer, and am already looking forward to Advanced OS.

It will definitely test your limits (and your free time), but it is well worth the investment. Ended up with an A!

Extremely well organized course. The best course ever I've taken during my entire academic life. Even if I've taken undergraduate OS course from my bachelor, I learned huge things.

Lecture is easy to follow with a lot of analogy, while treating the vast amount of topics. All topics that I learned from undergraduate OS are covered before midterm, and the last half was completely new for me.

One thing I most loved was projects forced me to think from system's perspective. If you take this course, you will see a lot of desperation at the forum like: my program runs perfectly on my local environment, but not on grade scope. We were forced to find and consider those hidden aspect, otherwise must have been neglected. Of course, it challenged a lot, but at the same time made completing this course very fruitful.

There were few things desired.

Firstly, without network programming experience, it will be likely to be though to understand the concept of the first project. Though I felt pretty complaint about it as I struggled, it was acceptable given the fact that this is a Master's program.

Secondly, I personally felt project topics are a bit biased into multi-threaded programming. There are a lot of interesting topics related with OS. However, given the course design concept, which is to give preparation for advanced OS, it was also fine.

Overall, this course made me completely satisfied about this program and convinced me it is worthwhile to continue on.

This was my first course in OMSCS. I knew that getting back into the grove of studying again would be tough but this course kicked my butt! I think the most important thing i learnt from this course is to manage my time well. The first two projects are in C and last one is in C++ , and i must say all the projects are very good -- they will teach you a lot. My advice for anyone taking up this course would be to start the projects as soon as they are launched, there will be many errors in getting successful submissions (referring to all test cases passing). Ended up getting a B as i did poorly in the first two projects.

Overall, this is a fantastic course that every student in OMSCS should take, especially if you have not had an undergraduate OS course. There are three projects (two in C and one in C++), a midterm, and a final for this course.

The highlights of this course for me were the three projects, which were extremely helpful in improving my programming and problem solving abilities as well as solidifying the concepts of the course. The projects take a lot of time (roughly 20-30 hours of effort as somebody who was previous C++ experience) but are fairly straight-forward. As long as you plan ahead and spend enough time on them and make sure you pass the Gradescope tests multiple times, you should be able to pull off As on all three projects. For reference, my average for all three projects was a 98; I missed a few points on project 1 due to having a race condition I did not notice until after the deadline and missed half a point on project 4 for not explaining my test steps enough.

However, the exams are where this course kicks things up a notch. Unlike the As I received on the three projects, I scored a C on both the midterm and final. A decent chunk of the information being tested comes from the papers you are assigned to read (with some of the questions on the exams not being covered in the lectures at all and only being touched on in the papers). Reviewing for these exams felt like trying to memorize every single OS fact you can and hoping that you remember every last detail touched on in those papers. There is also minimal review given before each exam, so there isn't really much in the way of preparation besides reviewing your notes, lectures, and the papers. I think that this course would benefit from switching to open-note exams instead of using closed-note ones.

That being said, the curve of the course is generous. Despite making a C on both exams, the high As on all three projects pulled me above the cutoff for an A. Even if I had not taken the final at all, I would have still earned a low B in the course. If your goal is only to earn a B, then earning a high grade on the projects and giving the exams your best effort virtually guarantees a B. However, you definitely need to put in a lot of effort to earn an A in the course.

If you decide to take this course, be prepared to put in a lot of work, but it will most certainly be worth the effort when you're looking back on it from the other side.

I have a non-CS background, with no prior experience in C and some experience using C++. I learned a lot in this class and would recommend everyone to take it, provided that they take the pre-requisites seriously.

Preparation: If you are not familiar with C programming, I strongly recommend that you read a book, take a MOOC etc. You should get familiar with how memory is allocated, using pointers (single and double), structs, string operations because you will need this for Project 1. I also suggest that you look up gdb and valgrind tools for debugging because this will help you immensely with the first project.

While it's possible to take this class without this prep (like I did and others), that just means you have to work extra hard during the first project to pick up the language. It's unnecessarily stressful, so you should study C in advance.

If you are so inclined, the lectures are available in Udacity for free: https://www.udacity.com/course/introduction-to-operating-systems--ud923

Grading: I managed to get a "B" in this course in spite of low exam performance, failing the first project and acing the last 2 projects. The curve is generous such that low 60s is a B and low 80s is an A.

Pros: Organized lectures, excellent material and challenging projects. The class has an active Slack community and TAs are especially helpful for project 1. Professor holds regular office hours.

Cons: No major cons.

Workload can be very heavy approaching the project 1 deadline (given you have a midterm to prepare for) and the project 4 deadline (given you have the final to prepare for). For that reason, project 3 was the easiest for me since I didn't have to worry about exam prep at the same time. So keep that in mind as you budget time for projects and exams.

Final grade: 86% A Lectures: well explained and engaging. I have a Bachelor in CS and still find I was learning a lot, in depth from the lectures. Good structure and easy to follow along. Projects: 3 projects and all are fun, but really challenging especially P2 for me. The last project is my favourite since it involves lot OO design. My suggestion is to start right away when they are released. Use Slack and Piazza Exams: although I did well on them, the exams are still not very well representing the course materials. All memorization with huge amount of information.

I have a non-CS degree background and this was my first class. I had never tried C beyond small hello world like toy programs. This class kicked my butt but I made an A.

The concepts covered in the lectures are clear and the exams are very fair in terms of question difficulty and material covered.

The projects are what make this class difficult. I have a time tracker add-on in my IDE so I can say with accuracy I spent between 90 and 120 hours on each of the three projects. That seems to be typical of someone with a non-CS background. Per class slack conversations, those with a CS background who had been exposed to C averaged out at about 60 hours. Time management around the projects is the killer in this class. Start them as soon as they open.

I'm glad I took this as my first class in the program. Even though the class was difficult I never felt like the difficulty was artificially induced by trick questions or poor TA feedback. I really feel like this class was worthwhile for someone like myself who had never been exposed to low level concepts before. Don't be scared if you have no or not much C knowledge. It's very possible to learn on the way and to do well if you put in the effort.

Feel like I learned more in this course than the first three I’d taken.

It’s really two halves. Lectures cover OS theory and are great for understanding systems design patterns. Felt like I finally understood concepts I’d heard about for years.

Projects are more about how to use OS primitives and ensure you’ve had some exposure to C. Fine and satisfying to get working but the specs are vague which can get frustrating.

Projects take up way more time but don’t count for as much. They’re not released in advance. Workload is definitely lumpy, and it pays to get your projects done early.

Non-CS background, got an A.

I learned a lot in this class but found it very difficult. I am self-taught in Python and have a math background so learning C (and even more so the infrastructure surrounding C, like how do I run two processes at the same time) was a huge time burden. I ended up with an A but worked very hard for it. Would recommend a strong foundation in C before taking this course. Project descriptions / starter code are not well thought out. Midterm and Final were fair given the provided review materials and the grading scale is a bit lenient (I got an A with an 87%).

A challenging but not-overwhelming review of operating systems concepts and intermediate C/C++ programming. The lecture content is nothing too difficult, although the final exam does cover a lot of content. Projects are more time-consuming than conceptually hard -- expect to debug a lot of pointer problems -- but provide good hands-on experience with the concepts they teach

I enjoyed this course a lot overall, but I'm taking a point off because I was burned by the project grading scheme. Due to the high number of students, projects are evaluated almost solely on Gradescope test cases. A small runtime error in the post-submission test case run can lead to a very low grade on a submission that is otherwise fully complete, and TAs are unwilling to evaluate projects holistically when this happens.

This is a fantastic course. This was my first course in the program. I have a bachelor's in CS and I work as a SWE primarily in C++, but I didn't have a strong OS class during undergrad, so I decided to enroll in the course. This was a great choice: despite my background in CS/SWE, I really struggled in the first project, since I didn't really know C and I knew nothing about sockets. However, after I let go of any pre-conceived notion that I knew C, I was able to start learning C/Linux from scratch, and then helped me set a good foundation for the rest of the project and Project 3 (which is also in C).

Overall, I learned a ton in this course, from both the lectures and the projects. The lectures are fairly straight-forward, with helpful slides and helpful pace. The supplemental papers are a bit long, but it's helpful to read them. The projects are loosely based on lecture concepts, but they require good coding, research, and debugging skills. You'll come away from this course as a decent C programmer with a solid introductory foundation in concurrency, operating system structures, and distributed systems.

If you are not super confident in yourself, DO NOT take this class in the summer!!!! It is the busiest summer ever in my life. This class is super useful, and the projects are pretty interesting. The code is in c, so you need to know how to write c/c++ before taking the class. Project 1 is a warm-up + gfclient and gfserver. Project 2 is skipped in the summer. Project 3 cache/proxy server. The previous two are pretty hard, and can't really get accustomed to the pace of the summer course. For project 4 about grpc, I feel much better, after being tortured by the previous two projects. It is very hard to debug the memory leaks and some other weird issues, and TA can't really help. They just give some general hints and that's it. Exams are also super tough. The good thing is the curve is very generous, at least for a final grade of B. Even after finishing this course, I still sometimes go back and review memory management and multi-threading. I would definitely recommend this course in a normal semester.

Class is well run with good lectures and involvement by the professor during office hrs. I took the class in summer 2022, so one needs to keep in mind to manage time to prepare C and C++ concepts as summer semester is a short one -around 11-12 weeks as opposed to fall or spring semester that has 15+ weeks. The best part of the class is one gets to learn gRPC and inter-process communication using shared memory that are very satisfying. This class has certainly increased my interest in pursuing Advanced Operating systems. For students who don't have C or C++ background, its certainly doable with some C reading and youtube lectures. Esp, it would be much more manageable in spring or fall semesters as there are only 3 projects and 2 exams in total. I scored an A and did well in all except for final exam... Didn't even know how i faired bad in finals when I thought I prepared well. Didn't get answers or explanations for finals.

Don't take this course if you took an undergrad OS course. I did and it's mainly a repeat. Project 1 after the warmup and before multithreading there is a section where you write an API but everything is so opaque that there are a million questions on Piazza you have to scroll through to get pertinent info. It's just the same as the warm up (socket programming) but like a pig with lipstick that's smeared.
I believe all the positive reviews come from students with little CS experience who get enjoyment out of programming in C for the first time. Even the multithreading material you can just watch the lectures for free on Udacity and you'll learn everything.

My background: data engineer with 6 YOE, did a CS minor in undergrad, novice at C programming, retaking the course after withdrawing because of a car crash.

The course content is excellent and I definitely learned a lot, but I have a lot of issues with the way the projects are run. The project descriptions are needlessly vague, and Gradescope ends up being the oracle for requirements. IMO, Project 4 was the most difficult of all the projects, and we only got 2 weeks to do it in the summer. I couldn't figure it out in time. With another week, I'm sure I could've gotten it, but the compressed schedule is rather brutal. Project 1 is extremely time-consuming, and I spent over 100 hours between the two terms on it.

I was playing catch-up the entire semester, despite not working at the moment. There's a Pareto principle at play here: 80% of the time spent on projects is chasing after that last 20% of learning.

I scored in the top quartile on both exams. I got a B overall, with and without the curve. It would've been an A if I didn't fail to complete the last project. I'm largely happy with my personal outcome of the course.

However, I feel like too many of these reviews are written by people with many years of experience writing C/C++ code, and this is something of a victory lap for them. Operating systems is widely considered to be one of the more difficult topics in computer science, and this is a graduate-level operating systems course. Don't underestimate the time commitment required. If your background is similar to mine, this course is not compatible with a day job, but you're also the person for whom this course would benefit the most. The course content is highly relevant in industry, my ignorance has held me back in my career, and there's no better way to improve than to jump into the deep end. Just be aware you're jumping in the deep end when you do it, and don't believe overly optimistic time estimates from reviews. What's the point of taking an easy course where most of the content is review for you, anyway?

Background: CS bachelor, worked as a software developer for one year.

Pros: This course is good, you can learn a lot about operating system here, and the knowledge here is deeper than what I have learnt during my undergraduate OS course but won't be too difficult.

The lectures are good, there are some papers related to lecture concepts are expected to read, but generally just watching the lectures is enough for most of the questions in exam.

The projects are well designed, the three projects provided in the summer semester are about multithreading, IPC and RPC respectively. The code framework of projects are provided, the miscellaneous componets (like command argument parsing, queue implementation, etc.) in projects are done by the teaching stuffs in the provided frameworks. What students need to do is the key coponents related to the lecture concepts.

Cons: There are some mistakes in the lectures, many of them are fixed via errata, for me they don't affect my leaning in most of the time.

The projects readme files have some inconsistency regarding to projects requirements. It cost me some extra time to figure out what is the correct way.

Background

Over 7 years of experience building tech products and currently working at one of the FAANGs as a senior software engineer.

Pros

1. Great depth of content. If you are really looking to understand OS course material, the lectures and the content do an amazing job at it.
2. The projects are fun. You get to recap a lot of C/C++ and actually implement big projects with the languages.
3. The Slack community is super engaging if you are up for it and you get to have interactions with other students that are typically rare in OMSCS courses.
4. The exams are fair even though too heavily weighted for the amount of effort that goes into the projects. Right now 3 projects account for 45% and 2 exams account for 50% with 5% for participation credit. IMO it should be 60-35-5 or maybe even 60-40 with the 5% for participation being extra credit. The current extra credit model that they have is too strict and I doubt more than 1% of the class got anything at all.

Cons

1. The biggest one for me - An absolute lack of quality support from the instructor or TA team. Let me justify my beliefs:
   • Except for Project 1, I barely saw any Piazza posts that had any helpful replies from the instructor team in responsible time. There are some posts that get replies after a day or two but a lot of those replies are either unhelpful or downright condescending.
   • For projects, you will still be able to get a ton of help from the students on Slack or Piazza. Slack is faster and better mostly though. To be honest helpful students deserve partial pay of the TAs in this course. There were 4-5 students in a class of 700 (~400 after the withdrwal deadline) who helped everyone throughout the semester and if it wasn't for them, we probably wouldn't get any help.
   • When it comes to doubts regarding the lectures or theoretical content, all platforms are quieter than the quietest night. Again students to the rescue to some degree here. Credit where due though, you can ask Profressor Ada questions during office hours where she does respond properly to all queries but with the frequency of office hours and the limited time, it's not the right platform to collect all the questions and ask in one go. But the TAs are responsible for answering these queries and they have at times the gall to say that they don't remember the concepts as they took the class years ago. I mean what are you being paid for?
2. The projects and the lectures don't really go hand in hand. They feel a bit out of place. But that's alright since they are fun to implement. However, my biggest concern with the projects is unclear expectations and requirements.
   • Project 1 has so many hidden requirements that you will find yourself evaluating the requirements from Gradescope errors. And even once you find out these new requirements, if you go back through the README to see how did you miss it, the answer is usually that they never mentioned it.
   • The expectations from student READMEs are extremely vague and the evaluations are equally ridiculuous. Most of the project README evaluations are based on the gut of the TA evaluating them. Which brings me to the next con.
3. A huge lack of quality feedback. If I am taking an academic course, I am doing so to improve upon my failures, not to simply score some marks and get a passing grade.
   • We never received the correct answers for the midterm exam or the final exam so we have no clue why something is marked as incorrect and what was the expected correct answer.
   • The feedback on project READMEs is laughable. I had a single line of feedback basically saying I didn't express myself well. Now what the hell do I make out of such a feedback? All it tells me is how bad you are at your job as a TA.

TL;DR

Don't get me wrong. Even with these massive cons, the course is comfortably doable, fun and I am on track for an A grade, but the experience is so lacking that I would never pay for this course out of my pocket. I would rather just watch the lecture videos on Youtube/Udacity and I will get 80% of the ROI of this course. The rest 20% ROI is in the Slack community to be honest which again you can simply join with the GT Slack account. If I wasn't taking two courses in the semester, I would have withdrawn from the course and got my money back.

P.S.

I took this course based on the reviews but yeah definitely not for me as this is NOT the experience that I expect. If I wanted a paid MOOC, I would have just gone for Udacity. It also made me realize that most courses in CS spec will be like this based on more feedback from peers so I decided to change to II spec after this course.

The professor provides office hours which is good and the lecture video is just OK. However, the problem is the connection between projects and lecture content is too weak. You don’t have to watch the video before starting the project. Most time you spent is to understand the template/frame provided. It could be difficult if u don’t have strong background on C and C++ but the real coding is not too hard. gRPC is the most difficult part as most tutorial online are written in Go.

I did learn something from this course but the projects are really torturing. The exams are 50% weight but midterm only have 7 problems. I may end with a 80+ not sure if can secure an A.

The greatest part of this course is Slack and Piazza (Piazza is helpful but I really dislike it). I found many good suggestions and solutions there when I encountered problems in projects.

Tbh, it is not recommended if you choose ii track. It is not a good starter for someone new to C and C++.

This is my 6th class at GT, and same problems as always. Paying $900 for pre-recorded open source lectures filled with wrong concepts/content/answers, and projects which are basically DIY learn as you go, and submit to an auto-grader...Very little involvement outisde of office hours. Luckily the class was lively on Slack and Piazza.

Welcome to the new concept of Master's degrees, Paid MOOCs.

First off I'll start by saying I was comfortable with C/C++ before going into this class.

I felt the projects were not hard but here's the gotcha...The projects come with very little instructions (paragraph or 2) you're supposed to finish the projects and create your own test harnesses or lose points on the project's readmes if you did not. You get 50 attempts to submit and pass, but if you use that as how you tested it, they subtract points. I personally disliked this because the instructions were vague, and unrelated to the course material and if they were related, very little examples are given in the lectures. Then you submit to an autograder where the feedback if you missed points is vague and loose, so all in all for homework...I'd say 4/10 in difficulty, 8/10 in confusion. Then you write a readme (as your report) which depending on what TA you get is biased on whether you did well or not, it's a toss really.

Then the exams, the exams questions are fair, harder than simple multiple choice, easier than full fill-in-the-blanks. The course material is straight from the lectures, but WARNING do NOT study from the lectures it's filled with ERRATA and then there are ERRATAs for the ERRATA. So staff testing you on questions, they got wrong themselves and never bothered to update in the years they've been doing this class.

I took it for the high reviews, but the experience was lackluster. I decided after this class to not do CS as a spec, because of the demotivating experience of this class. All in all, pretty sure I'll finish with a B, but not recommended if you actually want to learn OS...maybe...infrastructure servers?

Good, but difficult class, with concepts that will make you a better engineer

The content is definitely not a cakewalk. But what makes this course great is the extremely active slack community. Seriously, it would have taken me many more hours to finish the projects without help from the community.

I have some C++ experience from work and C experience from undergrad. It helps to come in with at least a basic understanding of C. There are 3 projects, and you can't expect to finish them realistically if you start them the weekend of the due date. If you start them each a couple weeks out, you should be fine. But don't be surprised if you have to put in a few hours of work per day until the due date.

Don't Take This Class Unless You Have Years Of C/C++ Experience

Background: I am an ex-Amazon Web Services Software Engineer II at Microsoft and have 4 years industry experience, contribute to open source, hold 19 technology certifications, have a BS in Information Technology, and have been programming for just shy of 10 years.

Bottom line: If you aren't a "C/C++ person" who has been doing C/C++ primarily for years, absolutely do not take this course. Seriously, you have been warned.

If you are coming in straight from your Bachelor's degree and wanting to learn more about Operating Systems, this is not the course for you.

The OMSCS program is touted as a degree where you can work full time and still go to school. After taking this course, I can say with full confidence that this is not the case.

This is simply the worst experience I have ever had in an academic setting. I literally spend all of my free time outside of work (and now school) programming. I'm one of those people that really takes this stuff seriously and goes above and beyond. If I, trying as hard as I can to complete the 3 assignments can barely finish them because of their huge size and scope, I don't know who this course is for.

Great class! Took this my first semester without a CS background and it was very challenging but a good first course

This was a good, fast-paced course to get a broad understanding of Operating Systems basics. If you've taken an undergraduate operating systems course, I would expect that you would be familiar with at least 50% of the material, but I would also expect that a good amount of the material will be new to you.

Exams - very fair, but they cover a lot of material, so studying for them can take time.

Projects - time consuming and rigorous, but I learned a lot. Like others have said, you should be somewhat familiar with C before taking this course, or the first project will be very tough. The grading is 90% autograder, 10% manual grading of the documentation you produce. The manual grading can be a bit subjective, but it's not worth very much. There are no hidden test cases, unless a grader feels that you were trying to cheat on the other test cases - once you pass gradescope, you can expect to get all 90% of the autograded part of the project, as far as I can tell.

Lectures - mostly great, only very occasionally a little ambiguous.

Papers - I didn't like many of the papers. Many of them felt very detailed about particular implementations of some system, and were kind of a slog to get through. You will be lightly tested on the content of some of the papers, so it is best to read them.

Really excellent course with a lot of worthwhile material. I'm a Systems Engineer that primarily works with hardware and embedded work, and this material (especially sockets, communications, and multi-threading) has actually helped me with my career already.

In terms of "playing the game" (academics in general). If you can get through the first project successfully, you're golden. The later projects are still difficult, but not quite as time-consuming as the first. This is because unless you're already well-versed in C programming or system-program architecture, it can be really difficult to wrap your head around even what your supposed to do. You also NEED to get yourself connected to the community to do well here- beyond Piazza, there is also a really useful slack channel you should join and contribute to (and learn from).

Lectures/exams seemed secondary to the projects- they are much less time consuming but tricky in their own way. I honestly didn't spend all that much time preparing for the exams/re-watching lectures and I did about class average on both midterm and final. The issue is- there is a vast amount of material but a small amount of test questions. Ultimately, if you get unlucky in what you really understand you may get a poor score even though you've put the work in. I trusted that studying all concepts shallowly would be good enough, and happened to get lucky.

Got an A with about 86%, so there is a nice curve at the end.

My background:

1. Know C & C++ but not fluent
2. Know some Linux
3. Know some CN concepts, know some basic OS and wrote some threads before

About the lecture The lecture is well-designed and taught clearly.

1. The first half (for mid-term) is mainly about the basic OS, process, and threads. I enjoyed all the lectures and it's not hard to follow. The only topic that confused me was the interrupt/signal mechanism. But after checking in Piazza it becomes clear.
2. The second half (for final) covers much more content including scheduling, memory, IPC (dive in), synchronization, IO, virtualization, distributed file/memory, and datacenter concepts. I have spent much more time understanding the concepts. There is also more math involved. Compared to the first half, the study load becomes heavier, at least for me. 

About the projects

1. The first project (project 1, C) is about socket programming and multi-threading(part1&2). It contains three parts - warmup, part 1 and part 2. It is not difficult since the document is quite clear and guidance is provided. Based on the time tracker, I totally spent three weeks: two casual weeks (light workload, few hours a day, finish in few days) on warmup and part2,  one intense week (heavy workload, usually started after dinner till midnight every day) on part 1. Got a 100% score from the coding part. I like this project since it was the first time I tried socket programming and it applied what we learned from the lecture. 
2. The second project (project 3, C) is about IPC. The part1 is using the existing libcurl API and is fairly easy. However, part 2 requires its own design for shared-memory IPC. This took me time to think through it. I have experienced several moments that spotting my design was wrong or original thought was incorrect. Based on the time tracker, I totally spent two weeks: one casual week for part 1 and one really intense week for part 2. Got 100% score from the coding part. I like this project since I never applied to IPC before. It was a new experience and I have learned a lot.
3. The third project (project 4, C++) is about client/server communication and request handling with gRPC and distributed file system implementation. Part 1 is to build the RPC and the part 2 is to complete DFS with asynchronous gRPC call. Part 2 is based on the part 1. Based on the time tracker, I totally spent two weeks: one casual week for part 1 and one ok week (medium workload) for part 2. Got 100% from the coding part. I like this project since learning protobuf and gRPC were on my to-do list for a while. This project has pushed me to do it and I did learn from the project.

About the exams

Make sure to go through the lecture and sample exam questions & highlights provided by the professor, then you would be fine.  Skipping paper is okay if you don't have time.

The end

I have spent around 270 hours on this course with an A. I like this course and learned a lot. Professor Ada is great and classmates are willing to share their thoughts/offer help in Slack and Piazza. The only pity was that I didn't have time to read papers and books (only read a few). I would recommend this course

Overview

Fall 2021 was my first semester in the program and I took GIOS. Overall it was a great intro to topics I hadn't known before coming in as a non-CS background student. The class involves three heavy programming assignments in C and C++. The midterm and final are based on lectures and can be supplemented with textbook materials.

Pre-Requisite Recommendations

You should come into the class having some C/C++ background, and if you don't, you can do what I did and read K&R C prior the class. I did only about 1/3 of the exercises in that book. I had also taken intro and intermediate C++ at a community college before the class. Those helped me with the basics of C++, which is quite different from C.

On top of C/C++ as I commonly see referenced, non software engineers should come prepared with these:

• Basic Linux command line navigation (ls, cd, chmod, etc) and other Linux basics such as what a file descriptor is. For me, reading portions of The Linux Programming Interface by Michael Kerrisk helped in getting some of this knowledge.
• You are expected to make your own development environment using a loose guide that shows how you can use Docker, Vagrant/VM, or a native Linux environment. I used Docker and followed a tutorial posted by a classmate. If you don't know what a container or VM are, you should familiarize yourself with some tutorials.
• Basics of git and github - cloning a repo, pushing your code to a repo, etc.

Projects

The projects are interesting and take a lot of time to complete. Projects 1 and 3 use C, and project 4 uses C++ (project 2 was in prior terms an extra credit assignment, but did not exist during my term).

• Project 1 - Socket programming ( C ) - 40-50 hours - how computers can "talk" to each other by sending each other byte streams
• Project 3 - Interprocess Communication ( C ) - 40-50 hours - how processes on the same computer can "talk" to each other using a variety of tools including shared memory, message queues, and sockets
• Project 4 - Remote Procedure Calls ( C++ ) - 30 hours - how a client can "talk" to a server by invoking what appears to be a local function, but will be sent to the server to actually implement

Each project has a part 1 and part 2 (projects 1 and 3 have warm ups before part 1). Part 1 of each project is implementing the basic OS concept using a single-threaded approach. Part 2 will require a multithreaded approach, which can be much more difficult. You don't have to come in with knowledge about multithreading - it is taught in the course.

The projects are significant time consumers. I see some reviewers saying they spent 10 or 20 hours on a project and I would say those people are anomalies who may do OS work or C/C++ full time in their jobs. Project 4 is commonly cited as being easier, but I did not find that to be the case. It was just as hard as the first two projects but took less time due to less code being required. Also project 4 has less time for you to complete compared to the first two projects, and on top of that, you're studying for the final. I enjoyed projects 1 and 3, but I did not enjoy 4 due to the much larger code base you had to read. It felt like I was trying to track how a couple dozen files were interacting with each other rather than using RPC.

Exams

The exam weights are significant for your overall grade, and despite many of my classmates not liking this, I liked it. This is an academic program and if you are good at studying and exams, you can do well regardless of the projects. I believe the exams give a fair chance to those who may come from academic backgrounds but who may not have coded substantially in their professions. The exams also force you to review many OS concepts taught throughout the lectures that are not tested through the projects - scheduling, memory representation, distributed computing, etc.

The Curve

In my semester and in many prior ones, there was a very generous curve. The curve considers students who dropped the course. Roughly:

• 83 - 100: A
• 50 - 83: B
• C or lower - you really have to not do half or more of the assignments/tests to reach here

Drop Rate

It's about 40% per term if you look at prior semesters. I wouldn't be alarmed at this if:

• You have programming experience professionally or you've done enough coding academically.
• You've prepared adequately in C and C++
• You have the basics of Linux, command line, containers/VM's, and git

Conclusion

If you prepare adequately before the course, you can do well. I've noted a few things that should help those like myself who are not software engineers. The course is very well-run, and Slack is a helpful resource. It seems most TA's hang out in Slack. I found the TA's quite helpful for project 1, but they did not give much away for the rest of the course. Taking this course will make you a better developer.

**TLDR **

This was a great course, got a B overall but thoroughly enjoyed it. This course requires a lot of time and prerequisite knowledge of C and C++. Exams are disconnected from the project work. 25+ hours/week

** Full Description: **

This was my first class in OMSCS. I wanted a challenge and I definitely got it. I took one CS class in C programming as as undergrad. My background was in Biology so very little formal CS training. Currently work as an as a machine learning scientist at Fortune 500 company with 3 years of experience, and I wanted to get better at my job by getting familiar with OS concepts. I had significant experience in C beforehand as a embedded software engineer so I felt prepared for the projects.

This class has 3 projects:

Project 1 (C): Multithreading 100% I did something simillar in python so this was fairly easy for me.

Project 3 (C): Interprocess Communication (IPC): 50% I had a hectic work month and could not get an extension so I only finished the first part of the project.

Project 4 (C++): Remote Procedure Call (RPC): 100% Had very little experience with C++ so this was especially difficult.

Midterm: 76%

Final: 68%

I felt like the midterm and final were very disconnected from the projects. I probably spent 75% of my time on the projects and 25% on the exams and lectures.

The pros: (1) Learning practical fundamentals of OS through the projects (2) Learning and developing C and C++ software

The cons: (1) Projects are disconnected from exams (2) Hectic workload

Background

I took information systems in my undergraduate studies. I tinkered with data science after my graduation. My primary programming language was Python (3 years).

I took this module simultaneously with another module for my first semester.

I did not get an A for this module. (So close though :'))

Review

Content

The course content was well organized and clear in its instruction. Each week focuses on a key concept like memory management or inter-process communication. The material is well paced and is reasonably detailed. For those who are into research, there are many accompanying papers which can be interesting.

Time spent ~ 3 hours per week

Projects

The projects are designed to help improve conceptual understanding. For example, project 3 was for inter process communication. Working through the project will improve your mental model of how the different components should interact together. Think of it as a practice to build your concepts together.

Time spent ~ 40-50 hours per project

Exams

The exams covers a wide range of topics. Even though the overall content were divided to 2 examinations, it still feels overwhelming to recap the content at once. Yet, at the same time, it is important to recap all the content. This is because it is not certain what are the specific topics which will be tested.

Time spent ~ 10 hours recapping per exam

My Opinion

If you are interested in computer science, you need to take this module. I mean, knowing how the different abstract components work on the OS level is mind-blowing and insightful at the same time.

TLDR: Yes the module is tough but the knowledge is worth it.

Quick Tips

1. If you do not have C/C++ background, treat GIOS as 2 modules. The C/C++ language is a module by itself.
2. Start the projects early. Yes this is repeated a lot, but I like to highlight it again.
3. If there is a slack channel, find and join it ASAP. The community support makes the course more enjoyable.
4. It says introductory but please note that this is the fundamentals for the crazier stuff.
5. possible survivor bias in reviews. I think it is worth mentioning that the withdraw rate for this module is at ~30-40%. To a certain extent, the posts will be rosier because chances are that the ones writing are people who managed to survive this module. Play around with the grade distribution link to check the mentioned rates.

This was my first course in the program. I'm a CS undergrad and a SWE with a few years under my belt so I felt pretty well qualified for this course. As all the reviews say, you definitely get what you put in. Lectures are well organized and delivered. I left every section feeling like I learned a ton, but the breadth of material makes it hard to study for the closed book exams. The only downside of the course is that the projects are a bit of a mess. Requirements arent always clear and gradescope isnt exactly helpful (especially when its broken). Slack/Piazza get really noisy and finding focused help can be pretty hard. Overall I think the projects have the potential to explode the number of hours per week you're spending on the course, but the lecture content alone is worth the price of admission.

This was my seventh course in the OMSCS program. I took it during the Fall 2021 term. I had an Operating System course during my undergrad, so I decided to take this course as a good refresher. The class has 3 projects, 2 exams, and some minor participation requirement on Piazza. There is some opportunities for a few extra points on projects, but it isn't much. The course material was very interesting, but the insistence on using C and C++ 14 and creating your own VM was a little off-putting. There are some challenging aspects, but overall, it is a great course. Many list this as a medium to hard course, and for the most part, I would agree, with there being some aspects being more challenging than others.

Coursework

• Project 1 (15%): This project focused on creating sockets between a server and client. At first, you just send messages. It then progresses to sending files. Lastly, it moves into multithreading the program. The programming language used is C.
• Project 3 (15%): This project focused on Inter Process Communication. At first, you create a proxy server to receive requests, use CURL to query a web server with the data received, and send the data back to the caller. It then progresses to implementing a cache server, checking if the file was recently requested and can be served locally instead of making a server call. The programming language used is C.
• Project 4 (15%): This project focused on a simple Distributed File System. It involves making RPC calls between a server and client. Also included in this project is handling cache consistency when multiple clients access a single server. Ultimately, this project is a scaled down version of a DFS which most people encounter when accessing files in a remote location. The programming languages used are C++ 14, gRPC, and Protocol Buffers.
• Midterm Exam (25%): This exam has 10 questions, most of which are multiple choice with multiple selections, but there are a few which involve calculations and typing in your result. You have 80 minutes to take the exam. The exam covers the first half of the class, is closed everything, and is proctored by HonorLock.
• Final Exam (25%): The exam has 15 questions, most of which are multiple choice with multiple selections, but there are a few which involve calculations and typing in your result. You have 2 hours to take the exam. The exam covers material since the midterm, is closed everything, and is proctored by HonorLock.
• Participation (5%): This is listed as participating in the Piazza class forum. I am not sure how they determine this, but I found myself commenting on posts often, answering the quizzes in the lectures, and completing the Collaboration quiz. Based on what was mentioned in an office hours meeting, this is pretty much free points.

Take-Aways

• Miscellaneous Stuff: The papers are old, but crucial in terms of the exams as several questions rely on the understanding of the papers.
• Textbook: There is no required textbook; however, there are some suggested reference books. If anyone has taken an OS course, they have probably used a Silberschatz "dinosaur" book. If it is somewhat current, it should suffice as a good reference.
• Virtual Machine: This was a little challenge for me. I prefer being given a pre-configured VM as it removes all possible variances, but that is not the case in this course. You are basically given "it must be this OS version with these libraries." They provide a vagrant file and Docker file, if you want to go that route. Some step-by-step instructions were provided by some staff and students in the course to help guide those, like me, unfamiliar with vagrant or Docker. Having some instructions from a student on how to set this up as well as using Visual Studio Code to connect to the Docker container for an IDE was a lifesaver for me.
• Projects: The projects are interesting and relevant to the course. The first two projects are in C, and the third is in C++ 14. If you don't have a basic understanding of C, you will find yourself spending most of your time googling the simplest of tasks. Each project had a readme, basically explaining what you did, why you did it, and any changes you would suggest. There was a possibility for 5 points of extra credit on each project, but it isn't easy to get. For the EC, you have to provide meaningful suggestions and feedback to make things better. This can't be just saying using a test suite; it has to be you providing a test suite file or alternate configurations or links, purposes, and benefits of using an alternate library. It has to be something more tangible than "use a test suite" or "maybe consider using library x".
• Exams: There is a mid-term and final exam in this class. Both exams consisted most of multiple-choice with some multiple selection and type in the answer/result. The material can be quite detailed. There are several formulas you should know going into the exams as you will be tested against them. Some questions focused on a single detail hidden in a 20+ page research paper dating back to before 1985.
• Professor and TAs: The entire teaching staff was great. They took an active role in Piazza, which made getting help and questions answered easy. Unlike some other courses, the posts stayed on topic pretty well. Some TAs may be a little more harsh or crass, but given a class with almost 1000 students, a large TA staff, and students across the globe, this is somewhat to be expected. During some crunch time periods (after submitting project 1, starting project 3, and getting ready for the midterm), answers tend to be delayed, but this is understandable when they are trying to get some grades back to students so they can decide if they want to drop the course or not.
• Overall Grade: I feel like I put an acceptable amount of time in this course (over 280 hours to be exact). In the end, my grade was 83.73, which got me an A.

TLDR

Do not let the keyword Introduction in the course title fool you. It is far from your OS course in undergrad. With that said, it is a great course for almost anyone in computer science. The class may be daunting at times, but it is definitely worthwhile and doable. While there is a curve, don't rely on getting a lower grade as this class can definitely catch you off guard if you are not prepared. Study up on C and C++ 14. I can't emphasize this point enough. If you think knowing C# or C++ in Visual Studio is enough, you may be thoroughly surprised to find out it isn't. Start the projects early. If necessary, over-provide diagrams and details in the project readme files. Don't just give suggestions in the extra credit section of the readmes... provide hard examples, code, or files. Watch all the lectures and read all the papers. Study for the exams. Know certain formulas. This may seem like the standard replies to be successful in the class, but trust me, it is what it takes to succeed. Almost everyone learns something, even if it is just more of the C programming language.

Preparation & Prereqs

My Previous OMSCS Courses

N/A (GIOS was my first in OMSCS)

My Background as of Course Start

As of the start of GIOS (Fall 2021), I was coming up on one year at my first/junior dev position (full-stack web apps via React & Node/Express). My undergrad and previous grad work were both in Engineering (non-EE/non-CE). I was about 10 years out of undergrad by that point (Fall 2021), with around 7 years of previous work experience unrelated to software/dev and not otherwise directly pertinent to OMSCS or to GIOS. Prior to starting OMSCS, I completed a web development boot camp (2020) to make the transition into dev work.

I also took community college CS coursework (2019) in preparation for eventual start of OMSCS (Fall 2021), comprised of the following 5 courses:

• three-course intro CS sequence through data structures & algorithms using C++
• intro to computer architecture & organization, which included some basic MIPS assembly and basic Java
• discrete mathematics

My Preparation for the Course

Ahead of Fall 2021 GIOS (i.e., over Spring & Summer 2020), I worked through C & C++ prep/review material (I had previous exposure to C++ in the aforementioned community college courses, but it had been over a year since I had taken them by that point) to prepare both (specifically) for GIOS and (more generally) for the eventual Computing Systems courses I planned to take after GIOS, since I was going into OMSCS with this specific intention already; in fact, I even declared my Computing Systems specialization already along with my registration/enrollment for GIOS as my OMSCS course #1 of 10.

If you want to scope out the projects setup a bit, they are publicly available in the GitHub Enterprise repos (must have student status/credentials to access). As a representative example, Fall 2021 version is here for reference (and similar naming convention for previous semesters; not much variation in the setup semester-over-semester). I went with the Docker + VS Code setup and enjoyed it very much, this is a great time to be a CS student, as the toolchain has vastly improved for this type of project work, compared to even as recently as 5-10 years ago or so. (Note: the projects themselves are private repos, they will not be accessible until you join the course, and are released throughout the semester individually rather than all at the beginning.)

CAUTION: Course Prereqs

Take these seriously. It is possible to do this course without any C/C++ exposure, but that does not mean it is advisable. For reference, based on the historic data in LITE (more on this later), around 35-40% of the class drops by the W (withdrawal) deadline---the odds that you will be joining this cohort are substantially higher if you are the type who did not appropriately heed the warning of being adequately prepared coming into GIOS. Also, being able to use things like git, basic Linux/bash shell commands, and gdb (or equivalent GUI-based debugger, e.g., VS Code debugger) effectively can be a make-or-break factor for handling the complexity of the projects in a timely manner.

Course Deliverables and Materials

Workload

Tough to guesstimate this accurately for me on a per-week basis, but I think a more concrete assessment in hindsight is on a per-deliverable basis as follows (which I amortized/averaged out for sake of the review to around 25 hrs/week in my own personal case, conservatively estimating off of the higher ends of the indicated ranges):

• 16 lectures (excluding the brief course intro lecture), taking a total of 5-10 hrs apiece to complete, including (ungraded) in-lecture quizzes and taking notes
• 3 projects, taking a total of 50-60 hrs apiece to complete over a roughly 4 week span apiece
• 2 closed-book/closed-notes exams (non-cumulative), taking a total of around 2 hrs apiece to complete and around 25-30 hrs of preparatory review apiece (depending how comprehensive vs. lackluster the previous lecture review content, notes, etc. were at the point of exam prep)

The "weekly cadence" for these deliverables is largely self-directed, but there are five hard deadlines as follows (in order of occurrence, with week numbers based on non-Summer, 16-week schedule):

• Project 1 due end of week 5
• Midterm Exam due early week 8
• Project 3 due end of week 11
• Project 4 due end of week 15
• Final Exam due early week 17

Each exam is worth 25% towards the total/cumulative grade in the course, and each project is worth 15%. An additional 5% is given based on class participation.

Papers and Other Reference Materials

Regarding the papers, I read the ones pertaining to the midterm, but did not find the time spent on them was beneficial for the exam itself. In my view, the lectures did an adequate job of highlighting the salient features of the relevant papers as pertaining to the exams. Also, I did find watching the lectures first helped me to understand the papers better in general, rather than the other way around (i.e., reading the paper ahead of the relevant lecture). Others have different opinions on the papers (i.e., relevance to exams, and whether or not it is "useful" to read them), so I will just leave it at that and simply advise you to exercise your own discretion based on interest in the particular subject matter of the paper(s), time constraints, etc.

Similarly, I did not find reading the textbook beneficial (I started off with the dinosaur book, but quit by week 2-3 or so), as the lectures were largely self-contained/standalone and covered relevant topics very comprehensively. Also, similarly to the papers, I think going back to the textbook now (having taken the course and watched the lectures), I can probably get more out of it (and may do so in the future, at least for specific topics of interest). The dinosaur book in particular went into a lot of detail and seemed to jump right into topics assuming some background familiarity, and so I found myself lost often while reading it, hence why I abandoned ship on that effort relatively early on, as I was not getting much out of the time spent doing the readings. OSTEP is reportedly more approachable, but by that point I was not inclined to pursue textbooks further beyond the lecture content, so I personally cannot comment on OSTEP specifically either way.

I did also find The Linux Programming Interface (TLPI) and the manpages (via appropriate Google search of the functions in question) useful as general references, particularly for Project 1 (getting acquainted with C system calls) and Project 3 (POSIX API for IPC), along with Beej's Guide to Networking (specifically, Section 6, which gives the blueprint for building an echo client & server). Project 4 is mainly based on the C++ gRPC and protocol buffers documentation from Google, along with any C++ language reference materials as necessary (e.g., cppreference.com).

Course Logistics and My Personal Experience

Not going to get too in the weeds here on specifics (e.g., per-project and per-exam analysis) other than to say that the previous reviews on this site and on the r/OMSCS subreddit were largely accurate/representative of my own anecdotal experience with the course, and adequately calibrated my expectations going in vs. what I actually experienced in the course.

This is very much so a course where "you get what you put in." In a way, it does feel like the lecture material/exams and projects are two distinct "entities" within the one larger overall course, but they do complement each other well in the grand scheme, and both will leave you much more competent in the subject matter on the way out of the course than on the way in, provided you give each the appropriate necessary attention/focus and effort that they demand.

I agree with previous reviews that the projects are more application-focused rather than OS-focused, but personally I did not find this to be a negative; on the contrary, I thought the projects' code bases were very thoughtfully developed (after the high hurdle it took to figure them out), and were quite exemplary in terms of software engineering practices as far as academic projects go (I've seen much worse!). These were the most complex C/C++ code bases I had encountered to date as of taking the course, and they improved my C/C++ programming abilities considerably as a result.

The closed-book, closed-notes format of the exams was somewhat off-putting to me, since rote memorization is not my forte, and I am of the general persuasion that in practice if I don't know something, then I "just Google it." But in general the exams did not drill down to minutiae and were mostly "fair" and representative of the "big picture" course content (i.e., do be sure to review the provided sample questions and in-lecture quizzes), so I cannot necessarily in good faith over-criticize this particular aspect of the course, either.

The three projects (Projects 1, 3, 4) are all variations on the same theme: building a client-server application to do file transfer operations in two parts, first as single-threaded applications (i.e., one server process and one client process) and then next as multi-threaded applications (i.e., many server threads and many client threads). This was done from multiple perspectives across the three projects: "plain old C with Pthreads" (Project 1), "C using inter-process communication (IPC) mechanisms" (Project 3), and "C++ using gRPC + protocol buffers" (Project 4). Coming to this course from a web development background, these were very insightful projects as a vehicle by which to dive deeper into this subject matter, since in my day-to-day work (REST-based client/server CRUD apps), most of this is abstracted by libraries which I can largely take for granted to "just work" as intended.

Personal Aside

In my own personal case, mid-semester I was pretty burned out after my full-time work picked up as the second project (Project 3) wrapped up. Going into that last stretch of the course (Project 4 and the final exam), it was getting tougher by the week to stick with the course 100% for me. The final project (Project 4) ended up taking me much longer to figure out than the previous ones (Projects 1 & 3), going into Thanksgiving weekend no less. When I figured out where I stood in the class at that particular point in time and realized that I would have to either fight really hard to get up to a borderline A, or otherwise could take it easier and get out with a solid B, I went with the latter approach to avoid any additional undesired stress by that point. I ended up completing only the first part of Project 4 and took the L on that project, and just focused the rest of the remaining time in the semester on the final exam. That strategy was indeed vindicated, as I got out with my "gentleman's B" as anticipated (i.e., the "Bs get degrees" approach). But, to get to that juncture, I did put in solid work for the first half or so of the course, in particular getting 100% on Project 3 (and previously around the averages on both the midterm and Project 1), which gave me the necessary "cushion" to make that decision regarding Project 4 in the first place.

Grading and Class Statistics

The class performance for Fall 2021 is summarized as follows:

| Deliverable   |  Mean    |  Median  |
| Project 1     | ~78/100  |  94/100  |
| Project 3     | ~85/100  | ~97/100  |
| Project 4     | ~84/100  |  97/100  |
| Midterm Exam  | ~80/100  |  82/100  |
| Final Exam    | ~72/100  | (unreported as of this review) |

How I stacked up vs. the class:

• slightly below the mean on both Project 1 and the Midterm Exam
• 100/100 on Project 3
• bombed Project 4 (did not complete Part 2 at all) and only got 39/100
• slightly above the mean on the Final Exam

My achieved grade: B (overall weighted ~75%).

For reference, per the aforementioned data in LITE, the historic grade distribution for this class in the preceding five semesters is as follows:

|   Semester  |   A   |   B   |   C  |   W   |
| 2021 Summer | 33.1% | 15.9% | 2.2% | 45.5% |
| 2021 Spring | 43.0% | 18.9% | 2.7% | 33.3% |
| 2020 Fall   | 43.1% | 21.0% | 2.4% | 31.7% |
| 2020 Summer | 37.6% | 20.3% | 2.0% | 38.4% |
| 2020 Spring | 30.8% | 16.4% | 1.3% | 49.9% |

From that data, the distribution of letter grades (as % of class total) in aggregate via the preceding 5 semesters is as follows:

| Letter Grade |  Mean |   SD  |
|       A      | 37.5% | ±5.6% |
|       B      | 18.5% | ±2.3% |
|       C      |  2.2% | ±0.5% |
|       W      | 39.8% | ±7.8% |

As this data suggests, there is a pretty high drop rate (i.e., Ws), ranging from mid 30s% to mid 40s%. However, if you "make the cut" and stick it out until the end (i.e., past the W/drop deadline, around the end of Project 3), of the remaining 55-65% students in the class, these percentages suggest a fairly generous curve:

(per-semester)

|   Semester  |   A   |   B   |   C  |
| 2021 Summer | 60.7% | 29.2% | 4.0% |
| 2021 Spring | 64.5% | 28.3% | 4.0% |
| 2020 Fall   | 63.1% | 30.7% | 3.5% |
| 2020 Summer | 61.0% | 33.0% | 3.2% |
| 2020 Spring | 61.5% | 32.7% | 2.6% |

(aggregate)

| Letter Grade |  Mean |   SD  |
|       A      | 62.2% | ±1.6% |
|       B      | 30.8% | ±2.1% |
|       C      |  3.5% | ±0.6% |

So, if you stick it out and stay in the top 90-95% of the latter 55-65% "survivors" cohort, you will leave with a B or better. In terms of "cutoffs" (i.e., A vs. B vs. C), it varies semester-to-semester depending on the class performance, so cannot really say a priori (e.g., 90% for an A, 80% for a B, etc.) since the curve is applied at the staff's discretion; therefore, the historic grade distribution is a better general guideline. But, essentially, you can do well on one of projects or exams to get a B in the class, but will likely have to do well (enough) on both to get an A, the cutoff for which is going to hover somewhere in the low-to-mid 80s% or so.

As a final point on grading, the (dis)proportional distribution among the deliverables is a controversial topic (i.e., 50% for 2 exams vs. 45% for 3 projects), given the time-intensive nature of the projects. I can see the validity of the argument for increasing the weighting of the projects relative to the exams for this reason; however, all I can say personally is that I got a lot of depth out of the projects, and I got a lot of breadth/exposure from the lectures. To get the most out of the course, give them both their due attention, and the rest should work itself out grade-wise. If learning is not the desired outcome, then why bother with OMSCS in general (and GIOS in particular) in the first place?

Closing Thoughts

Overall, I'm torn between a "Strongly Liked" and "Liked" for GIOS, but reported the latter since I'm leaning more towards that one. The main thing that steers me away from a definitive "Strongly Liked" is just some of the general vagueness in the projects (i.e., descriptions/readmes and starter code), which made for quite a "time sink" to decipher/comprehend properly in order to get started with the actual coding part. While I agree 100% that there is some necessary "struggle" involved in the learning process to build your chops as a developer, I also do not necessarily agree "wasting time" just for its own sake due to vagueness is the right way to go about the learning process, either. To this end, be sure to stay engaged in Slack early and often, as that is the key to success on the projects. I made some solid friends on there in the process, and they also helped me in my times of need on the projects. In my case (Fall 2021), there were a few "superstars" who cranked through the projects within the first couple weeks of their releases, and then those folks were also kind enough to stick around the projects Slack channels to help others out along the way. Cheers to all fellow Fall 2021ers for making it such a collaborative experience---you're all the real MVPs!

To wrap up, similarly to the sentiment echoed here and elsewhere (e.g., Reddit), GIOS is a great course overall. It gave me a solid knowledge base in things I was lacking prior to GIOS (including in my current full-time dev work) from not having been exposed to this material previously, coming from a non-CS background. In particular, I'm now much more conversant in topics like concurrency, threads & multi-threading, data races, multi-processing, virtual memory, etc. which were largely foreign concepts to me prior to taking the course (previously, I would generally skip the "concurrency stuff" in videos, books, etc. pertaining to programming, thinking it was just some esoteric topic, but now I can go into that subject matter much more competently thanks to GIOS).

This is very much so one of those "canonical CS" topics that you will benefit from gaining exposure to via OMSCS, even if you are not particularly interested in the Computing Systems specialization---the underlying principles transcend the various sub-disciplines in CS, and touch pretty much all things conceptually adjacent to programming in general and to applications programming/development in particular (including in the data science/engineering domains---basically, anything involving an application running on a computer). Therefore, in my opinion, it is still a useful expenditure of a "free elective" slot even in a non-Computing Systems specialization, provided you do the necessary prep work to succeed if you are otherwise lacking in the aforementioned C/C++ core competencies prior to enrolling in the course.

The projects are pretty interesting however the requirements and grade scope tests are pretty bad. The first assignment was literally broken in grade scope and the TA's were completely useless. The TA's don't understand the class material they only know how to solve the projects in the one way they were told to solve them.

The Mid Term and Final are the worst formatting I've ever had for a test. They are pointless but at least just studying the practice exams seemed good enough to get an A in the class.

GIOS fall 2021 review

Overview and the experience Coming from an economics background with Java and Python experience, GIOS was a plunge into the deep end of the swimming pool. There are two parts to the course:

1. Lectures (pretty good, but old, amended, and in some places confusing)
2. Projects

The projects are always tangent on the lectures, but you CANNOT solely rely on lecture material to complete them. They are challenging for someone with not much C/C++ experience, but they were also rewarding and enjoyable. If you decide to take this class, you are in for a challenge—but you will not be at it alone. This class has one of the best online communities in the program, thanks to strong TA’s and participation on slack.

What I got out of it I can code in C. I can confidently describe what an operating system is responsible for and generally go into specifics. I got a taste for distributed computing and how that works. I understand threading, inter and intra process communication using sockets, shared memory, signals, etc. I feel more confident in taking on the rest of the systems specialization.

Where it could have been better Lectures are excellent (info is presented concisely for the amount of material) but can be better in some spots. Exams are weighted heavily. Exams are short. Each question is worth roughly the same as a project’s readme for your overall grade. Papers are good but don’t play a huge part in exams. You ought to read them, but there is little incentive grade-wise.

I took this course without formal knowledge of C. However, I was familiar with pointers/basic memory management. I came from a golang background. 5YOE.

I have to say, the complaints about TAs on reddit seem to be very misconstrued. The TAs here are generally responsive and take a more... socratic approach towards responding, but will assist you if you're outright going in the wrong direction.

What they won't do, however, is to outright debug for you, which is something that I think I've seen a fair amount of in this course, where someone posts a full stack trace and then asks "What's wrong with this".

Projects

The projects are fun, but get more and more vauge as the projects go on. One biggest pain point here is really passing gradescope because you aren't able to replicate some of the scenarios locally.

The projects however do seem to be fairly divorced from some of the lecture materials. The projects generally focus around IPC (MQ, sockets, grpc).

Exams

Memorise everything. No way around it. For the midterms it was 10 MCQ questions. Given the amount content it's extremely hard to spot topics.

The options are all fairly similar so you will really need to know and understand what you memorised.

I should probably mention that you dont need 30 hours a week. The actual work probably can be done in 12 hours a week or so. The remaining of the time is actually spent understanding the project, watching lectures, reading papers, etc. The papers are quite boring at times so I usually get distracted and that added up to the overall time required.

Very rewarding class. Ada is an incredible lecturer that keeps the lectures concise and clear. The class is very well organized in general, and the TA's are helpful.

Projects are very time consuming, especially if you're rusty in C like me. Definitely times I wanted to pull my hair out, but in the end it was worth it.

This is a great course which covers operating systems concepts.

Pros: Clear and crisp lectures. Great labs. Active slack channel.

Cons: Soo much material. Active slack channel to keep up :)

This is a good class to take both if you are new to systems or have experience and want a refresher. The professor is more engaged in this class than I have seen with some other classes, she does the office hour sessions and also participates in Piazza. The lectures are well done, and do a good job at explaining the concepts. This class is good prep for the Advanced OS class.

There are 3 projects, which are challenging. Each is broken into two pieces, an easier warm-up type piece worth 35% and a harder in depth piece worth 55% (plus a 10% project writeup). Partial credit is not hard to earn and it is based on how well each part passes various test cases in GradeScope plus some additional testing the TAs do. Start the projects early!

The midterm and final exams are medium-hard difficulty. The midterm covers a little less material, and the final is not cumulative, it only covers the material after the midterm. Make sure you read the assigned papers, because there are several questions for it on each exam. If you only watch the lectures and do the projects, you will be handicapped on the exam (this happened to me).

Some classes will reduce the workload or have fewer projects in summer, this is not one of those classes. It is a full semester's work in a compressed time frame, and the projects can be quite time consuming. I would suggest taking this class in a full semester (fall/spring), and take a different class in the summer.

Graduated in 2017 with a BSME and some software experience. No experience in C/C++ unfortunately, which bit me very hard. I actually first took this class in Spring and dropped because I took too long to begin the first project, which proved too time-consuming for me to complete at a level I thought was acceptable. Second time around, I got a jump on each of the projects because I knew I would take extra time learning the language on each of them. I thought project 4 was harder than project 3 (most people think the opposite) because I experienced a steep learning curve trying to familiarize myself with C++, just as I had done in project 1. Overall, the class is a great learning experience, I just did not find the subject matter very interesting at all. I heard that this is THE class to take for people who don't have a software undergrad and that is probably true. The projects will really force you to understand what you are trying to do and gain a better understanding of computers 101.

Projects are interesting, but get a jump start on them if you don't have background in this. Honestly, just do it. I thought I didn't need a jump start since I finished everything in undergrad the day before it was due. I was wrong. Don't do it unless you are confident you know what is going on or else you will get a poor grade. We had people in our class that were seasoned software engineers who had worked heavily in C/C++ and they used all of their gradescope attempts on these projects somehow. I averaged about 98.5% on my projects simply by passing every gradescope test and being diligent in my readmes (except for the last one due to burnout :)).

Tests are pretty tricky and really require an intimate knowledge of the lectures (plus some of the papers, maybe 10-20%?) Unfortunately for me, I thought the lectures were almost unbearably boring. I think most people actually do like the subject matter, though. The tests actually are worth more for your grade than the projects, which is nice and not nice at the same time. I spent way less time studying for tests than doing projects, and I'm sure almost everybody else did too. I was average on the midterm but after getting a taste of the format and studying about 8 hrs (in addition to watching lectures and retaining that knowledge) I pulled a high 90 grade on the final, which got me an A (although much less would have probably sufficed due to my project grades, the curb is traditionally from 82 to 88%).

Anyways, good class for learning, but I thought it was really boring and realized C/C++ is not for an ex-Mechanical Engineer like me :)

This was my second OMSCS course (after Networks) and might be the most coding-intensive course I've ever taken (my undergrad was in CS as well). You're really going to want to have some knowledge of C beforehand and be completely comfortable with pointers, or these projects will probably be difficult to the point of being overwhelming. Even with that - and a couple decades of programming experience - I found the projects to be, though not difficult, very time-consuming.

I'm a little disappointed that the projects centered around using particular OS features rather than implementing bits of an OS. But I enjoyed the discussions of implementation approaches in the lectures.

This is my 2nd course in OMSCS. All my fellow classmates from Spring 2021 have covered everything I had to say. But I'd like to emphasis on the below things:

1. Projects: Getting an initial understanding of the structure/design of the project is one of the hardest parts. Once you figure out what exactly you have to do, it's only a matter of time before you get the desired result. As other have pointed out, the help and support you receive from fellow classmates in Slack and Piazza are immensely helpful in progressing on the projects, so look out keenly for those.

Some people also face issues with autograder - the code sometimes works flawlessly in your local VM, but crashes miserably in the autograder. I myself encountered that in P3, and had to restart the project from scratch and finally got it passing the autograder. I still have no idea why it did not work initially.

The amount of time you spend on the projects vary depending on the circumstance - I spent 20+ hours on the 1st and more the 50+ on the second (simply because of the issue I started earlier). Regardless I really enjoyed the projects and I would do it all over again if I should. The satisfaction you get when the autograder finally passes all the test cases is second to nothing (fight me on this!)

I personally learnt majorly through the projects than preparing for the exams (which was more a formality to get a good grade).

2. Exams: There are quiet a few amount of topics covered in a 2 hour exam in a MCQ format. They were not necessarily hard, but were tricky indeed. I got a 85 in midterm which was slightly above par and 66 in finals which was amongst the lowest.

I managed to get an A because I had 100% in all the projects. The exams might be a hit and a miss, hence getting as close to full marks on the projects is important for a good grade from my experience.

There are 3 projects, 2 exams. To ace the exams- Watch lecture videos, and go through the papers at a high-level 30-60mins for 4-5 papers.

To ace, the projects- Start early. Proj 1 is on sockets, Proj 2 is on shared memory and Proj 3 is on gRPC. Did not like Proj3 as it was not aligned with lectures. Proj 1 and 2 are excellent.

Good starting course to the program especially if you are looking for computing systems specialisation!

Background

• Non-CS degree, very little C programming

Content

• Absolutely vital to become good programmer
• Videos enjoyable and easy to watch without being bored
• Papers are inadvertently impossible to read
• 10-20% of the midterm/finals are based on the papers

TAs / Prof

• Super responsive and positive

Projects

• Will SLAP you silly if you lack C/C++ / socket design
• Still definitely doable, but you won't have any free time
• Read & ask questions thoroughly in Piazza/Slack

Project 1

• Complete the warmup ASAP
• Part 2 worth more points than part 1
• Might be better to tackle the part 2 first
• Refer to Beej's Guide to Network Programming

Project 2

• Again, start as early as possible
• Completed part 1 in a day, then got cocky & failed part 2
• Part 2 is the bulk of the project.

Project 3

• Still considerably difficult
• Read up on gRPC & Distributed File Systems
• Basically client/server interactions and synching them up

Midterm/Final

• Very fair, read the papers & watch the videos
• Seriously grasp the content & you're good
• Very little of the exams are trivial
• Not cumulative

Cons

• Sometimes very hard to find tutorials on the project. Without Piazza/Slack I would've failed miserably due to the lack of any good content online

9/10 would recommend

Background: I have a BS in Mechanical Engineering graduating with a 3.1. I work in C++, Python and Matlab at work so I'm not a complete stranger to the programming aspects prior to this course. This was my first OMSCS course.

I struggled quite a bit in this course. I'll give a brief overview of each graded portion of the class, with the grade I got in parentheses:

Project 1 (76)

Difficult, but I spent probably the longest time on this project than any other. Use Beej's Guide to get a fast start on it. Also, finishing the second part of this one will help you conceptually on the next Project, which is sort of a continuation of the first. The warmups helped beef my grade some.

Project 3 (35)

The autograder killed me on this one. It worked locally on my machine except for a couple bugs, but the autograder gave me zeros for nearly every test. Very much an all or nothing project, where I got almost nothing. Definitely the most stressful project, and made it very clear the other students were a ton more helpful than the TAs.

Project 4 (68)

Important tip - make sure your environment is set up properly by this Project... I had been coasting on using a different version of Ubuntu with VMWare before this Project, but this Project has some other dependencies. I spent way too long on trying to hack my way through getting it to work with my environment and ended up giving up and using Docker (which is great btw, I should've switched sooner). Not a bad project, I just made some bad time management decisions.

Midterm (75) / Final Exam (73)

Watched all lectures, read omscs-notes, did NOT read all the papers, and reviewed all the quizzes and answers to the practice problems/review she gives. I'm probably a bit behind the pack though, so reading the papers may have been helpful. Questions are petty fair, no "gotchas", but occasionally I'd finish a question thinking it could've been reworded to be more clear.

Overall

Great course, no regrets, but I hope my future classes don't starve my free time as much as this one.

Background: CS Bachelors' Degree / 10+ years as Web Developer. This course has too much content for an introductory class. Especially for the final exam, it comprises too many lectures. The midterm was fair but the final was a little confusing in terms of wording. Projects are SUPER hard, no matter how much people say the opposite. TAs did not help that much, they were either super busy or just giving high level (sometimes rude) replies that do not clear the issues.

Background: Bachelor's Degree in Electrical Engineering, did some refresher CS courses in community college and some MOOCs before being admitted to OMSCS. Not much of a CS background. This is my 5th class after AI4R, CN, SAD, and ML4T.

I can see why people really enjoy this class. The professor is very dedicated, the lectures are very informative and clear, and for an experienced software engineer I can see this class really leveling up your skills.

For me personally, this is the first class I've taken in years where I can say I didn't really enjoy it. The whole time I was just trying not to drown. Part of that was just some bad luck with having to move in the middle of the semester and losing 4 or 5 days of valuable time. But even if I had that time, I don't think I would have been able to get an A.

It really was just drinking from a firehose non-stop with no breaks and no chance to catch your breath. 0% of this class was review for me. When I see folks posting that they only spent 10 hours a week on this class, they must just be wizards. All my free time was taken up with this class and I didn't have a snowball's chance in hell at an A. It easily ranks in the top 5 hardest classes I've ever taken, and my 75.5% final overall grade is the worst I can remember ever receiving.

With that said, I don't regret taking this class. I enrolled with the intention of becoming a better engineer and I certainly got that.

If you're like me, with little CS background compared to your peers in the program, you will need the following to get an A in this class:

• Solid grasp of C and ability to do string and memory manipulation without thinking hard about it
• 35 to 40 hours a week to dedicate to this class alone
• Some good luck

I will still recommend this class, because without a doubt you will learn a ton that will make you a better engineer no matter your specialization. I feel like this class is brutal, but fair.

CS-6200 (Spring 2021)

TL;DR - The class has great content, the tests are fair, the projects are decent, and the TA support was hit-or-miss at best. It's not easy, but still crammable.

My grade: A

Lecture Material

The lecture material was actually quite good. It may not feel like it on first pass, but it covers pretty much everything in sufficient detail. There are times where you're expect to kind of fill-in-the-blanks intellectually, especially with certain calculations. And, there was a lot of errata which was a bit frustrating, especially when the errata was itself not always correct. But, still, pretty good content and at least personally the video formate was quite nice.

Life Hack: There are several resources provided at the start of the semester that are effectively group-compiled notes. Some of them are quite good and can probably save you a lot of study time with the test preparation.

Tests: Midterm/Final

The tests are based on the lecture material, and I personally don't think there were too many surprises. They will test you on minutia, so if you cram you're likely to miss points unless you've got an effecive photographic memory. Having said that, a good chunk of the tests were conceptual and/or mathematical. The math is basic arithmatic, so nothing challenging. But, you do need to understand the concept to apply the math.

Overall, the tests were very fair, but to do well, you'll need to commit to some studying. I am a fairly good crammer, and I could cram the material in 3-4 days of study without really reviewing it previously. The midterm was easier to cram than the final as it just had a lot more material. If you're not a good crammer and/or want to ensure good test scores, I'd suggest starting at least 1.5 - 2 weeks before the test.

Having said that, I feel strongly that the information is quite good, and even fun. So, unless you've got a ton of life obligations prohibiting you from making a deep-drive, I'd try to keeup up with the studies all the way through so you do not have to cram.

Projects

The projects I'm a bit conflicted on. I felt they were fairly fun, but the biggest challenge for me personally was often just sifting through the API and documentation to get started. After that, it's fairly plug-and-chug.

Generic advice

• If you're not familiar with Gradescope and it's auto-grader, again, start early. You'll want to be able to troubleshoot your errors
• The C programming language is not forgiving. You need to know what you're doing in terms of memory management and the behavior of functions you leverage. Read the documentation (e.g. man pages) and understand the API of every function you call. Yes, it's important. The difference between sprintf and snprintf could be quite dramatic as one of those two can lead to you accidentall obliterating structures in memory and ending up with errors on gradescope that don't show up locally and that make absolutely no sense given you're not able to effectively debug since you won't be able to reproduce them locally.
• If you start early, you'll likely get 100% on all projects. Conceptually the projects aren't that bad, but you'll need time to debug your C code.
• Use MermaidJS to create control flow graphs. They'll help you in your implementation, and you can copy them to your Readme file later, which means easy points.

Project 1

Overall, it was quite fun. I'm not sure how much we can give away, but I enjoyed writing my first multi-threaded program and learning the PThreads library.

• Start early unless you're already familiar with C and network programming. There is a warm-up that will get you prepare to jump into the next steps, and many people spent a solid long weekend on just the warm-up.
• You'll want to ensure you really understand the API provided in the boilerplate code. So, dig through it, ask questions, talk on Slack or Discord, etc.
• You'll need time to debug. Just start early.
• If you can unit test a function, just do it. I used cmocka and found it easy to use and quite helpful.

Project 3

Again, quite fun. Learning about implementing interprocess communication mechanisms in the Linux environment was incredibly enlightening and felt kind of fun and hacky when doing end-to-end testing.

• Again, start early. You'll want time to debug.
• Design was harder than Project 1, in my opinion, so control of flow graphs were very helpful.
• Don't get clever, just use the IPC mechanism that the rest of the class is using. You'll want to be able to troubleshoot together. Time is of the essence, and debugging is the most time consuming problem IMO.

Project 4

I really didn't care for this project. I was excited because it leveraged gRPC, and the documentation was the best of all of the projects. But, from the perspective of someone who has never used C++ I personally think C++ is a disaster and the C++ implementation of the gRPC library felt like a disaster. I've used many different programming languages and generally it's very easy to switch between them, but I hated C++ and it's gRPC implementation.

• Start very early if you're not familiar with C++ and/or gRPC.
• The project itself isn't that hard from a conceptual level, but the implementation can be a disaster if you're not familiar with C++ and gRPC.

The TA's

I don't want to generate a blanket statement. I personally had limited interactions with them, and I know there are likely some great TA's. But, some of those interactions were quite poor. I realize they're probably very busy and not making a ton of money to do this job, but there were some who very much lacked empathy, appeared hostile toward the students who didn't understand what the TA's have been doing for years (as if they never struggled in teh learning phase), and at times it was wholly unprofessional and unbecoming of a well-regarded technical institution like Georgia Tech.

Concluding Remarks

The material was quite good. I liked this class, but could have loved this class. The major factors negatively interfering were interactions with some of the TA's, and I just wasn't a fan of the first two projects documentation, and the third project I was simply biased against the tools we had to use. But, admittedly, that's personal preference.

If you're strong in C/C++, this class won't be hard for you. If you're not, well, consider brushing up on C first unless you can learn quickly on the fly.

4th/5th class (taken with SAD)

Overall: it's a good class, though overhyped based on other reviews ("best class in the program!"). I highly recommend you take it though, as the content is foundational to other parts of CS and Prof. Gavrilovska genuinely cares about her students and improving the course.

Projects: as is the case for most classes, this is where most of the learning occurs. You'll learn a ton from completing the projects, especially if you have no background in C/C++/systems programming. Also as is the case for most classes, there is some divergence between the lectures and the projects. The lecture content helps little for P1; it's mostly a crash course in C and socket programming. The lectures help more for P3 and P4, although the recommended lecture schedule is such that the project timelines don't align well with the lectures you're supposed to watch that week. Thankfully, you can skip around in the lecture schedule without much issue. You'll come out of the projects a better programmer, but there is a fair amount of unnecessary pain in the form of not well written READMEs and undocumented project requirements.

Lectures: a mixed bag, some are more effective than others in terms of clarity. A lot of errata, not just in the instructor notes, but also in a PDF (that hasn't been updated since 2018) and a errata thread on Piazza. All of those errata should just be consolidated in the instructor notes under the appropriate lecture section for easy reference. There's also a ton of content, particularly after the midterm. Personally, I think I'd learn this type of content better by reading a textbook instead of having to constantly pause the lecture video and try to digest what was just said.

Exams: like many students, I'm not a fan of how so much content gets boiled down to 10-15 questions in each exam. There could be hours of content per lecture to cover, but if you didn't focus on the specific topic that gets covered by that lecture's exam question, you're out of luck. I especially didn't like how the recommended lecture schedule has you watch 2 sets of lectures (20% of the final exam content) the same week you're supposed to take the final exam. It's just too much content and too little time. Some of the exam questions are also of iffy quality.

TAs: generally helpful on Slack/Piazza, but fellow students were shouldering the majority of the question answering. This is fine in most cases, but not when there are questions that require an authoritative answer (error in lecture content, ambiguous project instructions). Some of the TAs basically didn't participate in Slack or Piazza, so all they were doing is grading. I think the course could benefit from more TA interaction.

This was my first course in the program, and as others have noted, it was a great first course. My background is in electrical engineering, I have no professional programming experience but plenty of experience in class/side projects in C and C++.

The projects were great IMO. The first 2 are in C, last is in C++. Even with a full-time job + a small kid, I had enough time to finish them.

I was not a huge fan of the exams, though they weren't too unfair. I had a few small complaints about them. Namely, each exam was worth 25% of the grade, which is a bit much given that they seem to pick and choose topics from the lectures to test you on, so if you spent a lot of time on one subject, the test could ask about a different one and you'd be out of luck.

I had an A going into the final, though I had to basically take 2 week off to move + start a new job so I fell behind at the end and may end up with a B given that I had to cram for the final, but oh well. At the end, other than my small complaints about the tests, the course was a fantastic intro to OS topics, and really helped me cement my C/C++ abilities. Recommended if you are at all interested in the subject matter.

Just finished the final exam and for some context:

• This is my first course in OMSCS
• I don't have a CS background (i.e. C was completely new to me, along with C++ which are both used in the assignments)
• Didn't do prep work beforehand
• Probably getting an A

All I have to say is that this course was fantastic and exceeded my expectations.

Projects

I was intimidated going into this course with the lack of programming experience. However, it's true what former students have mentioned — it does get better with each project. I probably spent in total over 100 hours in total across 3 projects and the only tip I have is to start as soon as possible the moment projects are released.

Both Slack and Piazza were excellent where TAs and professor were super prompt and helpful in answering the questions. However, I relied more on the former as it's more active and often quicker to find your answers since other students would have had a similar issue.

Everything was A+ including setting up of your environment (which had instructions given) to the lengthy documentations and resources that were given. I thoroughly enjoyed the projects.

Exams

Lectures were super comprehensive. Office hours were helpful in clarifying questions that students had. There's a lot to digest so it'll require more studying time for the finals. Project 4's deadline is pretty close to the final exam so finishing Project 4 asap has been recommended by the TA(s) in order to cram in enough time for studying.

Additional thoughts

I wish that the projects have a higher weightage, purely based on how much effort went into them in comparison to the exams. I think this sentiment was shared in previous reviews as well.

But all in all - a great class that is well-run and executed! The TAs and professor definitely deserve a lot of credit for their hard work.

I took this class because I wanted to be more well rounded in my CS experience and understanding. I struggled a lot and was only able to dedicate ~15 hours a week to it

Pros:

• Lectures are great and professor is active
• 55% of your grade has nothing to do with coding so you can survive even if you don't know C super well

Cons:

• Coding assignments I thought were not structured well. Generally speaking they were split into Part 1 and Part 2 for each. My issue was both of these basically were all or nothing. Either you solved the problem and got 95% or above or you couldn't solve it and got like 40% or below. There really wasn't much room for partial credit with the autograder so it could be quite demoralizing if you are like me.
• The last project is maybe the most confusing project I've seen. They need to fix the writeup imo. I couldn't solve it. Everyone said its the 'easy' project but I just found it so confusing that I figured it wasn't worth my effort and to focus on the final instead. I think it paid off but I don't have my grade yet.

If you are trying to learn C (like me) at the same time you take this course and you can dedicate less than 20 hours a week, you can definitely still pass! But you need to get comfortable that you might not get an A. Decide what you want between your work/life balance and what is more important: the coding, the knowledge or both. Once you answer that stick with it and stay in the course till the end :)

I disagree that this is one of the best courses in the OMSCS personally but I could definitely be biased so if you think this course sounds fun or interesting then go ahead and have fun!

Background: CS related bachelor, 8 years experience, currently senior developer. Completed CN so far, for comparison that took 5 hours per week.

This is a well run course that covers a wide variety of topics. If you have not taken an OS course before, this will be worth your time.

The projects are not overly complex if you have a solid software development background. Most of my time was spent figuring out C/C++ APIs, and understanding the existing code, rather than focus on the actual class topics. I found the application of theory to be somewhat rudimentary, although perhaps AOS will dive more into that.

Project 1 - 21 hours - most of the time is spent getting used to coding in C. Project 2 - 13 hours - straightforward project focused on shared memory Project 3 - 15 hours - gRPC

If you have no C experience it would be good to spend some time going through a book before starting work on the projects. I spent about 10 hours prior to class start going through Head First C, and doing some practice problems. C has some features that are not intuitive. Going through a book that can point out common pitfalls will save you countless hours later.

If you're concerned that this course is too difficult, go through P2L1 and P2L2 on Udacity. Next, complete the Problem Set 1. If you can complete these, then you will be able to complete the projects in this course.

Pros:

• Challenging projects, if you haven't worked with MT, MP servers before.
• Good comradery in Slack. Fun chatting, getting, and giving help there.
• Instructor is involved, very knowledgeable and caring.
• Presentations are well done. Packed with information.

Cons:

• Tests carry a broad scope. 10 lessons for the final exam.
• Depending on your background, studying for tests may have to happen concurrent to completing projects.
• Grading turn around is pretty slow.

Recommendations:

• Study Operating Systems: 3 Easy Pieces before taking the class.
• Work on some programs using C. Make sure you understand pointers and consider how C handles strings.
• Watch the lessons, take notes, then watch them a 2nd (or 3rd) time at faster speed to review.
• Read the papers AFTER you've watched the lessons at least once.
• Participate on Slack.

Overall:

• I would recommend this class, even if you've taken an OS class before.
• Many students drop, but if you are willing to work hard, whether or not you have background with C or C++, you can succeed.
• There's a good vibe with this class. It's hard not to appreciate it. Is it the best course in OMSCS? Not sure, but it's definitely one of the better ones.

Just finished the final projects, time for the final exam sprint.

Workload from github commits number:
Proj 1 186 commits
Proj 3 226 commits
Proj 4 108 commits

Literally, the whole proj 3 took me around 6 days(including dream with debugging).

I took it in my first semester. Lots of dirty, gritty, embedded programming. A true software engineering experience. Still beginner friendly, since they don't assume much prerequisite math or patterns. But you have to learn the tools quickly: an IDE, docker/vagrant, netcat, AddressSanitizer, bash scripting, and how to run any unit tests the smarter students share on Piazza. The research papers are not that necessary to read, since the lectures talk about them extensively too.

Others have already said it all. Challenging and rewarding class. Well-done lectures. The projects were very challenging and intimidating, but somehow I was always able to figure them out. Slack channel was super helpful whenever I got stuck. Every project feels like a worthwhile accomplishment once you get it. The only bad part of this course was the midterm and final--they are a very high percentage of the grade but are short multiple choice tests that are not comprehensive. This made me angry at the time, however the generous curve means you can miss questions on the exams and still get an A if you do well on the projects. Recommend.

1. Background

• Education:
  • Bachelor's of CS (2019) from a name-brand Canadian university
• Work:
  • currently working full time
  • software developer YOE: 2 years (mostly with C++)
  • current work tech stack: primarily C++, a bit of Python, Linux/Unix
  • industry: quantitative finance at a big bank
• Previous OMSCS course:
  • N/A (matriculation fall 2020)
• Term: Fall 2020
  • first term of OMSCS
  • working full time
  • only took one course (GIOS) during Fall 2020
• My Relevant Experience
  • Took OS as an undergrad, did poorly
  • Have worked with C++ for the last 2 years, so I am familiar with working with pointers and memory, as well as C-style syntax

2. Review

1. Difficulty: 8/10 This course is relatively hard if you want an A. If you just want a B, the curve is usually really generous, so it would not too hard. If you have not taken an OS course before, and/or are not comfortable with programming in C in a Linux environment, the assignments will be a big challenge.

The assignments are difficult mainly due to scope and breadth of requirements. They are not difficult to implement, but do take a long time to finish and debug (i.e. concurrency issues).

The exams are not too difficult. As long as you review the practice questions and do all the module quizzes, it is not hard to get 70%+ on them. But because the midterm and exam make up 55% of the course mark, it is a bit more difficult to get a high enough mark for an A. (Make sure you know how to do any question that involves actually calculating numbers)

2. Time Commitment: 10/10 If you want to cover all the course content, this course will be very time consuming. Between the long assignments and the lectures, it is easy to spend 20+ hours per week. However, if you only watch the course lectures and are not aiming for 100% on the assignments (that is to say, are happy with a B), I think this course is far less demanding.

Lectures: there is a big volume of lectures, a module per week. A module in total is probably 30-60 minutes of content.

Papers: there are a lot of papers to read (almost 1 per a week). You can probably get away without reading any, but they are interesting (albeit very dry and technical at times)

Assignments: this is the biggest time sink. The estimations of time for GIOS assignment is quite accurate on omscentral. I think each assignment took me at least 30+ hours, so basically two or three weekends.

3. Quality of Instruction: 10/10 The modules were well recorded, informative and digestible. Sometimes the content is a bit light on details, and I feel the syllabus might be trying to cover too much content and not enough depth, but overall great quality of teaching.

4. Usefulness: 10/10 I may be bias, but I think OS is a fundamental course and should be required for everyone getting a CS degree. Although it might not be directly related to AI/ML or Robotics, understanding concepts such as process/threads, basic synchronization constructs, device/hardware, file systems, parallelism, etc. goes a long way to help you develop better code.

3. Overall Thoughts

Even though I had taken OS during undergrad, and have solid relevant experience working with C-style languages, I still found this course challenging, in a good way, and I feel that this course was a great introductory course. For reference I ended up with ~85% (A) in the course, scoring 95%-100% on each assignment. I also watched all the lectures and read all the paper. I was aiming for an A, therefore invested a lot of time in the course (25-35 hours per week). With that said, the curve is generous, and a B is usually ~60%. So there is a large margin of error, and room for learning.

I completely agree with the majority of OMSCS students. I think this course is well-ran, with great content and engaging assignments. I think this course is a must-take and you will end up learning something useful regardless of your experience.

TL;DR difficult and time consuming, but worth it. very useful content. 10/10, would take again

A reviewer described this course as both learning C/C++ and learning operating systems (depending on your background). In my experience, I couldn't agree more. I didn't have experience in either so I walked away learning a lot. Disclaimer - this course doesn't teach C/C++. You'll have to "self-teach". This course helped me grow at my company where senior SWEs are expected to manage and implement both software and systems.

If you want to learn systems fundamentals and are interested in writing software that reinforces those concepts, you'll benefit greatly from this. C is the operating systems language and C++ is a superset of C that is used in large systems/services. If you're on the fence about learning these languages, either because you've heard they're challenging or may not be applicable at your company, consider how learning these languages will help you learn a language like Golang or Rust (newer, trendier and simpler languages) that you may not know or are currently using. Those languages will seem similar to C/C++.

I spent 2-4 weeks during the break familiarizing myself with C, since the first 2 projects use it. I used Pluralsight for on-demand video training, read most of "The C Programming Language" book and probably did between 15-20 hours of tinkering with all the basics. If you're similar to me, I'd recommend doing this before the class (which is what I did) or you'll probably fall behind. Even with my preparation I still found myself on Slack asking basic questions like why my string concatenation is causing a SEGV runtime error.

If you're interested in systems and backend development, understanding operating systems is fundamental to larger systems which are more likely to be needed to scale today's applications. The distributed file system project at the end was particularly interesting, because it is so commonly used in practice. Overall, this is a great introduction to multiple things, but it depends on what you're interested in. It also required a lot of time, because I struggled with what could be simple things (and it seemed like most students did too). However, I usually started right when the project was released and finished a week or two early. I received 100% on each project. The mid-term and final were really about memorizing the papers which I didn't focus on. I received a C and D on these but ended with an A. As a wise reviewer below said "embrace the curve".

This was my first course in the program and I really liked it.

Project 1 and 3 were great! Project 4 was OK, thumbs up for it for gRPC being a current technology.

Pros:

• You'll get a lot of knowledge out of the projects, and I would say 80% of the knowledge and the time spent on this course will come from them
• TAs seems to be responsive on Piazza, nothing to complain about that

Cons:

• Projects are only 40% of the total grade, IMHO they should be at least 60% of it
• Sometimes the lectures and the projects stray from each other and I wish they were more in sync (like project4)
• Most papers are dry

It's a great course and I believe everyone in the Computing Systems specialization should take it, you'll definitely come out of it as a better developer/software engineer.

This was my first course in the program and I think it was a great introductory course. I came into this class with basically no C experience. Project 1 was a real struggle and I put a ton of time and effort into it. I think anyone without C experience can do well on the projects but just know that you'll put in significantly more time. The TA run Slack channel was absolutely vital for this class. Whenever I got stuck on something, I would explain my problem in the Slack and either a TA or another student would give me a push in the right direction.

After project 1, the class was smooth sailing. The second project required a good design before coding but I just read through the whole project Slack channel and the design was basically explained by the TAs and other students. The last project was in C++ and the code was hard to understand at first but once I realized what all the pieces were doing and how the files interacted with each other, it ended up being the easiest of the 3 projects. I found all of the projects to be fun, challenging and very rewarding. The feeling of seeing your code pass all the auto-grader tests was the best dopamine rush I've ever gotten from school.

The exams in this class honestly suck. The entire course, containing hours and hours of lecture content is condensed into 2 short multiple choice exams. The lecture content (that I bothered to watch) is well done and does a good job of explaining complex topics in simple ways. I felt like it was pointless to try to study hard for the exams because they cover such a vast amount of content and are mostly multiple choice so you can make best guesses on a lot of stuff.

As far as time commitment, during weeks when I was working on the project, I was putting in 20-30 hours a week on top of working full time. I started the projects as soon as they were available and usually finished them in about half the time allotted. When I wasn't working on a project, there wasn't much to do so I had some down time this semester. My best guess for how much total time I spent on each project would be:

Project 1 - 70 hours
Project 2 - 50 hours
Project 3 - 25 hours

I chose to spend about 90% of my time in this class on projects and 10% on lectures/exams because projects == fun and memorizing stuff != fun. I watched all the lectures for the first half of the semester and spent a few hours studying for the midterm. I didn't watch a single lecture for the second half of the semester or bother studying at all. I just yeeted the final exam, making my best guess on everything.

My grade breakdown:

Project 1 - 100
Project 2/3 - 97 (Missed 3 points on the write-up. TA must have been in a bad mood.)
Project 4 - 100
Midterm Exam - 64
Final Exam - 56

Final Grade - 77 (B)

I think GIOS is a great first class. The projects are awesome and made me a better programmer. The lectures are good but I was too busy with work and the projects to want to spend much time on them. The projects should be weighted much heavier than the exams because they are the bulk of the class. The explanation given for weighting exams heavier than projects was so that students who don't do well on the projects still have a chance to pass. Given that this is a graduate program at a top tier CS school, I don't think giving students a cop-out to flunk the projects is a good reason.

Really amazing class. The projects are challenging and informative, the lecturer is great, and the exams are fair. I didn't have any C experience going in and learned a ton. Amazing TAs too, and the slack is really great environment for learning, they can be a bit intense, but they just want you to learn. I think the difficulty might be a bit overstated. The projects are hard, certainly - so don't slack off, especially for project 1, but outside the projects the class is fairly easy so if you time manage well the workload shouldn't be too bad. I slightly regret not taking another class alongside it.

If it is relevant I got an A (final grade = 93.4)

Note: 12hr/wk is an average and consists of some 2.5 hour weeks and some 30 hour weeks

Took GIOS alongside AI Ethics and Society as my 6th and 7th classes, after AI, RL, CV, ML and HDDA.

This was a great class, I agree with the other reviewers who say it's a must-take for anyone who came into OMSCS without a CS background or without having previously taken an OS class. The lectures are excellent and implementing the projects really exposes all of the things you think you understand from watching the lectures but actually don't.

I had no experience with C or C++ prior to this class, so there was a bit of a learning curve when starting project 1. I spent the first 2 weeks learning C by reading the K&R book, but there's probably a more modern resource for learning C nowadays.

The only minor gripe I had was that there was no test suite provided. For the first project this was okay since we could test our implementations against other students' code (those who had finished the project early), but for the 2 other projects I ended up using the grader as a test suite.

This was a good class. I have nothing to add that others haven't already said.

If you haven't taken an OS class before, need a refresher before taking AOS, or want to cut your teeth on some C and C++ projects: take this class. You won't regret it. Good luck!

This course RUINED my experience in the OMSCS programme!

It was my first course, and I chose it because I wanted to get a feel for what a "difficult" course was like in OMSCS, plus it was foundational, and I figured I could eke out a B (hopefully).

I have work experience in the general field so I knew some stuff going in but I was incredibly rusty with programming.

The lecture content was very interesting, a very good range and diversity of content (and getting into the realm of supercomputers was good for me). The lecturer, Ada, was active on Piazza and there was a very vibrant community on Slack.

Assignments were challenging - especially for a first course - but they were oh so rewarding. Definitely a bonding experience with the rest of the class as we teamed up to survive. It was really good and highly recommended. 7 courses later I still think they have been the best assignments I've had in the OMSCS programme. I suffered through nation-wide power-cuts throughout the term (up to 5 hours a day of no electricity) and the TA team were very sympathetic, even though I never asked for an extension; they were just aware of my challenges and were very encouraging in their feedback (more on that later).

The assigned readings were very informative and I am glad we were told to read them.

The exams were fun, if that's possible - only a few "big" questions that required applying our minds and doing calculations and so on, so it wasn't just plain multiple-choice that you might be able to guess - there was real hardcore work involved (pen, paper, calculator).

The Office Hours were fantastic and really interesting (Tony and Ada were also a good team! They always looked interested and enthusiastic, which helps tremendously for students).

So, in summary, this course was so good that it RUINED my OMSCS programme because it was my first course and I didn't think anything could be better (and in many ways, it has remained that way; but thankfully most of my other courses have had their own pleasant surprises).

I started my first assignment with a 55% and the TA's observed that I was pretty rusty with my coding and had incessant power cuts, so they just said encouraging things in the feedback and reached out to me on Slack. I managed my time better for assignment 2, and made a 70, then a 90, and finally a 100 - then did really well in my exams (85%+ on both), and landed up with an average of 83% which was curved up to an A (not only to me, but the class applies a curve - I made the cut-off by something like 0.23%).

So, for my first experience in OMSCS, I took what is considered a challenging course, loved it, learned a lot, established a community of peers and friends (one has become my official GA Tech study buddy :)), and surprised myself with an A - and now I would recommend that EVERYONE takes this course! Just be prepared to have most other courses become a disappointment by comparison :-)

SUMMARY: It's a lot of work - 20 to 25 hours a week for me; It's challenging; It's informative; It's interesting; It's awesome; It's worth it!

This is a fantastic class and (as others have said) I have a hard time imagining there is a better first class to take in the program (unless you already have extensive OS experience).

The projects build on each other incredibly well and each feels like an accomplishment when completed. The exams ask some very specific questions of the material so doing well is really a function of time put towards studying, but overall are fair.

In general, I think the class has a fantastic ROI in terms of amount learned per unit of effort put in. Thoroughly enjoyed + recommend taking!

.

My background: 3 years experience as a penetration tester, no formal CS background from undergrad.

The projects in this course will take a lot of time, start early. The tests are difficult, study as much as you can handle. I got near 100% on each project, and ~65% on both tests and still passed the class. I learned a ton and am happy with that result.

If you don't have knowledge of Operating systems you NEED to take this course. It provides foundational knowledge that will carry over into nearly every other aspect of using computers. Yes it is hard, yes you will spend a lot of time on projects. That is why you signed up for this program, take this course.

The projects in this class are very hard. Don't get burned out on them and neglect the exams which are hard but with enough time you will do fine. The curve in this class is nice too. Ada is one of the best professors in the program hosting office hours and being active on piazza, Tony is awesome as well. Some of the TAs are very sarcastic on slack but they are cool though. this class was a lot of work for me because it was my first class in the program and I have an EE background but it helped make great habits for the past two years! <3

I would really not recommend this to someone over the summer who does not have a strong C foundation. It takes alot of work just to keep up with the summer pace. I personally had a lot going on and would spend time down to the wire trying to get everything in by the deadline.( I think I submitted P2 and P4 an hour before the deadline). The summer schedule is really tight, like 3 weeks on average for each projects plus 2 exams crammed in there. The amount of content to retain is quite alot and like the curve is nice, and I thought about taking a W a couple of times because I didn't think I would make it.

But Tho's shining self came in and helped me feel better about my position because he CARES about students passing and is very helpful. Whether it's his thos-c-posium or as a cheerleader. IMO, I don't think anyone is rooting for anyone to fail, like I get that sarcasm doesn't always transfer well but I felt that the TA crew on slack and piazza were responsive and on top of it. Sure they have lives, but like you can't tell by the amount of time they spend on slack responding to the numerous redundant questions being posed.

Overall, I wish I took it in a fall/spring semester so I could get the full experience and let the content sit in and marinate more.

I took this as my first course of the degree program and found it to have a right balance.. It covers a wide range of operating system internals, the assignments involve a good amount of programming and exams are moderate in difficulty.

A basic understanding of C programming would be very helpful in completing the assignments ( to the level of being comfortable with pointers ) .

The office hours are regularly conducted by the professor and all questions are answered during the office hours. But didn't find TA/Piazza forum very welcome/helpful in answering questions. That's one area that definitely needs improvement.

I'd strongly recommend this one for a starter course for the program. It adds value and helps in getting through the initial nerves of getting used to the modalities of an online program.

A great course...

Originally I decided not to write a review because I felt I had nothing new to say. It is true that you learn a ton, and I am better off for the experience. Zero regrets on taking the course. It is awesome and definitely worth taking.

except for “that TA”

However, I am retroactively writing this because I am concerned after reading a recent review for this past summer. My only issue with the course was a single TA whom I shall not name. He was incredibly rude and condescending toward students. I figured it was a one off semester issue, and I didn’t want to taint the experiences of other students by talking about this guy. But I’ve seen him on other Slack channels, and according to one summer session reviewer, he’s still working as a TA in GIOS. He’s a cancer to OMSCS and really blemishes what is an otherwise excellent program. To be clear, I am not referring to the head TA.

This was my first semester and loved the class. The projects were difficult, more so if you did not have the prereqisite knowledge. Exams were relatively easy if you understood the material throughly. You might have to go through the materials multiple times to have a firm grasp of the subject. Check out the full review and learning outcomes of the class at my site OMSCS Journey : GIOS

This was a very challenging course for me. My background is a Systems and Informatics Engineering undergratuate, but I havent programmed in 10 years (only for OMSCS courses in Python), also I have never programed or took a course on C or C++ before, nor have worked with pointers.

Projects are worth 40% and there are 3 of them, for me they were of almost the same level of difficulty. Each project took me around 70 hours (70 real hours, each full day of work is 8 hours, so around 8 complete days or 4 weekends, please start projects early as they are impossible to do in the last weekend before the delivery date), still I struggled a lot, I really recommend everybody who is going take the course, learn about C and Pointers before the class starts and also to start each project from day 1, otherwise you will run out of time. Also dont forget to join the official slack channel during the course, as it is a very straighforward communication channel and I found it more useful than Piazza to solve problems during the projects.

Midterm and Final are worth 25% and 30% and they test a lot of content each (each one feel like a whole course exam, specially the final), still, if you start to study early the lectures and do all of the practice questions you should do fine.

I am very thankful to Ada and the TAs, also to everybody that gave advice on slack, this is a course were I felt more connection with the Proffesor and TAs than other courses I have taken.

This course is very rewarding and I am glad I took it, I learned a lot from it, I recommend GIOS to everybody who wants a challenging course and learn a lot about operating systems, a skill I think is very important for every computer science student and graduate.

GIOS has a very high curve, so do not desesperate if failing on one project, you should still do good, but try to start next project earlier.

Should we talk about the TAs?

I think we need to talk about the TAs. They’re a problem. There are a handful that are helpful, but they don't spend nearly as much time on Slack as the two that are not only almost 100% unhelpful, but actually disruptive and destructive. They know who they are. Everyone knows who they are.

The only thing you can really do with these TAs is ignore them and hope they go away. Sometimes it works. Many times they successfully derail things, and it would be better if they would just be quiet instead of obnoxious and disruptive. They’re way too busy trying to live up to their reputation and out-troll each other. I think this was the last semester for one of the worst of them, though.

Shining moment

A student pasted a small snippet of code they wanted to ask a question about and the TAs immediately jumped on the opportunity to make fun of the code and how dumb what it was doing with pointers (or something) was. Then someone pointed out that the code had come from the project itself. It was theirs. They were in such a rush to be the first to win troll points that they ended up trolling themselves, and it was glorious.

Let's talk about the projects

They're only barely related to a tiny slice of the lecture material, and you end up spending most of your time fighting problems that have nothing to do with whatever it is you're supposed to learn. Start the moment they're released and cancel your other plans.

Also they'll repeatedly tell you that Gradescope is not your test harness, but it is, because it has to be, because watching Gradescope tests fail is how you learn about all the requirements and expected behaviors they forgot to tell you about up front.

Of course you should test locally as thoroughly as you can, but in the end Gradescope ends up being a test harness. They’ll insist otherwise, but that’s just denial.

The lectures

They're good. But man is there a ton of information to try to absorb. There are just sooooo many of them and they cover so much stuff.

That brings us to the exams

The only way to assure success is to memorize all that stuff in the lectures. Like, all of it. Oh, and in the papers, too (there are a lot of those as well). Good luck. Thankfully the exams are generously graded.

There's a reason this class is famous for its generous curve: It needs it. There is almost no way you're going to absorb all that material in order to do very well on the heavily-weighted exams that make up 55% of your grade (even though the projects take up a good 80% or more of the total effort in the class).

Summary

Maybe an overrated course. Not terrible. Not as great as you’ve heard. Probably could be better if some of the TAs didn’t actively work to ruin it. As others have noted, the near-complete disconnect between the projects and the lecture material that you need to pass the exams makes it seem a lot like two different classes.

I took two operating systems courses during my bachelor in CS and still this course felt relevant and taught me new things, so it was not only an excellent refresher but an expansion. Also, the fact of revisiting OS concepts after having real work experience has been very interesting.

Pros:

• Lectures are informative and well done, one of the best I had in OMSCS.
• The projects are challenging and required to code a lot, it is probably one of the courses where I coded the most.
• Almost everything is done in pure C using system calls. Parse strings, allocate/deallocate memory dynamically, create threads, sync them, create message queues and other IPCs, sync. shared memory segments through them, define a comm. protocol…
• Responsive and involved TAs. Even though with vague bug descriptions they tried to provide solutions and guidance. Unlike other crowded/popular courses, I didn’t feel they tried to shirk or be passive/aggressive with the students.
• A professor who cares. Dr. Ada held regular office hours and was truly involved in the course.

Cons?

• The class is quite crowded, so it was very difficult to follow Piazza unless staying on the top of it, especially when it came to projects.
• Project 4 (GRPC/Protobuf with C++) was the least interesting of all of them, since it was more constrained and more “fill in the gaps” style.
• I found the last lectures about distributed file systems and distributed memory quite boring and focused on too particular details and policies that personally forgot two days after the exam (although maybe this is because I’m not really interested in the topic).

In summary, great course, even with an OS course in your bachelor you should consider taking it, and for the ones without, this is a must!

I have background in maths and CS but never took any OS course. I know a little about C but not deep, never used pointer to pointers. This is the most challenging and rewarding course that I have taken so far. If you want to be a good software engineer and interested in distributed systems, it is a must-take. However, you can probably skip it and take AOS instead if you have taken an undergraduate OS course.

• Project 1 took me 55 hours. Low level socket programming. Very challenging to get it right.
• Project 3 took me 45 hours. Mostly about synchronization. Very useful.
• Project 4 took me 25 hours. It's about building a simple distributed file system with gRPC.
• Midterm was intersting and tested your problem solving skills. A little bit of memorization of concepts.
• Final was not so interesting. It focused more on memorizing concepts than midterm.

I was able to get close to full marks for all parts without any OS background and little knowledge in C. But I would still say the course is challenging. I spent on average 16-17 hours per week, but I felt exhausted while doing the projects. The effort was very "dense", it felt like spending 40 hours a week.

This was my 8th class in the program. I had experience with C but not C++ which was used in the 4th project. First of all don't be fooled by the "Introduction" word. This is by no mean an introduction. This course goes into some complex concepts like socket programming, Multi threading, message queues, shared memory, RPC to name a few. You cannot learn C and expect to complete the projects. If you have no prior experience in C, do not take this class. Tons of people dropped because of this reason. We were 430 students at the start and the number was 249 at the end of the Summer class. Also there is no middle ground here. Either you can do the project or you cannot do it. Again that boils down to how well you know C.

PR1: First project was tough. There are 3 parts to it each having the server and the client component. The first 2 was fairly easy but the last one involving the multi-threading is tough. The most difficult part is debugging the multi-threading portion. Bugs and memory leaks would be rampant and fixing them will require a working knowledge of C. Many were not able to finish PR1.

PR2: Skipped for Summer but it was only a case study.

PR3: PR3 was a monster. There are several moving pieces here and unless you design the flow of information between the components, you cannot start this project. At the very least, you need to have a big picture of the message flow between 3 components viz. The client, proxy server and cache server. I had serious doubts on finishing this one but eventually managed to do it within the stipulated timeline.

PR4: PR4 was simpler but tough. Ironic as it may sound but the move to C++ was very rough. Lots of boiler plate code was already provided but to understand the code flow was very difficult. One can still manage to go ahead and code without getting the flow but that is not how I code. Also the gRPC spits out lots of garbage code. Thankfully you don't need to know much about that to design your implementation other than your definition on the protocol buffer.

Projects are worth only 40% which is sad given that you will spend 80% of your time on that. Mid term is worth 25% and final exam is worth 30% a whopping 55% total. The problem is, MT only has 10 questions and final has 15 questions. Its a hit or miss and you cannot afford to skip any lessons. The good thing was, there are plenty of notes written by former students which helped a lot for preparing for the exams. 2 most popular ones are teapowered and omscs notes. You can get their details on the slack.

I scored 100% on the projects. My participation on slack and piazza was also pretty good so bagged 5% there. I fared poorly on MT and final but was close enough to the mean. In the end, I just managed to sneak an A I think. This was the closest I have come to losing my 4.0 GPA so I consider this class to be tough. The good thing is, this class is perfectly manageable in the Summer.

Finally the TAs in the class are amazing. Tony the head TA does an amazing job running this class and the Prof. Ada is very lucky to have him on board. The best part about the TAs are, they want you to succeed in this class and will help you get over the hump. For E.G. few folks struggled massively in PR3 and the deadline was extended multiple times to help them. The bad news was, this bumped up the class mean. I feel there should be some bonus points awarded for completing the projects on time. Good Luck to future students taking this class.

TLDR: GIOS is a great course, but very difficult if you do not meet the prerequisites. Take them seriously.

GIOS is really two courses in one. The first is a theoretical course about how operating systems interact with hardware and how programs utilize the operating system to run quickly and efficiently - this course has two difficult exams, a midterm and a final. The second is an intermediate C (and C++) programming course - this course has three challenging coding projects.

The first course is taught extremely well - the lectures are world class and despite the sheer quantity of material, it is quite digestible and quite interesting. The second course is not taught (although you'll need to apply concepts from the first course) - this is where the prerequisites come in. You are on your own to complete three very challenging projects (with support via Piazza and Slack). Unlike many students, I actually enjoyed reading the research papers - it's really amazing that the systems and techniques we rely on for computing performance are based on decades-old research and experimentation.

I did not take the prerequisites seriously (my fault) and struggled immensely with the practical aspect of the course. I assume that I am not the only one as approximately 40% of the students dropped the course.

Here are my grades. Note, Project 2 was not offered as I took the course in the summer - my understanding is that it is an optional extra credit assignment of some sort.

Participation: 100%

Project 1: 32% (Class Average: 82%)

Project 3: 51% (Class Average: 91%)

Project 4: 46% (Class Average: 82%)

Midterm Exam: 72% (Class Average: 79%)

Final Exam: 68% (Class Average: 75%)

Due to the way the course was weighted (Exams: 55%, Projects: 40%, and Participation: 5%), my final score as a 60.6%. This is easily the worst I've done in any course in my entire life.

Each project is divided into three parts, a "warm-up", the main project, and the write up. I completed all of the warm ups, but aside from a few points here and there, did not complete any of the main projects. I received full credit (10% of the score) on all three project write ups. The first two projects were written in C, while the last project was written in C++.

On the plus side, due to the curve, I ended up with a B. The curve is your friend - embrace the curve.

There are tons of posts on Reddit (and here on OMSCentral) about how to prepare for the course - do a search and take them seriously. If you are only marginally ready, you might want to avoid taking this in Summer when the course timeline is compressed, but the workload does not change.

I hope this helps future students who want to take this course get an idea of how to approach it and what the course entails. It's really an interesting and important topic so I recommend it, but not until you are ready.

Of course, that's just my opinion. I could be wrong.

This class has so much potential. The projects are great and I learned a ton doing them (the mark of a good project, in my opinion). One is on network socket communication and dealing with multi-threading, one is on inter-process communication, and one is on RPC and server caching (using gRPC). The TA support was great (especially on slack). Unfortunately, despite being the primary learning mechanism for the class, the projects were only worth 40% of the grade (vs 55% for the midterm and final combined).

In my opinion, the lectures were nearly unwatchable. It's like being a read a textbook out loud. They are incredibly dense. It is impossible to memorize all the information and very hard to determine what the take away should be (main ideas). In addition, the tests are very confusing multiple choice questions on many small details on outdated technology. It would be much more fair if we could write a long answer explaining the concepts, rather than answer multiple choice questions. Really, I think the professor probably underestimates how much reading a just slightly wrong answer can get your thinking off track and play tricks with your thought process.

I didn't know C before taking this class. It was tough. I watched as many of these as I could before hand (thanks to another review for the link) and it really helped me out: https://www.youtube.com/playlist?list=PL9D558D49CA734A02

If only the lectures were as brilliant as these, it would have been a great class. Still learned a lot, but the lectures and tests left a bad taste.

Interesting course with challenging projects. A minor negative emphasis on high-schooling students and catching them on trivia is present, but tolerable. Not as challenging, as described: almost no C preps or system programming experience and still done well.

Pros: {1} Learn a lot. {2} Predictably medium workload overall. {3} Challenging, but manageable projects. {4} Fair midterm. {5} Auto-grader and clear expectations from the report.

Cons: {1} Hard to pair with another "challenging" course. {2} Huge workload spike on the midterm. {3} Some minor details are ambiguous from instructions. {4} Many auto-grader tests are trying to catch edge cases that were not clearly described anywhere. {5} Condescending attitude from head TA: complains all day about students without prerequisites instead of answering questions + sarcastic remarks. Slightly annoying. {6} Clarification posts discussing common pitfalls are trying to hide them at the same time. {7} Midterm marked wrong by a couple of points. No regrades. {8} Multiple ambiguous questions on the final. No regrades. {9} Hard to see any system in the material. Looks like a mishmash of topics. I've learned a lot of something, but hard to say what exactly. {10} Projects are challenging for a wrong reason, jump from one API to another, making you put all the effort in the wrong place. Sockets, libcurl, Protobuf trivia, sudden C->C++ transition, multi-threaded file I/O, time-stamping, tricky C ownership model, all have nothing to do with material taught.

Tips: {1} Implement and test a small part at a time with ample debug output. And just keep correcting till all the tests pass. {2} Write a linux C program on each API mentioned above, if you want to prep.

This was my third class in the program. I had experience with C-family languages, but no significant experience with C/C++ entering this class.

TL;DR

Great class! Well-worth the effort required. The class also covers many practical topics around computer networking. If you complete all projects, you will become competent in C/C++. Unfortunately, the exams were so exasperating due to poor questions & overvaluation that I cannot give this class a "Strongly Liked" recommendation.

Tips

• Start early. This means many things: go through K&R before the class starts; setup a dev environment before Project 1 opens, ideally with a proper IDE (e.g. VS Code); try to finish Part 1 of each project in the first weekend.
• Focus on the practice questions. The exams have many questions similar to the lecture quizzes & provided example problems, especially the quantitative problems. The exam questions tend to be a harder version of the practice problems, so make sure you have a thorough understanding of the solutions.
• Pay attention to Piazza. Many things can go wrong in these assignments, but usually someone else has hit the same issue if you can find & recognize it.
• Important C programming concepts:
  • Array-pointer relationship
  • File I/O
  • Function callbacks
  • Double-pointers
  • Flexible array members

Content

Grading

From the official stats, the Summer 2020 class had a withdraw rate of 38%. Out of students who didn't withdraw, 61% got As and 33% got Bs.

Note the weight of the exams (55%) relative to the projects (40%).

Participation factor is confusing. According to TAs, everyone gets a 0 for participation pre-curve. Of the students who end near a grade cutoff, "a handful" get bumped up to the next grade based on the quality of participation.

The class is typically curved with the A cutoff around 80% to 84%. I believe the B cutoff is typically around 60% to 65%. I'm guessing this is the average projects + exams (i.e. out of 95 points) with participation factored separately, so you probably shouldn't trust the Canvas calculation. We were not provided with the curve statistics for our semester. I believe the A is very achievable if you ace all the projects and get a decent (>75%) exam average.

Projects

The projects are the best part of the class. They're very tough, but also very relevant to modern software & networking.

The project grading is mostly "all-or-nothing": you will get >90% on the projects if you pass all autograder tests as long as you don't hardcode anything to bypass the core requirements (this is supported by the high median grades). The median grades for the projects were all ≥98%. The key is perseverance; I estimate 40+ hours per project.

The frustration comes from the lack of support & onboarding for the fundamental skills. It's "sink or swim" for learning C/C++, the C standard library, & Linux system calls. Piazza can be helpful if you have specific questions. Make no mistake: the C programming prerequisites are demanding for this "Intro" course.

There was minor opportunity to earn 5% extra credit on each project for improvement suggestions, but when the projects are only worth 13.3% each towards the final grade, it's pretty inconsequential. For the summer semester, we did not have the optional, extra-credit Project 2.

Environment Setup

The class provides an Ubuntu VM & instructions for hosting the VM with Vagrant. In addition, I used VS Code's Remote Development extension to SSH into the VM for coding & debugging. This worked extremely well for me.

The autograder, Gradescope, seemed fine. We were allowed up to 50 submissions for each part of each assignment with no penalty, which was very generous (my max was ~12). There's no "submissions per day" limit, which benefits procrastinators. You get moderately useful error messages back from the test scripts. The TA staff will actively discourage using the autograder as your tests, but I found the name of the failing test was usually enough to identify the issue.

Project 1: Multithreading (PThreads), POSIX sockets in C

For those of us without C experience, the first project can be very discouraging. The learning curve starts steep, although it levels off quickly for the rest of the class after you get past Part 1. I gained a lot of momentum: I finished the major part of the multithreading assignment in 2 evenings using concepts covered in the lectures. I finished this part faster than the warmup.

Project 3: Inter-process Communication (IPC) in C

This was the toughest project. The assignment builds two multithreaded processes transferring arbitrary files with shared memory IPC. The project requires several thread & process synchronization decisions, so a decent amount of design & preparation was required for success.

Project 4: Remote Procedure Calls (gRPC + Protobuf) in C++14

This project was a 2-week sprint for the summer semester. This was almost as tough as Project 3 due to learning C++, Protobuf, & gRPC to build a basic distributed file system (DFS), all in 2 weeks. The TAs provide a lot of helpful framework/boilerplate code, but it also introduces lots of frustrating red herrings while attempting to debug multithreading issues across multiple clients. They reduced the test suite to compensate for the short summer timeline.

Resources

The TAs & students tend to share an overwhelming variety of resources, so this is my curated list beyond official documentation & man pages.

• The C Programming Language (i.e. K&R): The C language is relatively simple, but it still takes time to learn enough to become productive. This book should be accessible to GT students through O'Reilly's website. If you can go through this book before the start of class, even better. I spent ~20 hours reading all chapters & completing the simple problems.
• Beej's Guide to Network Programming: This is a fantastic resource for socket programming, although IMO the first few sections are painfully verbose. If you know network basics, start at the system calls section.
• The Linux Programming Interface: Also available through O'Reilly, this book has some extremely relevant chapters on Semaphores & shared memory wink.
• GitHub gRPC examples: These examples provide a great starting point, especially for async gRPC.

Exams

Question types included calculations, multi-choice-multi-answer, and True/False.

This was my least favorite part of the class for several reasons:

• Too short. At only 10 & 15 questions respectively, they're high-risk given the huge amount of content they cover. The final covered 10 lectures + 7 papers.
• Lack of feedback. The midterm grading key was posted almost a full month after the midterm. We were not provided with a grading key for the final. The midterm grading key didn't provide 1:1 solutions. Appeals for ambiguous questions were, in my experience, not considered or acknowledged.
• Ambiguous wording. The questions are brief & leave too much for interpretation. I lost points on both the midterm & final due to questions that weren't explicit enough.
• Overvalued. Here's the TA-provided justification:

The exams are worth more because it covers a wide range of the subject taught in this class. Each project focuses on a more specific topic and so have a lower weight when compared to the midterm or final. A student's time investment is variable and not a metric that can be measured or considered to determine weights of each assignment.

In my opinion, the exams aren't long enough to be comprehensive & justify the weighting. Also, there are many OMSCS classes that contradict this mindset.

Lectures

This course has a lot of content: 16 lectures with 20-30 videos each. A few of the specific topics (e.g. SunRPC & XDR) are outdated, but otherwise the class concepts remain very relevant. Notably, some lectures did cover the fundamental ideas of cloud computing.

Papers

Overall, these were pretty dry & long. Most were written in the context of programming languages that are effectively extinct. The important papers were discussed in the lecture videos.

Understanding Operating Systems is a bit like understanding Quantum Mechanics. You don't need to know how it works, but unless you do, you can't really say that you understand Computer Science. And once you take the "red pill" and start down this rabbit hole, your world will start looking completely different and your code will start exhibiting "spooky" behavior that you never thought possible.

This is a project-based course that is graded like it is an exam-based course.

You will be spending a lot of time doing projects. There are six parts to project 1, and two parts to project 3 and project 4 plus write-ups for each (project 2 is a not-so-easy written assignment). While everything is C/C++, a deep understanding of these languages is not required. The projects cover so many topics (sockets, protocols, threads, synchronization, memory, file systems, caching, REST, IPC, RPC, etc) that you would need to be an expert in all of them to find the projects easy. And if that were the case, you shouldn't need to take GIOS in the first place.

The decision of whether to take this course should not depend upon an understanding of C/C++ and these topics. You will learn all of this. Instead, you should be asking yourself: (a) do I really have the time to devote to this subject, and (b) do I have the kind of hard-headed tenacity to keep trying until I get my projects working? For me, I needed to take 2 weeks off work to complete project 1, and a week off for each of project 3 and project 4.

Your development environment is critical and you should start working on day #1 to set this up. I knew I'd need a full IDE that would help me understand the code, catch errors early, and provide visual debugging. You will also need a relatively powerful Linux machine (or VM). I opted for a local CLION development environment doing remote debugging on a cloud machine. That worked great for project 1, but remote visual debugging soon became so difficult that I became a slave to printf() statements. 100% local development might have been a better option for me. These are not trivial decisions and you will need to think through how you want to work.

Our GIOS class was larger than usual, but the Piazza conversation was not the noisy chaos I expected. The questions were well constructed, the TAs were very respectful, and the average response time was about 25 minutes. But nobody is going to do the work for you, and I still found the majority of my issues were things I needed to figure out myself.

The required reading is old and academic, but also eye-opening and humbling. For instance, did you know that virtualization was fully productized in the 1960s? If an academic paper is discussed in the lectures then you can be certain it will be the most difficult question in the exam.

The exams account for 55% of the final grade. To me, this seems highly imbalanced. After all the work that goes into the projects, I found it painful to reflect I wasn't even halfway to the finish line. The final exam is a 15-question, 2-hour multiple choice. The mid-term was shorter, but neither had time pressure. The questions are re-twisted each semester so that old concepts can be tested with new language. But as a student, this twisted language opened up ambiguity. Perfectionists will not be happy.

In taking this course, I can confidently say that I have never learned so much in such a short amount of time.

This is my second course after AI4R and it is definitely much more challenging than I anticipated. Probably it is partly because I am doing it in summer. I am preparing for the final now.

Projects There are only 3 projects in summer: Project 1, Project 3, and Project 4. Every time I am working on a project, I cannot catch up with the lectures and readings.

I feel that they could've made a lot more test cases, but chose to be lenient to the students, so that is good. I was already struggling with the projects, not because of the language, but because I was expected to learn a lot more than the lectures to do them well. That's good, though!

Exams The mid-term was fair. It was not easy, but not ridiculously hard either. I really wish they had more explanation or conceptual style questions, but the real problem is that they cannot be autograded. Therefore, they stick to multiple-choice and short answer questions.

Wow, what an amazing class. This was my first OMSCS class and boy did it whip me into shape. The projects are brutal and require a lot of outside work. But you learn so much by completing them and the moment when you pass all the Bonnie tests is a religious experience.

The lectures were concise and the papers were a good application of the concepts. I enjoyed learning and found this class to be a very rewarding experience.

However, it was an absurd time commitment. I spent 2-3 hours each week night working on this class, snagged 1-2 hours during the work day, and put in 12-14 hours each weekend. Start early and front load your work. Office hours are especially helpful for learning tips and tricks and places to watch out for. Definitely don't double up with this class.

The curve is especially generous so don't freak out too much.

This class kicked my butt but I loved every moment.

Content

A broad base of OS-related content is covered. Included is networking, process/thread scheduling, inter-process communication, multithreading, file systems, memory paging, virtual addressing, virtual machines, and RPC. Seminal work in this field was done in the 80s/90s so many of the papers are from that time period.

Projects

The real standout of the course. One medium-sized project and two large ones covered networking, RPC, and IPC. All of the projects were challenging but had mostly straightforward requirements. You get a couple submissions per day to the automated grading system. The score on the grading system is your real grade for the project, so you can know for sure that your code is done if you pass all the tests.

The projects are in C with one in C++. They would have been much more challenging had I not already been familiar with C concepts like pointers, function pointers, dynamic memory allocation, etc.

The lectures cover mostly conceptual material; there is little coverage of how to actually program the projects. It seemed like some of the class had difficulty pulling together a program based only on online documentation and StackOverflow... welcome to being a software developer.

Relevance

It's less common than it once was to write low-level networking code yourself, but still useful. If you ever want to poke around the internals of a web server, you'll know what's going on. Not much has changed since the 90s as far as threading and mutexes, so that part is very much relevant. I appreciated that the last lab switched out an old RPC system for the modern GRPC framework.

TLDR:

• review by someone with no C/C++ experience
• very tough course but doable only if you put in a serious amount of time and effort
• very rewarding course

As someone who had never coded in C or C++, this was a big challenge coming in. I took an intro to C on coursera which helped a bit, but I was unable to complete the first project and felt a bit defeated. After receiving encouragement from the TAs, I doubled down and invested more time in the class, was able to fully pass the remaining projects and finished with an A (after curve). My biggest tip would be to start on the projects as early as you possibly can, and invest upfront in learning debugging tools for C if you are not familiar.

The class community and the TAs and teacher were all very helpful. The original course creator is still the teacher for the course, and I think it is part of what makes this such a quality course.

I was extremely impressed with the depth, span, and delivery of information in this class. Not having taken an operating systems course in undergrad, I felt that the material solidified a number of fundamentals that I did not previously grasp. The other reviews about the projects are spot on: each are very difficult (especially without a good understanding of C and its nuances) and will force you to really understand the systems you are tasked to implement. Even with prior background in developing embedded system firmware I still struggled.

The teaching staff was highly professional and responsive, which proved invaluable throughout the course duration. My one and only major critique are the exams. They were cut and dry and focused more on academic paper trivia than solving problems.

Aside the exams, this class is a MUST if you have not taken any shape or form of operating systems in the past. It will make you a better software engineer and it will prepare you for other interesting courses within the program.

Overall

This is a great class. It was my first in the OMSCS program and I learned a lot.

I ended up with an A by doing the following before enrolling:

• having done data structures and algorithms in C++ at a community college
• having done the Stanford online course in networking
• having read through an book on computer architecture
• starting every project as early as possible

Projects

All the projects were hard for me. It took a lot of time to even figure out what the questions were trying to ask, as there's often a lot of C programming patterns that are really hard to figure out.

I'm not sure how anyone who doesn't go into the course already being familiar - if not comfortable - with pointers in C would have a chance.

It is crucial to start the projects early. Especially since we're limited to 10 submissions a day, and it can take that many to figure out what the project is even trying to accomplish.

At the same time, the projects were very useful.

On one project the grader looked at the wrong Readme, but the TAs corrected that very quickly and without making me jump through a bunch of administrative hoops. I appreciated that a lot.

Tests

The tests in this course are hard but fair. There were no surprises on the tests since I paid attention to the lectures and what the professor said was important.

The final is a beast. There's an insane amount of material to get through. Since it is worth 30% of our grade I skipped a bunch of project 4 to devote more time to studying.

From a learning perspecitve, I may have been better of struggling with the project. However, with all the distruption of covid-19 it took a while to get grades back for projects 2 and 3 so I didn't really know where I stood in the course.

Piazza/Slack

I never actually got into the slack channel, I think because I registered off of the wait list.

Piazza was extremely helpful. Searching for the error messages or failing tests in other students posts often got me the answers I needed.

GIOS was my first course in the program, and I'm very glad to have started with it. My background is an undergraduate degree in applied math and four years of experience as a full-time software engineer. I took the class to help round out gaps in my formal knowledge since operating systems is important subject for many areas of software development.

The class was well-taught; I enjoyed the material. The projects were my favorite part of the course. They were challenging, but practical and rewarding. I spent an estimated average of 40 hours on the technical part of each project and five on the report.

The lectures were engaging -- at least from my perspective -- albeit not always related to the projects. I actually enjoyed having separate theoretical and practical parts of the course. Make sure to prioritize the exams because they make up a significant portion of your grade. I personally did not use a textbook, but having one may have been helpful. I felt the exams were tough but fair.

I would recommend this class to anyone looking for a deeper understanding of systems. I think the class will make you a better engineer even if your field is not as low-level as the subjects in this course.

This class has three projects, the first two use C and the last uses C++. I have a background in C++, so I avoided having to learn C on the fly. C is very difficult to pick up while trying to understand the topics for each assignment. I believe that is why this class has a high drop rate. This course not only uses C, but uses more advanced features like callbacks. The same goes for C++.

The professor holds office hours, and the TAs were great. The tests can be very difficult, so time must be spent listening to all the lectures and doing most of the reading for papers. I do not have a CS undergrad, so this may have contributed to the difficulty I faced on the tests.

The course does have a generous curve at the end, so as long as you do well on the projects or the tests you should be fine in the end. I recommend taking this course as a refresher on OS concepts, or a chance to learn about the OS.

This was my first course in OMSCS and I enjoyed it quite a lot. There are 3 main projects and each of them should be started as soon as possible. I would advise going through entire skeleton code of the project before writing the code. Slack, Piazza and TA's are helpful if you get stuck on anything in project. Many OS topics are covered in lectures starting from Process, Threads, Synchronization, Scheduling, Memory Management, I/O, Virtualization, Shared Memory, Remote Procedure calls and Distributed shared memory and distributed file system. The lectures do a very good job of introducing each of these topics. Try finding time to watch lectures while doing projects as exams mainly cover topics from lectures. I thought exams could be improved as most of the questions are just variation of sample questions. Some of the questions were made tricky just for the sake of exam. Overall, I felt the course did a really good job of introducing concepts of operating systems.

Start as soon as possible on the projects. Project 1 (file transfer protocol) and Project 4 (RPC) are time consuming and test your patience and resolve. The TAs are super helpful and the quality of the video lectures is really good. The best part is, the instructional staff really want you to succeed and understand the material. Grading was slow and I mean super slow. This is probably because we started out with 700 students in the class. However, they did manage to grade our finals and the last project in less than a week. If your undergraduate degree was not in Computer Science, this is a must take course in my opinion.

I took this course since a lot of people here and at Reddit has been recommending it as a good first course.

God I hated it so much lol. The materials weren't too difficult, but the projects were absolutely absurd. I think the meme "How to draw an owl" is pretty apt here. Compared to the other OMSCS course I've taken this semester, the instructions were vague or nonexistent and I was struggling just to complete the basics.

I did learn a lot. But compared to the hours that I spent on the projects, it wasn't a very cost effective way of learning IMHO.

I ended up with an A in this class, but I can't say I enjoyed the journey. I felt a bit like I was being thrown to the wolves and left to fight to survive. I spent more time figuring out what the projects were asking me to do than actually implementing my solutions. Getting clarification from TAs was hit or miss. Some TAs were helpful, others were condescending. But you're probably better off lurking Slack and looking at the Slack history than actually asking questions, because even if you're right about some inaccurate or incomplete description, odds are you'll still be treated like you're a high school student.

That said, after surviving the projects and finally coming up with a good solution (after about 50 hours for Project 1), I did feel like I had achieved something, and I had a better understanding of C paradigms and system calls. It's just, I still feel like I could have done that on my own. The class didn't really help me learn, it just gave me a reason to do it. I felt like there was an "us vs them" divide in the class between the cool kids who live and breathe system calls and who banged out the projects in a couple of hours, vs the plebs still asking what a pointer is, who will get pointed to a guide online, but not without a dose of condescension.

The grading in the class was absurd. The final exam alone was worth 30% of your final grade but was only 14 questions long, and the questions felt like arbitrary facts pulled from the Udacity lessons and referenced papers. The curve was insane, to me it shows that the material isn't where it needs to be if they're curving 10+ points per letter grade. I found the lessons a bit hard to follow because they covered so much material. We were also told that documenting our solution, even if it ended up not working, would be awarded partial credit. This ended up not being the case once the median grade in the class was seen to be higher than expected. If only I'd known that the hours I spent writing detailed descriptions and drawing up program flow diagrams would not award me a single point, I could have spent my time in a more useful way.

This is my first class in this program. I am not very experienced in programming and even worse at basic theory of how program works so this class is really touching the blank section of my knowledge. With that being said it does cost quite some time but also ends up being very educational. If you are interested in learning about this topic I highly recommend to take this class.

The lectures and projects are good (compared to other class I took). It has obviously been adapted to online study so that's a plus.

There are 3 required assignments with mid term and final exams. Exams take 55% credit in total so you do have to read all the papers and watch the lectures to prepare. In my opinion the "hard" rating has quite something to do with how this class is graded. The last project due date is also very close to the final exam. So if you are pairing it with other classes, you might want consider the work load at the end of the semester. Two final projects plus two final exams could be tiring.

Language wise, it started with C and last project was done in C++. Zero experience in this language could be annoying, depends on how fast you can learn and how much time you are willing to spend on fixing all the little bug.

On average I spent about 20 hours per week which is very unevenly distributed. In easy weeks I might just spend a couple hours while before exams I am spending 6-8 hours every day preparing. I earned an A marginally at the end without feeling very confident through the semester. There are a couple extra credit item so it's not too hard to get an A if you are serious enough with it.

This class was a beast! Start the first project early. Once you get in the groove of the projects, they become easier since they build on each other. However, do not underestimate them unless you have a strong background in C programming. Creating Linux sub-systems from scratch was fun and I definitely came out of this class with a better understanding of programming in C and concepts like memory, caching, and multithreading.

This is my first subject and i took only one subject on this semester and i was able to build momentum eventually. I liked it very much as i also a system programmer and aware of C, C++ and late start still able to handle the home works on time.

It would almost be more correct to call this "Intro to Concurrent Programming in Linux" or "Programming at the User/Kernel Interface" since the main focus of the course is on concurrency primitives (threads, mutexes, semaphores, condition variables, etc. ) and coding against Linux syscalls. You won't come out of this class writing a basic OS kernel or anything like that.

What you will gain from this course is an appreciation for how userspace and the OS kernel interact, and a new appreciation for how much complexity is abstracted out by modern APIs that you don't have to deal with.

If you're already comfortable programming in C, you shouldn't have too much trouble with this class. If you're not, you probably will. The exams (midterm and final) are straightforward but can be a bit picky (i.e. a complicated multi-step calculation that Ada works through in the lecture videos in its entirety, but that you must reproduce on the exam without references), but the course is generous about grade cutoffs (>= 80 == A seems to be the standard) so even mediocre performance on them is not a blocker for earning a good grade in the course.

This was my first class along with Computer Networks. I earned a B as a grade on the class because i didn't listen to the previous reviews to start the projects early. I am an application developer with approximately no knowledge in C and multithreading. I thought that I can handle programming projects easily. But that was not the truth. In the first 2 projects, i started the projects during the last weekend before the deadline, and I really suffered and i got really bad grades. I did very well on the midterm and the final because i understood the lectures. And i got a high grade on the last project because i started it early. So as an advice:

1. Start the projects as early as possible: If you want to get an A, this is the only way. Piazza is super helpful if you are encountring issues on the project and bonnie errors can help you to identify what you have done wrong
2. Lectures: If you understand the lectures, you can get very high grades on the midterm and final, the exams are closed notes but if you understood the lectures, I am really sure that you will be able to get high grades on the exams. The lectures are not boring and you will feel that you are learning something you need in your life as a software engineer.

So as a final advice, take the course and start the projects as early as possible

It was a great first course for me, especially as someone who did not come from a CS background

GIOS

Course

• This was my 4th class in the program. I do not have a Computer Science background but have been working as a Software Engineer for the last 2 years.

Summary of Assignments

• There are 3 coding projects in the class (and 1 EC project which can be finished in <5 hours). You get 4 weeks for each project and each project can be finished in 1-2 weeks (~30-50 hours?). So, you can have two free weeks for each project.
• Projects 1, 3, and 4 all have 2 parts. The first part is a single threaded implementation and the second part is multithreaded. The projects all involve byte transfer (send and receive) and writing client and server code.
• Use print statements and gdb for debugging. I did not set up remote debugging through CLion (like other students) as I found the print statements were enough to fix all issues.
• Go with the default VM provided (Vagrant). You can also use docker.
• This class uses Bonnie for automated testing (limited to 10 submissions per day).
• Project 1: Get File Transfer - Use this link (https://beej.us/guide/bgnet/html/) to get started. This explains how to set up sockets and will be very helpful for project 1. This project will probably take the longest since you will have to get familiar with VM, C, and Bonnie (automated testing suite).
• Project 2: Metrics Writeup (answer some questions based on some experimental results). This will only take a few hours.
• Project 3: Proxy Cache - This project involves some design work - determining how to share information between the proxy and cache. Watch the lectures to understand how shared memory segments, message queues, etc work before starting the project. Once you have a design, the implementation will not take much time.
• Project 4: gRPC File Transfer (C++) - Use this link (https://grpc.io/docs/tutorials/basic/cpp/) to get started. Spend some time understanding what RPC/gRPC is before getting started on the project. A lot of the code can be reused between the client and server. Understanding the multithreading part was a bit confusing (instructions/code comments were not very clear) but other than that, this project is easier than the other two.
• If you can get your code to pass Bonnie, you will likely get close to (if not full) full credit.

Summary of Exams

• There are 2 exams (non cumulative) - a midterm and a final. I spent the week before each exam studying for the exam. You can get by without reading the papers (they are too dry!).
• The exams contain some calculation based questions and multiple choice/multiselect multiple choice. The questions are a bit tricky so make sure to understand the concepts presented in the lectures in depth. Go over the final review questions.
• The midterm covers the first ~6 lectures and the final covers ~10 lectures.
• The final is non cumulative.

General

• Grade distribution: 3 projects - 40%, Midterm - 25%, Final - 30%, Participation - 5%, Up to 4% extra credit (for project 2 - no coding).
• There is a very generous curve in the class. (A: 80-85+, B: 60-65+). If you get 100% on all the projects, you can get an A with ~70% on the exams.
• If you know any coding language, I would not spend much time before the class trying to learn C. You can learn as you go. If you need a reference though, refer to these lectures - https://web.stanford.edu/class/archive/cs/cs107/cs107.1202/schedule.html.

Great class, if you know C/C++ well you can easily take this with another. If you don't know C/C++, you should learn it well before taking this class or you are going to spend a lot of time on the projects. The material is interesting and useful to nearly any developer. The TAs are very helpful, but they aren't writing the code for you. They provide more than enough assistance, but especially earlier on they are reluctant to give too much away. Some people don't appreciate the socractic approach that some of the TA's take, but I found it useful and often times hilarious.

The worst part about the class are some of the other students constantly complaining (e.g. Can a TA read my project code and give me some partial credit even though it doesn't pass any of the automated tests?). I participated in Slack and Piazza and I got frustrated a few times with other students wanting way too much in the way of assistance.

I have little CS background. This is absolutely a difficult one with a steep learning curve. I'd say if you distribute the workload among the weeks evenly. 20hrs/week is enough to reach a high 90s%(which I did), starting with little background. Let's put it this way. If you never take any OS class, this is a good one. Given that this is CS 101, without which, you shouldn't be considered as a CS student.

This was my first course in the program and I recommend it for anyone that is unsure of where to start. I had never taken an Operating Systems course and was able to be successful in the course. The meat of the course is broken down into projects and exams.

Projects: The projects were easily my favorite part of the course. However, don't write off the requirement for C. Two projects are in C and one is in C++. The jump to C++ is pretty easy and nothing prevents you from using the C APIs that you are used to using from the first two projects. I had some prior experience in C++, at least enough to know about pointers and c-strings and have about four years experience as a professional developer. In my opinion, the first project was probably the most difficult due to the fact that this is where I had to learn some lessons working with C. My advice is to start as soon as they are released. These are not projects that can be done in a night of frantic coding. The TAs are helpful, but they aren't going to hold your hand, so expect to do some due diligence when working through issues.

Although some students disliked Bonnie (the auto grader), I found it to be pretty helpful. Based on the test results, you will know how you are going to do when it gets graded by a TA. Complaints were typically about Bonnie not explicitly telling you why the test failed, which is kind of ridiculous. This is a graduate program at a top ten CS school. When programs fail in production, you have to dig and find out why, so learning how to debug and troubleshoot are great skills to learn in an academic environment.

Exams: Midterm and final are fair. Study the video lectures and the papers and you should be ok. The final is not cumulative, but covers a broad range of topics as well as many papers that you will need to be familiar with. The midterm really only covers two main topics in the first part of the course.

This was my first class in the OMSCS program and I felt this class was pretty fair when it came to the material. What led me to my rating was all the extra stuff. Piazza is helpful and the lectures provide a lot of information. It seemed useless to have office hours once a week at 1pm EST as there would be little attendance since it was in the middle of the day. The slack is probably the worse part of the class. Specifically, there is a TA, Tho, that mostly treats slack as a place to dump on students for asking questions. You are belittled and given condescending answers whenever you ask something. He honestly couldn't be bothered with wasting his time helping students. There are some TAs out there that feel they are better than everyone else and this is one of them. This is not the standard I thought an institution like Georgia Tech would have. When the semester first started his troll responses to questions was discouraging to want to ask further questions. This might be his intension. There is the response of "oh if you are butt hurt from the answers that are given then maybe you are not good enough to be in this program" when in reality this program should be an opportunity of learning and as a student you shouldn't have to worried about asking questions. He should not be a TA if all he wants to do is belittle students. If you plan on taking this course, refreshing yourself in C will help and when you get stuck on something first search the slack to see if anyone has asked something similar and then if not ask your question. If you get an arrogant response from a TA just ignore it and wait a little bit before asking it again.

As context, I have a somewhat unorthodox background: CS-lite BS years ago, but have worked (for many years) since then in a non-technical field.

I loved GIOS. It has a lot to offer, is very interesting and engaging and fun, with great Projects, and has a lively and (for the most part) supportive community of students, current & former, and TA’s behind it. And Professor Gavrilovska is a really solid, accessible resource, who clearly takes her responsibilities to us seriously, in addition to being a very good lecturer.

I basically put my life on hold for 5 weeks in order to get over 100% on Project 1 and hit the mean on the midterm, and by the time Project 3 started up I didn’t have much left in the tank. (The fact that a number of the TA’s and former students on Slack (who can often be quite helpful!) are also kind of troll-ish definitely dampened my enthusiasm for engaging (to a level sufficient for getting A’s on these challenging Projects, anyway.))

Nonetheless, the majority of my problem lied within myself. I simply didn’t care enough to put the work in, and basically gave up after the midterm. I only really completed half of P3 and barely turned in a Readme for P4, yet am (apparently? the grade isn't quite final yet) heading for a B. (I also got just below the mean on the final, so at least I test well.)

Anyway, my sum up is: this class is even more of a firehose of info and deadlines than your typical OMSCS class, but the insanely generous grading policy (it’s not so much a curve as it is levels of standard deviations within the normalish curve of one’s individual cohort dictating where A, B, C are) helps make the landing exceedingly soft. Be brave, and have fun! : )

This was my first class that I've taken for OMSCS at the recommendations of many students. Three are four projects in total: 1,3 an 4 are all required and the 2nd one was optional for potential extra credit. The projects are all in C and the final project was in C++. I thought this class was an amazing class with a very active piazza and slack to help students with questions.

The class heavily emphasizes C concepts such as pointers, string manipulation and synchronization concepts (multi-threading). I came into this class with almost 0 C/C++ experience. I have mostly utilized Python, JavaScript and some Java before hand. I read a book on C to get familiar with concepts but a lot of the class was learning different components of the standard library as well as how to utilize different C concepts.

I think that if you really want to get a good in depth experience with C/C++ and multi-threading then this class will be a great choice for you. The final project is C++ and about GRPC which I found to be an awesome tool-set to learn and can be use-able at a lot of companies.

If you are going to take this class then try and start on the projects ASAP as you only get 10 tests a day. I would submit a test on the first day of the project to get a good understanding of what the project will look for.

I wish I took this course earlier in the program, because it covers so much material that is very central to computing. I loved that the assignments use C and need to be done on Linux. The automated test environment actually worked well and gave useful feedback on our programs. The TAs were very involved on Piazza and even Slack. The professor and TAs all came across as highly knowledgeable. Great set of papers to really teach us a lot of CS history.

I thought some of the material could have been modernized. For example, we have a Sun RPC assignment, but newer technologies like thrift or proto aren't really mentioned. Compare that to AOS, which uses gRPC for some assignments. One of the assignments felt like a race condition tester. But overall this course was exceptional and I think every OMSCS student should take it (followed by AOS, which is equally excellent)

This was my first class in OMSCS, and I would strongly recommend it as a first class.

The projects for this class were great. In addition to learning operating systems concepts, you will get a good introduction to multithreaded programming. One caveat, though: come prepared with a decent understanding of C/C++, especially pointers and memory management, or else be prepared to spend quite a bit more time on the projects.

The lectures do a great job of explaining the topics covered.

The problem with this course is that the listed prerequisites are woefully insufficient. As a result, for many the vast majority of the time spent on the projects has nothing to do with the course material. As an example, c++ isn't even listed as a prerequisite, yet it is required for one of the projects. Sure, once you know c it's easier to learn c++, but having to learn that along with completing the project along with many other gaps the prereqs didn't list make it a daunting task. Essentially, I spent far more time on the projects wondering, "So wtf is this project even asking me to do?" rather than understanding the goal and being able to analyze, think, and research about how to reach that goal. Instead most time was spent deciphering assignment instructions and learning background material. The course subject matter is enjoyable, but the fact you have to work around all these obstacles just to apply a very limited amount of the subject matter makes the course not enjoyable. Furthermore, I consistently found TA response, particularly on slack, to be passive-aggressive and condescending to the point where I stopped bothering to even use slack.

This was my fourth class in the program, and the hardest one I've taken so far. I wanted to learn about more low-level concepts like multi-threading to make me a better software engineer, and the material did not disappoint. However be aware that it is a LOT of material. Like, a lot. And some of the lectures are very long and full of details (some were close to 2 hours!), which meant it took me twice as long to get through since I hand-write all my notes.

The projects were good, definitely my favorite part of the class. The first two are in C and the third was C++. I did not have a C background, so found it very challenging, but I managed to learn as I went, and I ended up with an A in the class. It's definitely doable.

Slack was invaluable for helping me get through the projects, however the help mostly came from other students. I did not find most of the TAs that helpful, except for the head TA (Tony). One in particular was quite rude and would make you feel bad for asking questions. Completely not necessary. However overall I enjoyed interacting in Slack. Piazza was also pretty helpful, as long as you could get through the basic and repeated questions.

The tests were not great, I felt. They were multiple choice or free form short answer, where most questions had multiple correct selections. I didn't love the format, and the average grades reflect this (66 for the final, I believe).

There's a generous curve at the end of the semester - I got an A with a final grade of 83. Overall I recommend the course, but I highly recommend the following in order to succeed:

• Get a base understanding of C before you start. You can learn as you go, but it'll be better if you brush up ahead of time.
• Get Three Easy Pieces for an undergrad references for OS
• Get The Linux Programming Interface for a good programming reference. I used this book multiple times for the first two projects.
• Be active in the Slack channels.
• DO NOT FALL BEHIND. Do a little bit every day. If you fall behind, going through that many lectures at the end will be a huge slog. Make sure you watch the lecture for that week and read the paper. Take notes to absorb it. It will make studying for the midterm and final much less painful.

Good score. Will be a bit challenge if you took this in summer.

Lectures are great and cover the material well. Papers (about 10) cover depth where lectures do not always present sufficient depth. Textbooks are good, and OSTEP can be found online.

Exams (two, midterm and final) were multiple choice, count for > 50% of grade, and surprise you by testing knowledge either not covered or highlighted as important in lectures, or not used during projects. Closed book, closed notes. Median/average scores for midterm (78) and final (68) were low.

Projects (three) used C (first two) and C++ (third). Each project has two sub-projects, and a report. Project documentation is sketchy/incomplete, so you need to discover requirements using an early submit to bonnie - number of submissions capped, so start early (before semester starts).

The first project uses (ipv6) sockets (see beej) to build a file server using callbacks.
The second project uses shared memory and IPC to build a file cache for a file server.
The third project (new for Summer) uses gRPC and ProtocolBuffers - good project, but only 2 weeks to learn tools, shift to C++, and build project.

As with any #GaTech #OMSCS course, the challenge is mainly the time and the quantity of work in the projects. Conceptually medium, but hard because the project workload leaves little time to study the actual OS material. Best plan is to cover the material (lectures) as much as possible before the semester starts.

This course is a great introduction into how operating systems work under the hood. The material was very interesting and well presented in the video lectures. The course is very broad in the topics it covers and doesn't go into too much detail an any topic except for threads and concurrency which was covered in much more detail compared to the rest. As the course pre-requisites state, it is useful to already have some vague idea of the basic architectural elements of a computer, but this shouldn't be much of a barrier.

The projects were interesting and since I took the course over the summer, the (extra credit) project 2 was skipped. The three projects we did were on

• multi-threading and sockets
• shared memory and other IPCs
• distributed file systems and RPCs

The projects were pretty straightforward, but very time consuming so make sure to plan ahead. It is impossible to do them in the one weekend before the deadline and leaving project work until the last minute was the main reason for people not doing well in the first project and dropping this course. If you know C and C++ it makes your life much easier, but the projects will still be time consuming. If you don't know C, make sure you set aside twice the amount of time for the projects. They are all non-trivial C/C++ programs. There were a lot of people struggling with memory leaks which they were unable to debug and this will consume huge amounts of time if you don't know what you're doing.

I found that doing the course over the Summer term can get pretty intense even though I already knew C. Knowing C meant I still managed to have some spare time for myself and a few other things. I would not recommend taking this course over the summer if you are not comfortable with C.

There is a small selection of papers to read in addition to the video lectures. You need to read them, because there will be exam questions that refer to the paper contents. However, I found the papers rather dull and most of the interesting stuff was already covered in the video lectures. If you don't have time just skim the papers, but read the results and conclusion sections in more detail.

Overall, I would recommend this course. I learned a lot and the material was interesting. However, be prepared to write low-level code - read the pre-requisites on the course website and make sure you feel comfortable with the material.

This was a great classical CS course, on operating systems and their generalities.

TL:DR

Taking it in the Summer was a challenge for me as my professional commitments escalated in the middle of the term. Please be advised, that there is a decent amount of material in this course and from the standpoint of the Summer schedule, the information will be condensed. The best part, in my view, were the projects. The first two projects were very mature and well structured projects in C. If you don't have C experience, be expected to spend a considerable amount of time covering the gaps in your knowledge. My C/C++ was over 25 years old, and I did fine - for the most part. The final project, was a new project for the class, written in C++ using gRPC and Protocol Buffers 3. The project, especially considering how fresh it was, was absolutely fantastic.

The exams, although I felt were fair on what they tested, had a horrible delivery format. Exams that test procedural coding knowledge should not be tested from the Canvas platform, period. In the final, due to scheduling circumstances that required me to cram four days straight resulted in one of my worst exam grades of my entire college career. As a warning, in these medium to high difficulty CS classes, it does not behoove you to get behind on the lectures and the papers. Regardless, the curve in the class for both an A and a B was generous, and my performance on the midterm and projects was enough for me to get a solid A in the class, to my surprise, actually. Considering how low of a grade percentage results in a B cutoff, is historically in the class, I don't fell bad on earning my curved A.

The instructor is very engaged, holds live office hours, and is responsive when necessary in the class. The TAs are awesome fiduciaries of class/project information, in the private Slack for the channel, TAs and students alike share hints and information that can be very helpful for the successful completion of the projects, I highly recommend the Slack channels for this course. I found them much more relevant and helpful than Piazza. And much better at fostering a more classroom feel than a forum. Forums are no substitute for live communications.

All and all, the class was great, and I would recommend it to all students planning to complete the Computing Systems specification or looking to take an elective to boost your overall knowledge of general operating systems. In my OS class in undergrad I didn't feel was the greatest, and with this class, I feel it really got me up to speed on what I was likely missing.

Great entry level course for the program, and reviews basic OS concepts that may be used in other courses. Tests were a little tricky, but generous end of term curve.
The key to the course is to watch the lectures, then read the assigned papers, then start the project. You can burn a lot of time by just starting to code. This is a recurring theme throughout the program.

The lectures were well organized and break the concepts down into simple to understand chunks. The TAs are heavily engaged on Piazza and go out of their way to help with projects.

The course was a little demanding during the Summer semester, but suspect it would be a little more tame during Fall or Spring. This course could be taken with another course (though I didn't do this).

Be sure to know C/C++ and Linux ahead of taking the course...the projects could be overwhelming without this knowledge beforehand.

This course is very rewarding but very difficult. I would recommend taking it, but not in the summer. The projects are extremely time consuming. I spent ~60 hours on each of the first two, and didn't finish them. I finished the final project only because I dropped everything to work on it as soon as it was released.

Other students have reported the exams as straightforward, but I found them tricky. Some questions are vague and open to interpretation. One question presented you with a page of code, and told you to highlight all the lines with errors, or all the blank lines where something was missing. Also, some of the material feels like it's only being taught for ease of testing. I don't think it's really important for us to memorize how to calculate task throughput or cpu utilization or page table size, but they are easy to test.

As others have said, the course is extremely well organized, and the professor is active on piazza. She also very actively solicits feedback, and seems to care about improving the course.

This was my first course of the program and while it was extremely demanding, it was also very rewarding. Between the lecture content and the projects, you cover concepts and direct applications of those concepts. The summer made the schedule very tight but it is doable. The biggest hurdle for those without any C experience will be the first project and trying to understand the project requirements while at the same time picking up C. I have a fairly heavy C# and Python background but had to spend a lot of time learning C constructs before I could even get started on the projects.

Make sure to join the slack channels for the projects, they are a crucial life line. The amount of material covered on the exams can be daunting, but the course is very fair and if you put in the time to really understand the material then you'll be fine.

The course lived up to its reputation: difficult but worthwhile. I had done some significant prep work by reading most of the "Operating Systems: Three Easy Pieces" textbook. This helped with comprehending the lectures and the exams. My previous semester was CS6290 (HPCA) which also covers some of the memory management topics, making those sections easier as well. I think those two courses pair very well together.

The projects were difficult but enjoyable. The summer session skips project2, and only required projects 1 (IPC) ,3 (Shared memory), and 4 (RPC). Projects 1 and 3 used C. Project 4 was new for Summer 2019 and used C++. My C was very rusty. I attempted to prep by reading through parts of the K&R book and working some basic examples, but it was not sufficient and there was a lot of learn-as-you-go during Project 1. A solid understanding of pointers, character arrays and null terminated strings is definitely recommended background.

The Project 4 rollout was actually fairly smooth for a brand new project. The transition to C++ was a little difficult for me, but manageable. I'm sure they will be making minor changes to the project based on feedback from the class moving forward.

The projects use Udacity's Bonnie to test your code, and these checks were most of the project grade, so it was fairly straightforward to know how you did. The feedback from a failed Bonnie check was sometimes vague. Setting up a good local testing environment was very important to project success. The number of submissions was limited to 10 within a rolling 24 hour window to encourage as much local testing as possible.

The time commitment is significant, and was a challenge over the summer. I estimate I spent roughly 2 hours/week watching lectures, 3 hours/week reviewing/studying (more close to the tests, less at other times), and probably 30-40 hours per project. All told over a 10 week course, somewhere around 16 hours per week average.

The TAs are very present and helpful on both Slack and Piazza, although they do expect you do to at least some amount of searching for the answer to questions yourself before simply asking. The project Readme files include links to background and reference material. If you're not a strong C programmer, plan to spend some upfront time reading them before diving into the code.

The Slack workspace has a very active community of both TAs and students from previous semesters. This community went a long way towards making the online program feel more like a traditional classroom.

I'm going to say I loved this course, but with one large caveat: the tests, in my opinion, are not well delivered and the stuff that gets you points on them is not terribly helpful to know (specifically the calculation-focused questions). The concepts behind them are helpful, but the format the test is delivered in (a Canvas quiz) really does not do the material justice.

The material is exciting and interesting. You get to learn about low-level concepts like multithreading and how memory access actually works (up to a point), but then you also get to learn about larger scale concepts like distributed systems. I really found very few of the lectures to be a slog to get through, it was legitimately interesting. The only material I didn't love were the papers - I found them pretty dry and some of them were also more of a history lesson in operating systems.

The projects were definitely one of the best parts of this course. The first two projects (technically 1 and 3 since summer session skips project 2, though project 2 is a write-up I hear) are a great way to learn inter-process communication in C, and they also naturally progress into multithreaded implementations of the projects.

Of particular note is that they tried out a new project 4: a distributed file system using C++14 and grpc/protobuf. That was awesome. Going from C to C++ on a modern tech stack in industry use was really fun and I feel like I learned something valuable. There were some hiccups with the grading suite but it got worked out eventually.

To succeed in this course:

• Come prepared knowing C in advance or the projects will be very difficult.
• Since they are using C++ in the last project, that will also help you a lot (you can use advanced features of C++ to great effect there).
• To succeed on the exams, watch and understand the lectures, take advantage of the exam practice questions, and make sure you have any "trainable" problems down pat (don't just hand-wave them away if you understand the underlying concept, actually practice them).
• Read Piazza and lurk the CS6200 Slack for advice and to keep in touch with TA announcements.
• Do the assigned readings.

In the compressed timeframe of summer it was a lot of work but it is doable and you will get something out of it.

This is a review from someone with no prior formal background in computer organization or systems programming.

Learning C/C++ and Linux while trying to complete these class projects felt like being asked to navigate an underwater cave without having ever scuba dived. Sure, I've gone snorkeling before, but this is totally different.

The course instructors occasionally throw you a bone. Maybe they give you a map of the cave. Maybe they tell you which areas of the cave you should avoid. But damn it, I just want you to tell me if I'm moving my feet correctly! Without this understanding, every inch of movement feels strained, inefficient, unenjoyable.

I think most of the non-divers give up after spending a bit of time underwater and realizing how deep the first cave is. I feel as though the majority of folks who continue onward have done this before and do find enjoyment out of navigating these underwater caves in creative ways. I think I would have too, if I hadn't been so distracted by my inability to do simple things like "swim forward" and "turn around."

My satisfaction from this class comes from the fact that I did make it through, though with a few major bruises. Now if someone asked me if I can scuba dive, I will say "yeah! And I can probably find my way around underwater caves... though my form probably still needs a lot of improvement."

A very good first course for my OMSCS journey. Very good and helpful TAs who also run a slack channel along with Piazza community. Instructor is very good in lectures.

Projects were the best part of the course, which were very well thought of and gave a hands-on experience of the theory being taught.

Overall, a fantastic course.

P.S.: I am not from a Computer Science background but have 4 years of programming experience in industry.

Great course. More challenging than I expected having already had an Intro to OS course in undergrad, but mostly due to the large projects. If you know C, you'll be fine.

I'm writing this to help future OMSCS students understand the expectations. This was my first OMSCS course. I went in cold and was shocked by what I found.

You are on your own

CS-6200 expects that you are able to work alone and come to conclusions on your own. If you get help from another student, that's great as long as it does not directly answer the project mystery element or direct you to the solution. You probably won't get a TA to help you. You will never get the professor to interact with you.

You're being punished for previous students cheating

The projects are designed to prevent cheating, not for you to learn best practices or implement known quantities. You do not have access to automated tests. The project submission tests provide sparsely worded output. Your work will fail because there are hidden/undocumented requirements. The requirement documents are very poorly written copy-paste jobs that were made in haste. Your program can meet all the requirements and still fail all the tests. You will be told it's up to you to figure out why.

The lectures and readings are almost totally disconnected from the projects

I found the lectures to be delightful. I only wish they had more best-practices or implementations of topics. CS-6200 chooses breadth over depth, which is NOT what I expected. Disappointing. For example, the lectures on thread strategy go into concrete patterns; while the lectures on shared memory are basically concept level.

The exams are worded poorly

Expect questions that could arguably have multiple answers, but only one is "correct" for the exam.

The official books are reference only

Don't bother buying them. They won't really help.

TAs are not here to help you

It would be so easy to divide the class by the number of TAs and assign people to a particular TA for questions with the caveat that other research and Piazza be tried first. They don't do that here.

Piazza is good, but ...

It's other students responding to your questions 99% of the time. Occasionally a TA will pop in. The professor will make an announcement here or there.

Slack is worthless

Side conversations, snarky/sarcastic comments and general "I don't know either, but..." comments make it hell to deal with. On two occasions, the right mix of people were online and helped me at least eliminate guesses to passing tests. This saved me trial-and-error time. It's a deceptive medium. In retrospect, I should have flooded Piazza with questions.

Other school's master's programs are more cohesive

After reviewing other colleagues experiences at their schools, I'm seriously considering switching schools to focus on one or two projects a semester and walk away with feedback and code-reviews from a breathing professor instead of an automated submission tool.

Good course.

I always want some exposure to OS. This is a pretty good intro course for OS. Prof. Ada did a good job at lecturing and giving projects. The TAs are helpful and active on piazza. Both TAs and the prof. are responsible at office hours. Apart from basic concepts in OS, like threading, concurrency, virtualization, memory management and file system, I like the last couple lectures where the prof. gave some knowledge about latest cloud computing technology. The projects are in C and are a little bit harder than I expected, but still manageable with some efforts. Understanding the course material well is the key to get high scores on mid-term and final. The instructor is cool with grade curving. This semester we have >82 = A.

Participation: 5%. Project 1, 3, 4: 13.3% each. Project 2: Extra Credit. Midterm: 25%. Final: 30%.

This was my 1st course (taken alongside 6035) and I do not have a strong background in coding. As such, the projects were extremely challenging, requiring a strong background in C and linux experience. The projects are doable, as long as you start early and pour your blood, sweat, and tears into the computer. Even if you don't do well on the projects, you can still do well in the course (provided you study for the exams).

The midterm and final are closed book and provided via proctortrack. The questions are not multiple choice. Review the lecture videos at 1.5x speed before the exam, walk through the practice exam questions, and use study guides from previous students (linked in piazza or slack) to do well.

Even if you don't feel like you are doing well, stick it out. The cutoff for an A is usually in the low 80s, and a B is in the low 60s. Do Project 2 for extra credit (no coding required) and participate throughout the semester- if you're on the border between grades at the end, these things can bump you up to an A or B.

Summary

I really enjoyed this class. I'd forgotten a lot of OS concepts since completing my undergrad degree and this class had a ton of awesome information. Projects can be challenging, but are doable. I'd recommend this class to anybody that didn't just take an OS course.

Projects

The first project is ridiculously stressful if you're not used to writing C (like me). I spent a lot of time on it - easily 50 hours to catch myself up in C, learn the project format, solve the problems, learn how to use Bonnie, etc. After the first project, it was a lot easier. Doing well on the first project will definitely improve your experience through the entire semester, so work hard here. The documentation in the projects is verbose and still somehow awful.

Lectures

This is my first class and I'm torn on the lecture quality. I liked Ada's delivery and I personally thought the lectures were pretty well done. I think they have some small problems. For example, there is some material that is confusing but apparently too hard to re-record (the consistency models example with "Not OK!" displayed through multiple "ok" examples comes to mind). Not bad, but could use some improvement.

Instruction

I'm torn here. I think the instructor & TAs are highly involved in the piazza and slack discussions, but the TAs tended to be pompous because of their tiny bit of "power." The TAs were super helpful - they just came off as jerks pretty often. They had weekly office hours streams which could make up for some jankyness in the lectures, but they managed to change the time every week. It was hard to get to them when they were live, but Ada answered any question she was asked. She's pretty great.

Communication

Slack was a cesspool. The first thing I saw was someone telling everybody else to drop the class over & over and it didn't improve in a general sense. It was great for project assistance, though. There was always somebody in there to answer something. Piazza is perfectly civil. It also had lots of good information, though I hate the whole "post something interesting" for participation credit. Participation shouldn't be about posting random things that force others to wade through it. Maybe I needed to learn how to use filters more effectively.

Exams

Midterm & Final with the final only covering the second "half" of material. The midterm only covers half the amount of information the final does, though. Fair exams that are pretty easy to pass if you study the lecture material, take notes, and maybe read a suggested textbook.

This was a very well-run course. The TA and professor involvement were outstanding. The difficulty level will really vary depending on the skills you bring to the class. I took an OS course when I did my undergrad, but that was almost 2 decades ago. Taking GIOS was like doing a good ab workout - it was painful at times but strengthened some core muscles that needed work.

The tests are worth a lot, 55% of your grade, and the exams require a lot of preparation. The professor provides sample questions and study help, but it is a ton of material so start preparing early. I definitely recommend paper/pencil notes while you watch the lectures. That helped me process and also provided a nice study guide for the exam.

There are several papers highlighted in the course. I recommend listening to the lectures before reading the papers, the professor does a great job of setting context and discussing methodology and results. You still need to read the papers, but it is much easier after listening to her lectures. All required projects are in C. A vagrant file is provided if you wish to use a VM. Projects can be tested ahead of time (up to 10 submissions a day) on Bonnie. Projects are not 'all or nothing', it is possible to get points even if you can't get it all working by the deadline. Also, 10% of each project is a report/write-up, so you can get some points for showing your understanding.

Want to program in C? Want to understand what goes on underneath the hood of an operating system? Then take this course (unless you have zero programming experience).

As many of the other reviewers have mentioned, this course is both extremely rewarding but demands anywhere between 8-15 hours of studying and programming per week. In my review, I'll share my thoughts on how to prepare for this course, what you'll learn, and the four projects (one of optional, for extra credit) that you'll tackle. Further, it's worth noting my academic and professional background: a handful of undergraduate CS courses (e.g. computer organization, data structures, discrete mathematics) and a software engineer at Amazon Web Services (AWS)

Don't take this course if

• You have no programming experience

How to prepare for this course

• Brush up on your C programming skills
• Brush up concepts covered in a computer organization & architecture course

Typical workload

• Read approximately 1 research paper (my favorite were: Birrell's threading concepts and another one light weight processes) per week
• Watch lectures
• Work on project assignment
• Read textbook (optional, but helps fill in the gaps)

Project assignments

• Design and implement a multi-threaded client and multi-threaded web server
• Write up a paper describing metrics that you would use to measure performance of (above) web server
• Design and implement a web server that interacts with a cache server, using some form of inter process communication (IPC) such as message queues and shared memory
• Implement a remote procedure call server, client

As other reviewers have mentioned, the project assignments require you to program in C. So do yourself a favor: brush up on your C prior to taking this class. If not, expect to add an additional 5-10 hours (from what I gathered from other students with limited C programming skills) on top of the average 10-15 hours you'll be spending on course work (i.e. watching lectures and working on projects). And although not entirely necessary, I also recommend taking a computer organization and architecture course, which would cover some basics like registers, machine instructions, assembly, memory management, since this course jumps right into multi-threaded programming.

What you'll learn

A lot. Check out the course syllabus. Because of this course, I'm a better software engineer / computer scientist. In no particular order, here are a handful of the topics I really enjoyed:

• Threading and using mutexes (for mutual exclusion) and semaphores (for scheduling) when writing concurrent programs (using threads or processes)
• Processes and how they can communicate with another using inter process communication (IPC) techniques such as pipes, message queues, shared memory
• Scheduling algorithms (e.g. Linux O(1) and CFS)
• Memory page implementations (tradeoffs when selecting a smaller/bigger page size)
• Tradeoffs on implementation distributed systems
• What Remote Procedure Calls (RPC) are and how similar they are to HTTP/XML APIs we see in contemporary systems

Tips

• Get on the omscs6200 slack channel and follow the conversations (very helpful for projects)
• Check Piazza frequently, at least two to three times per week, for upcoming assignments and projects
• Start projects immediately as soon as they become available

I learned a great deal but oh boy that was a lot of work. Make sure you start all projects right away, stay on schedule with the lectures and keep track of Piazza and slack. Make sure you refresh your C to a pretty good standard before you register to this course.

I thought this was a great first course. The work isn't too difficult if you already know C/C++. If you don't, I would imagine this course would be much harder. There are some more relatively "advanced" uses of the language when doing the projects in this course and the majority of the people that were struggling to finish projects on time (especially the first) seemed to have been new to C/C++.

The projects are doable in a reasonable amount of time but START THEM AS SOON AS POSSIBLE (especially project 1). I promise this will save a little bit of sanity in the long run when trying to keep up with lectures. Stay active on Piazza/Slack, too. The TAs and other students are key to succeeding on the projects if you want to please Bonnie (the auto grader). Spend the time to do well here - in the end you will realize it's actually easy points. Project 2 is also an extra credit project (~3 page paper which took about 5-7ish hours worth of time).

There is far more material in the second half of the class than the first and this is where it gets much harder. You really have to be on top of the weekly pace of the lectures after the midterm or else you will immediately fall behind. Not only is the material greater in quantity, but it is also much more difficult to digest. Get ahead on lectures the second half of the class if you can - I thought there was a good opportunity to do this before the midterm.

The practice questions they give you for the exams are very helpful - I would spend a decent amount of time on them and know them really well. The exams are very fair and as long as you put in the time you will succeed.

One of the best run courses I have taken anywhere. TAs were helpful and active in Piazza. Projects were a lot of fun (and work!) that reflected the learning objectives. The lectures done by the professor were outstanding. Easy to understand and interesting to watch. About 10 papers to read, most around 10 pages. They actually were decent, though. Most were done by engineers working in a real company and not some academic.

Midterm 25%, Final (non-cumulative) 30%, 3x Projects 40%, Participation 5%. Also an extra credit project/small writing assignment worth up to 4%.

Projects each had about a month window to do them in. Plenty of time if you start early (or if you don't like the majority of people .. can be frustrating). They are all in C and heavy on threads. If you have no C experience, then this can be a painful learning process. Definitely not the kind of projects to cut your "C teeth" on.

The exams were pretty straight forward. If you understood the material covered at a conceptual/high level, you will be fine. If you don't watch videos (or wait until last minute to do it) or don't care to read papers or don't want to think about them while doing it, then I guess the tests could be difficult. Administered via Proctortrack. Each gave us plenty of time (1-2 hr) and also about a week window for when we could take them.

I would highly recommend this class to anyone who wants to be a programmer. Just a fantastic class in every way.

Great class! Delivers on its promise to present OS fundamentals in a really engaging way. The lectures are very clear and well designed. The course introduces several seminal papers (old but foundational) in select areas of OS theory, which are generally well written and easy to understand. The 3 required projects are on 1) Multithreaded programming with sockets, 2) multiprocess programming with IPC, and 3) RPC. All are in C, and they complement each other pretty well. They aren't trivial, but the staff makes available a pretty good cloud-based test suite that you can run your code against before submitting, so you generally know where you stand once you finish. Exams are pretty easy. There's opportunity for extra credit from an extra project and Piazza participation.

It's a large class so there's a lot of Piazza chatter. Some students can get pretty salty if they're struggling on a project and seeing flaky results from the tester. Multi-threaded code can cause some pretty weird bugs, so I think for the most part it was due to student errors. The staff took the feedback seriously and handled it fairly and with an open mind.

The class pairs really well with HPCA - many of the same topics are covered in both classes, but GIOS focuses on the OS side, and HPCA focuses on the hardware side. The overlap just helped provide a fuller understanding of how the system operates top to bottom.

My background is ~18 years experience as an embedded developer, who has written some small bare metal schedulers before. I have very little Linux experience, but lots of C experience. The class could be pretty hard if you don't understand computer architecture or C very well.

Excellent class, you can tell the TAs, and especially the professor, have refined the material, timelines, and overall approach to maximize benefit to the students.

Recommendations to succeed - stay active in the slack channel for projects (just reviewing past conversations on the project channels answered close to every question I had), ask relevant questions on material in the office hours, and review the references pinned in Piazza and the project readmes.

Be careful, Tests are worth ~60% of the grade! However, they are not cumulative which is a relief, you don't have to worry about studying for material from the beginning of the semester while prepping for the final.... the breadth of material covered is relatively thorough throughout the semester.

If there is any desire to understand operating systems, program in C, or understand lower-level computing concepts I would recommend this course.

It is not easy, but if you put in the time and have some programming background it is very doable with 15 - 20 hours a week on average of work.

Pacing is great as well.

If you are familiar with C, this class will be reasonably easy. Otherwise, try to get some intro to C (particularly pointers).

The Professor and Lessons are great. The assignments and tests are nearly impossible. TAs (most, not all) are very condescending and expect you to already know what they are suppose to be teaching you and will shame you on post boards for not knowing. Take this class, do your best, expect very little in return.

This was an excellent course with interesting programming assignments. Highly recommended!

I actually took Intro to OS in Spring 2019, but I had to drop it before the first project is due. I strongly recommend that you have a STRONG foundation in C before attempting this course. There are people who do well with little knowledge of C, but I am a professional develop in function languages and I found the first assignment VERY time consuming to correctly finish. I previously took an Introduction to C programming course a few years ago, so I felt I would be OK for this course. If you are looking for an A or a B without a VERY high amount of stress, I strongly recommend you take a few non-graded MOOCS in C and read at least a few books before attempting this course. I am a functional programmer for my day job, and I found the first project to be very challenging. Also, begin the assignment as soon as it is assigned, because TA's can be difficult to reach outside of office hours.

This is the hardest course for me so far (my third class). I had a little C program background and didn't have any OS class before. The concept was intensive at the beginning because of all the new terminology and mechanism, policy, abstraction so on so forth. So is the first project. To a lot of people who are experienced programmer, it might be just a review but for me, it was a catch-up. I spent more than three weeks just doing warmup part of project 1 (worth 20% of project 1, probably only earn me 2 points of 100 final grade). And don't think it will get better, it will get worse on project 2 and worst on project 3 in term of the workload.

I thought that I won't be liking the close book mid-term and final much. But I was wrong, the reviewing process before the test helped me to look into the concepts and practice the quiz and calculation on my own. The test is still hard but you learned through it. I like the TAs, they are very active in Piazza and on Slack channel. I also think and thank that a great class attracts a lot of great students, learn with them and from them is another gain in this class. Cheers to my classmates!

I loved this course. The prof is amazing, she is always available, mostly helping students clear their doubts. The TAs are also proactive and will help you in all aspects of the course.

this was my first omscs class and i do not have an undergrad degree in cs. it was not a good first class for me since i was not good at adjusting to this whole studying after work thing and getting into the routine of it all with a significant workload waiting for me.

the material difficulty was not high, but i struggled at first since i found the course lecture videos very tedious and useless. the professor read the slides word for word most of the time and provided little depth or clear explanations. eventually i figured out that i really should be reading/watching other materials to actually learn the subject matter and then watch the official lecture videos to get a sense of what we were expected to know.

the papers i gave up on reading after the midterm, thankfully other students put together summaries and the stuff you need to know is covered in lecture videos.

the projects were challenging and fun(like a 80/20 split), i had 0 C experience going into the course. START EARLY.

I highly recommended this classes.

The prof and TA are highly involved and very responsive. Prof. Ada answers question on Pizza and weekly office hour (via Youtube live). The TAs mostly response via Pizza and Slack.

The courses has 3 coding assignments and two exams (mid & final). The courses also provides lots of chances for extra credits. The most difficult assignment is the 2nd one; the first one is also challenging if you don't know much about C (like me).

If you want to take this class and are very new to OS and how the underlying hardware works, I will recommend reading the book "Three Easy Piece". It's very related to this course.

The instructor, ta's and piazza/slack channels where a great help in this class when doing the projects and exams. If you keep up with both pizza and slack, youll have an exponentially easier time with the course material and exams than if you ignore them. Glad to have taken this class as my first class in the omcs program.

Great but difficult course. The language used is C in on a VM running Linux. This was my first time really using Linux and a VM so the initial start/setup was difficult for me but once i got everything up and running. it was better. Still difficult, involving multi-threading clients/servers and ways to lock data from other processes. Not recommended for a first course and make sure you watch all the lectures in order to complete the projects. TA's are helpful and other students in slack channel were very helpful.

The course was extremely stream lined and well organized. There is a strong interconnect between project and lectures. Prof. Ada was highly engaged and passionate in driving the course. Her office hours were regular, and she took the pains to clarify doubts students had. That said, this class also expects a lot from students; it does help if you know C, but even if you don't, expect to put in a lot of efforts into projects. Lectures are detailed, with a lot to unpack with an array of tough to understand papers. However, it helps to ask for help, and no question was treated as a dumb one.

Exams were not very tough, but they really tested your knowledge, especially the math portions that cannot be guessed. TAs were also very knowledgeable and supportive, especially Tony, Hobin, VJ and Ioan. The class communication is usually through Piazza, but the slack channel was very active, especially after the release of a new project.

I'm impressed with this course, because everyone involved was genuine and had a real interest in making sure the students understand OS concepts.

This was my first course in this program. It was not an easy one but I definitely got to learn a lot from this course.

My Background for Reference :

• computer science undergrad
• professional software engineer for 2.5 years experienced in Java, Python, and JavaScript
• rusty on the C

This was my first course in the OMSCS program and I took it alone, which ended up being a wise choice. While it wasn't terribly difficult, it was definitely time consuming, even if you have solid programming skills. The course is very organized. All the information to succeed is pretty much given to you. There are study guides as well as practice exam questions which will help you target your studying.

The lectures are very well put together and must have taken a ton of time to create initially. Each week there is a lecture that takes anywhere from 3-5 hours to watch if you do any decent note-taking. The concepts are well-explained and will give you the material you need to do prepare for the projects and exams. There are research papers that you are recommended to read as well. Read them if you can. If you can't it's not the end of the world.

I learned the most when preparing for exams. If you study appropriately, you should do fine on the midterm. I re-watched lectures and did the study guide and sample questions. It felt like there was much more material to cover on the final. I studied much more for the final and felt way less prepared for it.The material seemed more difficult as well, so study smart. I skipped a good chunk of the research papers in the second half of the course.

The projects were the best part of the course. The instructions are pretty clear and you'll learn a ton coding them. Definitely join the Slack channel; I gained invaluable information from other students that I would have never figured out on my own. Disclaimer: I take a while to do assigments.

Project 1 (various client/server programs):

• very time consuming since it is really like 4 mini projects in one; I probably spent around 70-80 hours on it, give or take
• probably takes the longest since you're getting a feel for the course and ramping up your C skills
• if you can get through this one, you should be fine for the rest

Project 2 (extra credit):

• 1.5 page paper designing your own experiment based on prompts they provide; maybe 8 hours on the high end
• only graded if you're on the edge of a letter grade

Project 3 (Proxy Cache Server):

• There is much less hand-holding on this assignment and you will have to come up with your own design
• probably took me 50-60 hours

Project 4 (RPC):

• this one is mostly learning the RPC libraries
• took me probably 20 hours

Overall, it was a great course and I learned a ton. I'm using this as a segue into Advanced Operating Systems.

This course offered a good amount of introductory material about operating systems. We had two exams (midterm and final) that where both closed book/closed notes and 3 Projects with the option of a 4th extra credit project. Each exam covers a good amount of material and concepts to master. I found this to be the more challenging part of the course as you must understand the concepts well to do well in the exams. I recommend watching the lectures a few times while taking notes and making sure you understand all the concepts prior to moving on to the next lecture. The projects were time consuming but doable. I used one of the recommended books as reference for the projects and found it to be a great resource (Linux Programming Interface book). I would recommend using safaribooksonline (it is free for gatech students) to get access to this book and other books the professor and TAs mention as reference (C programming books, etc.)

I went to one of the top 3 (Berkeley, Stanford, MIT) CS schools for undergraduate so my opinion of this class may be a bit skewed. I thought this class was easy to medium difficulty. IMO it's easy for anyone to get an A as the general cutoff is anything above an 80%. Tips to succeed:

1. Start projects early and try to get 100% on them. No reason for anyone not to. There's 3 weeks of time and the projects require 5-20 hours each? (With each project getting easier than the last).
2. Keep up with Piazza. It'll help you with all the projects if you ever get stuck.
3. For exams you only need to get like 63% (given that you complete the projects and get full participation points). And exams aren't hard. There are review questions and then Udacity sample question for both midterm and final. Spend 80% of your time on the Udacity sample questions b/c the actual exams mirror them more closely than they do the review questions given by the professor.

Great class content, I've learned a lot, and overall very lenient making it more fun to learn than stressing about grades all the time.

Hard course, but I loved it and found it incredibly valuable.

Projects are tough, but rewarding. Echoing many others here, make sure you are proficient in C. Not just familiar, but proficient. Otherwise, budget for 1.5-2x these listed workloads.

The tests are hard, but fair. The most challenging part of the exams I found was simply budgeting time to study properly. The projects were often so demanding that I lacked spare time to keep up with and review the weekly material properly. Instead, I had to scramble a bit to catch up about 2.5 weeks ahead of the two exams. This works, but at the cost of better long-term retention.

GIOS was the perfect start to OMSCS. The course is managed really well. Prof Ada and TA's are very involved. The content is good, projects are challenging and exams are tough.

There were 4 projects ( a 2nd one was an extra credit project). The project were in C. I had minimal exposure to C and that made project 1 really challenging. By project 3 I was fairly confident in my C skills. Project 4 was fairly easy as compared to the other two.

The mid-terms and final term exams were tough and application based.

I would highly recommend this course.

Overall, I really thought this was a good course. I have a BSc in CS, but it's been a few years, and I don't work in the industry. While I did have an undergrad OS course, I thought this one covered the basics, but also went deep enough for a graduate level course.

The projects were the high point. They were well structured, and had just enough framework in place that you had to do around 50% of the work to complete the project, but didn't have to reinvent the wheel (for parts that built on previous parts, there was either code or binaries to fill in the previous work). Exams were very fair, but take them seriously - they are written in such a way that you can't BS your way through them. They really do test your knowledge...

I would highly recommend this course as a first course.

3 projects, a midterm and a final make up the grading with 1 additional project for extra credit that's only graded if needed as well as class participation.

First and foremost, this is a fun and worthwhile course. You can tell the professor cares about the topic and about the students. The TA crew is phenomenal and there's a dedicated private slack for the course.

That being said, if you don't know C or can't recall your C-fu from many moons ago then be prepared to double your workload. It's all C, all the time in GIOS. As a web developer, I had forgotten most of the C I had previously learned and probably spent 40+ hours on project 1 but YMMV based on your C competency. You may not enroll as a C developer, but you'll certainly leave as one.

The exams are difficult and are a combined 55% of your grade. The final had something close to 20 dense lecture hours and the questions were definitely indicative of that.

All of that may sound ominous but if you put in the work then you're likely going to get at least a B AND learn a ton. There aren't any free lunches in GIOS, but there is a generous curve that rewards those who keep working and stick it out. This course currently has about a 40% drop rate, but it also has about a 40% A rate.

I wish I would have taken this course as my matriculating intro course to the program.

I loved this class. Professor Ada went above and beyond to be involved with the class. She was very responsive via email (I literally got a response back within hours) and did weekly office hours.

The TAs for this class were extremely standout. They're always hanging out in the 6200 Slack (one of the TAs actually paid out of pocket to host a private Slack instance so that there's search history available for everyone, which is extremely useful for the projects). They're always around to offer hints and help with the projects.

The lectures themselves were long, but really great and informative. The readings for this class were also extensive, so prepare yourself. However, watch the lectures first and then do the reading. Professor Ada does a great job in making the papers a lot easier to understand.

This class is no walk in the park, but it's also not hard as long as you try to stay consistently on top of the lectures. All of the projects are released about a month ahead of time, so get started the first moment they open. I also know the first instinct for a lot of people when met with coding problems is to charge ahead and start coding. I highly advise you to not do that. First, read through the README. And then maybe do it again. It might leave you confused, but they're extremely thoroughly worded to help guide your architecture of your programs. Then, read through all of the code. (Everything is in C, so start brushing up on C, particularly with string manipulation and pointers.) I found it extremely helpful to read through everything and then leave comments with TODOs to mark up the entrypoints of where I needed to code.

The midterm and final were also pretty challenging. The course covers a LOT of content, so study up on the study guide and the sample tests that are provided. Make sure you are VERY solid on the math portions towards the end of the semester, since they are likely to be heavily tested.

This was my first course in OMSCS and I'm really looking forward to the rest of the courses if they're all as fun and engaging as this one. I don't have an undergrad CS, nor did I have prior experience with C (though I code everyday in Golang and dabble in Rust, which helped a lot), so don't be afraid to come into this course even if you have experience with neither. You can definitely pick C up along the way if you start your projects early and do a lot of Stack Overflow/Googling.

This is my first OMSCS course and I loved it. The course is very well organized and the professor explains things really well. A lot of very useful OS fundamentals and concepts are covered. The lab is a bit challenging, so recommending start as early as possible. You'll benefit a lot when finishing them.

Great course.

Projects are hard but totally doable.

Exams are very fair. Look at the review guide before anything else.

Takes a lot of time but you'll learn so much. Definitely recommend taking it.

This was a very well--organized class. The TAs were very involved. Tony was great. I think the lectures are easy to understand. I got much better at C programming from this course. As someone who's a software engineer, I found I was pretty familiar with most of the concepts - the course doesn't delve too much into detail, so I maybe didn't learn as much as I expected. The midterm was manageable. I did almost 0 work on the weeks there wasn't a project due, and up to 15 hours to complete a project (though less for others). Would definitely recommend as a first class, it's not too hard. The concepts are kind of all over the place so detail is spared throughout the course

This was my first class. It was a wonderful introduction to systems concepts.

While there are people that picked up C along the way, I was thankful that I took CS50 on edx prior as it introduced me to memory/pointers, C data structures and makefiles. There were plenty of other items that one needed to learn on the fly as they started the class and it was good to get some C knowledge first.

Some architecture background (for example registers and caches) is a nice to have but it is possible to figure it out during the semester.

Overall, I found both the projects and exams hard but doable. This was a great class.

This is a very good introductory course on operating systems. I did not have undergraduate CS background. The course is very hard for me but I learned a lot. Familiar with C is a plus. Projects took tons of time even though they are only weighted for 40%. To prepare for the exam, I watched the lecture videos several times and I think that helps.

This course taught by Prof. Ada is very well run. The lectures do a good job of explaining the material and Prof. Ada holds regular office hours to help clarify things. Her involvement was very helpful. The TAs were very good in this course as well, but grading was a bit slow. I took this as my second course in the program. I took it in the summer, so there were only 3 main projects instead of 4, and then there was a midterm and a final. There were also a few required papers to read. If you are comfortable with OS implementations and how they function and are comfortable writing in C, you could probably skip this class. But even though I had an undergrad OS class about 3 years ago, I found this course to be sufficiently challenging and I learned a lot from it.

All the projects are programming in C and they can take quite a bit of time to work through and debug, especially if you aren't super comfortable writing and debugging in C. The assignments were available early enough to allow you to have enough time to work on them. The midterm and final are closed book and fairly difficult and are carefully worded to make sure you understand the material. But there is a generous curve in the class. If I remember correctly, somewhere in the low to mid 80s usually ends up being an A, and somewhere in the low to mid 60s ends up being a B. I would highly recommend this course and I think if you put in the work it's not too difficult to pass.

I had to withdraw from this course, primarily because of the projects. As others have mentioned, they are extremely opaque and piddly - your only verification that they are meeting the course's test cases are a limited number of submissions per day with very little feedback surrounding that submission and little information surrounding what the test case even was. I will admit that C is not a language I'm particularly good at. I recommend becoming very competent with C prior to attempting this course. Additionally, the specific APIs in C - which are poorly documented wherever you go - become your worst enemy.

Prior to withdrawing, lectures were about on par with what I remembered from my undergraduate-level OS courses. Overall, unless you're really interested in OS or need this for a requirement, I would skip it. The projects are honestly hugely frustrating and they don't need to be - a local testing framework which mirrored 90% of the autograder's test cases would have made this a much less piddly course.

A great class! For people who is not majored in computer science before, this course will significantly improve your understanding of basic computer component such as operation system, kernel, CPU etc. The projects are somehow difficult, but if you start earlier, those projects are definitely accomplishable

This was my first course and I wasnt expecting it to be such a difficult one. I did learn a few things which i hadnt learnt when i was doing my under-graduation and the projects are quite good. But, you need to have working knowledge of C for these projects or you are in for a bumpy ride. I hadnt worked on C in a long time and had completely forgotten about it. The projects take up a lot of your time. The TAs are helpful.

Very good course if you want to practice your C and write Multi-threaded code for client/server applications.

Challenging but doable class. The lectures were very informative and the exams were straightforward. The projects had a decent level of difficulty but were really fun to work on. All projects were in C, so definitely have some programming experience in C with call back functions and pointers. Submitting projects also used Bonnie so it would tell you if your code passed the instructor's tests before you had to submit it. Overall really enjoyable class - I would recommend.

This course covered the basics of OS constructs and theory and does it very well with the exceptionally made lecture videos.

The TAs are indeed something else - they are extremely hard working and will bend over backwards to help you in times of need. They're absolutely world-class.

One thing that almost made me hesitate to rate this a 5* course was that the projects seemed to be more about applied knowledge rather than the actual theory behind the OS constructs. The projects were basically creating multithreaded HTTP and file servers, parsing network packets, and calling RPC servers - projects that I would expect in a networking class. I was expecting projects more along the lines of writing a simple, primitive OS? Maybe these projects are in the next class (AOS)? For what the projects are, they were well designed, fun, and were sufficiently challenging and thought provoking.

• Like all OMSCS projects, procrastinate at your peril. Some projects may appear simple until they aren't because of some small thing that just refuses to get resolved. Project submissions are limited to 10/day.

• You don't need to know C to do well in this class - it appears a good number of people in the class had no previous C (or even programming) experience. But knowing at least about pointers and gdb will save you a good number of hours of struggling. Even someone like me who makes a living writing C found some of the projects to be tricky. It didn't help with taking this in the summer with the compressed schedule.

• The midterm and final needed a good bit of studying to do well on. They really tested a thorough understanding of the subject matter.

• There's a TA-run private Slack channel specifically for this class, which was very useful in digging up older, informative discussions. (Remember to contribute to the slack fund, you mooches).

This course was my third course in the OMSCS and I chose it after seeing its great reviews here.

The course provided a lot of insight on the inner workings of OSes and had 3 projects rather than the usual 4 due to the relatively shorter summer semester.

Projects were all in C and pretty challenging especially if one hasn't worked with C. Make sure you know abit of C before thinking of starting out on this.

Assigned readings were interesting and relevant. Best part are they were manageable and easily understandable if read after watching the lectures.

Lectures from the instructor are great and exams were very challenging but fair. The instructor and her TAs are great providing alot of insight and help on Piazza and during office hours.

In general, I found the content really great and this is must do course for any one interested(even slightly) in OS stuff.

I did not have any experience in C, and this was my first exposure to operating systems concepts. Prior to this class, I took ML, CV, AI, and RL. Prior to this class, I read through OSTEP and Computer Systems: A Programmer's Perspective, to prepare.

• The projects pushed me to ramp up my knowledge of C very quickly, and apply concepts learned in class.
• The TAs were the most responsive I have ever seen, replying in less than half an hour in many cases.
• Most useful feedback I have ever received on an assignment, for project 1.
• Professor Ada was very involved. She knew the ins and outs of every assignment, and held weekly office hours.
• Professor Ada and the TAs were transparent about why they weighted the exams and assignments the way they did, and how they graded. They were also understanding with regards to Bonnie issues, and the TAs helped us out with local testing.
• Deadlines for the first two projects were extended.
• It was a very collaborative environment. Students helped each other out with enthusiasm. The interop testing especially in Project 1 was very useful.
• Resource recommendations were excellent: I will likely continue to refer to OSTEP, The Linux Programming Interface, and Beej's Guides in the future.
• The instructors actively solicit feedback for every project, and this shows in the quality of the projects. The projects came with clear instructions in a readme, helpful tips, and no mistakes in the code. I liked that we were required to document our approach and think about ways to improve each assignment. This enhanced my understanding and retention of what I learned while doing the project.
• I wish we could have gotten our grades and feedback for Project 2 before taking the final. Perhaps hiring more TAs would help, but maybe the class budget is constrained for summer semesters.
• I also have difficulty learning from video, without an accompanying textbook. I was grateful for the class-compiled transcripts, but it was a bit hard to follow since it was just verbatim. I liked OSTEP and The Linux Programming Interface, but to do well on the exams, we really have to focus on what is presented in lecture. It is probably too much to ask, but it would be great if there was a guide (similar to Beej's, perhaps) for the course. Maybe I'm a rarity though, and most students learn perfectly well from videos.
• It would have been nice to see our answers alongside the correct answers for the midterm, but that's not too important.
• I didn't find the exam guides very useful --- I would have preferred more questions in the style similar to that of the actual exams. The quizzes and sample questions in udacity helped, but there were only so many of them, and I found the questions on the midterm and final to be much harder.
• I found the papers very dry, took the advice of one previous reviewer, and didn't read them. The lectures cover the points that may be on the exam.

Overall, I love this class and would absolutely recommend it to anyone.

3 projects, 2 tests. The tests are fair enough. However, warning to anyone taking this during the summer, this class can really get away from you quickly and there is a ton of material.

The projects are by far the worst component of this course. The instructions for projects are extremely vague, leaving much up for interpretation or having to ask TAs for clarification. You will spend most of your time researching and learning the various internal and external APIs rather than programming anything cool. The code for the APIs are extremely messy and extremely difficult to work with in my opinion. Also, there are a limited number of submissions that can be made to Bonnie per day which makes it more difficult to test your programs. Therefore, you have to spend additional time developing your tests on top of the already tedious and time consuming projects.

In combination of the mundane material and frustration at the vague projects. This class has been miserable. I'm just glad it's over.

As someone new to the concepts of OS, I enjoyed most of the content of the course. The lectures were put together well and mostly managed to keep my interest. I haven't taken the final yet, but the midterm was pretty fair.

The projects are the real weakness of this course. The first project was a little bit interesting and forced us to get familiar with concurrency patterns. The trouble with this project was that the autograder became super flakey about a week before the deadline. It seems to be the fault of udacity, so I don't blame the TAs for this part. I found it frustrating, however, when I lost points due to grader malfunction and the TAs were nowhere to be found when it came time to adjust for the false negatives.

The later projects did not have these same technical issues, but they were incredibly tedious and, IMO, not very educational. They essentially took the form of: 1) implement and utilize this one concept from lectures 2) now make it multi-threaded. Enough with the concurrency, already! I learned nothing during the second and third time making something multi-threaded. Oh, and the second project asked use to call a curl library. What is point?

If you enjoy writing boilerplate C code, maybe you'll enjoy these projects. For me, they were a massive waste of time and energy and did little to reinforce the concepts of the course.

This is my first course in OMSCS and I absolutely loved it. It is very well organized and TAs were very helpful and active on slack & piazza. I wish all the courses in OMSCS had TAs like this. Prof. Ada made sure she always attended the weekly live chat sessions. I really liked the way the course videos are structured. Also learned a lot by doing projects.

One suggestion from me is start early with your projects. Do not wait until the last day to submit I learned it the hard way. If you are familiar with C programming then it should be a easy course for you. I would definitely take this course again!

Projects were interesting and challenging. The Slack and Piazza groups were really helpful in solving them.Exams were more application oriented with very few theory questions. I'm from a non CS background and this was my first course so I had to spend some amount of time getting acquainted with C and other OS programming paradigms. You would need to work hard incase you plan to get high grades. Since this class is quite easy for those with embedded or OS programming experience and the grading is relative

This is my first subject part of OMSCS. I was nervous initially and delayed a bit to start setting up the dev environment. But an early start is needed. If you are a windows guy then you can use Visual Code inside Ubuntu and helped me a lot. Reading paper for mid term and finals helps less than watching video. Prof.Ada's video covers everything and more needed for exams. Totally love the TAs ! and thier proactive helps

This was my first course in OMSCS. I have a strong C background, and had an OS course in undergrad, so I didn't find this too difficult. The projects take some time, so be sure to allow yourself enough time. Also, if you're not good with C you should allow extra time. In my opinion, the instructor and TAs were all great. Overall I think this was an excellent class, and would recommend it, especially for people new to the OMSCS program.

Interesting material presented in approachable way. Material is a little bit denser at the end but its cover more breadth. Projects are quite the grind especially if you don't have experience with C. Felt like I fought the C compiler / memory leaks more than I interacted with the course material (by a long shot). Huge curve at the end. I got a B despite doing very poorly on all the projects and only mediocre on the tests.

My background
Have used C language for numerical analysis for years
Don't have any degree related to computer science
Took this class for the first course

Review
This class uses C to program server-client file transfer concepts. There are 3 projects, beginning from simple echoing server to a server that does some sophisticated jobs like receives a file from a client, do requested work, and send back the result to the client where both server and client are multithreaded. If you are not familiar with these programming concepts, it will take time to understand and do the first project even if you have used C for different applications.

As this class declares itself as intro, the lecture covers pretty wide range of topics. Watching 1 Udacity lecture video took me about 3 to 4 hours. There are 4 to 6 lectures per part and there are total 4 parts, you can calculate how much time you have to pay for watching Udacity videos. I recommend you to keep notes for every video otherwise you will not find relevant materials when preparing for the exams. I kept notes with MS Word and I spent about 4 pages per lecture.

The workload I specified (==10hr/week) is the peak load when there is a project. I spent average 2 hours a day for a whole week to complete the project before the due date. If you are smart and can find an easy way to implement the problem, then it should be shorter. If you are going in the wrong direction, you will spend the whole week for debugging. When there is no project due, I recommend spending some time to follow the Udacity videos. It is quite long.

The instructor gracefully provides an expected question set for each exam. It is a shared google doc and students are encouraged to collaboratively fill the form. You can see other students' answers so you will find it very useful. There are two exams, midterm and final. And the final is not cumulative.

The instructor also encourages you to read provided literature. She actually covers what the provided literature is doing, and it will be also on the exams. But those technical papers are hard to read and also not very fun to read, honestly.

This was my first OMSCS course. I come from a mechanical engineering background, with only done 1 C project over a year ago during my senior year embedded computing class and capstone project. I've done some self-studying and programming at work, so not completely disconnected from the programming world.

I knew that I would struggle a bit to understand and relearn C so I gave myself extra time to do the projects (START EARLY) and stay consistent with a strict schedule. With a full time job and no kids, this class was my life for these few months.

One key thing I struggled with in the beginning was to set up your environment. They say there are a bunch of ways to do it and you can do it however you would like, but from a beginner's perspective and not knowing anything about how to set up an environment, I would have appreciated it if they had ONE default suggestion. After a week or two of struggling to get a proper environment set up, I finally found a working environment. I used VM VirtualBox to install Ubuntu (which they should have instructions/find instructions on internet), then for IDE in Ubuntu I used VisualStudio Code. This IDE was great because I figured out how to do debugging (there is a youtube video on debugging with VSC in Ubuntu), and you can debug with multiple VSC windows, essentially stepping through multiple interacting programs (debugging client AND server at the same time).

A tip is to be active on the Slack channel. It can be difficult to keep up with all the activity going on, but if you put in the time and effort, you can sometimes gain some really helpful pointers and tips. That is why it is recommended to really start early and find your problems/roadblocks early, and you can be on the lookout for a solution in the Slack channel. To get the most out of the Slack channel, I learned that you need to be very precise with the wording of your questions and try your best to communicate that through text. That will allow the TA's or students to better help answer your questions. Don't be afraid to ask your questions, but be specific and think about how to phrase it in a way for other people to understand (explaining code and technical stuff through text can be very confusing and difficult).

Another tip is try to meet up with students locally. Having someone to talk to and discuss project ideas and course concepts is VERY helpful. Of course please beware of plagiarism and misconduct according to the course rules.

Projects were absolutely great! Coming from someone with very little C programming experience, I had so much to gain. Of course they might change the project contents every semester, but our semester it was fair amount of work with the given time. The first project was the most daunting because everything was so foreign to me. The VM, which IDE to use, how to debug, socket programming (concepts I've never done nor was it taught in the videos); it was overwhelming at first... so START EARLY. Project 3 was by far the most fun (get a whiteboard) with the design aspect. Project 4 was the most difficult to wrap your head around, but once you figure it out, you will say: "What that's it?..."

If you finish the projects and pass all the automated tests with a decent readme, you should be able to get 100 on the projects. I did right at average for the midterm, and a little below average on the final (disappointed with my performance), but I surprisingly got an A in the course!

All in all, in my opinion this was a perfect first OMSCS course. It will definitely not be easy, but if you put the time and hard work in, you shall be rewarded!

I took this class after already having taken an undergrad OS course and with good familiarity with C. Having that background made the class a bit easy, but the tests will still require some studying. The midterm and final were fair but most of the questions could have been answered with only watching the videos, the papers take a long time to read and aren't heavily represented on the tests.

The projects aren't too difficult if you already are familiar with C but they will still take some time to complete. The projects taught concepts that were new to me, such as shared memory and inter process communication, so they were enjoyable. The TAs are active and answer questions quickly.

This was my second OMSCS course and by far one of the best courses I've taken at a university level. I say best in term of the rich amount of material that's covered in the lectures and projects which further reinforce (THREE projects + 1 extra credit project offered but optional) the theory. The class will require you to work very hard to complete the projects. They give you starter code and a description of what's expected. You will find yourself googling how to do things like setting up TCP sockets or using Shared Memory IPC etc. A good background in C will help in this course as all the projects require using C language. Slack and Piazza are good places to look for answers / ask when you are stuck; 7/10 times someone else has already asked the question.

To prepare for C, read and practice some examples on Arrays, Pointers (understand pointer arithmetic also), Structures, Function Pointers (used to do Callbacks), Dynamic memory allocation and freeing using malloc() and free().

Ubuntu operating system is used for the projects. I used Virtual Box to run Ubuntu but perhaps my computer is sluggish and the VM was annoyingly sluggish. I would recommend running it natively off of a partition if you can. I have two monitors but could only use 1 with VirtualBox, I could look into enabling the 2nd monitor but I didn't even try considering how sluggish it already was.

The exams were challenging but fair. If you go through all the lectures and understand the content and do the quiz examples and sample exam, you will be prepared for the exam. It is a lot of content so do keep pace with the schedule while working on the projects. I got through the class without buying the recommended books.

The course will get challenging and you might lose hope at times but keep going. Here are sample scores from a previous semester and what grades it translated to with the curve. I wish I had this information earlier in the semester:

Example 1: Project 1 - 80 %, Project 2 - Optional, Project 3 - 70%, Project 4 - 75%, Midterm - 90%, Final - 85% --> 87%, Participation - 5% (max) = A

Example 2: Project 1 - 60 %, Project 2 - Optional, Project 3 - 45%, Project 4 - 50%, Midterm - 80%, Final - 75%, Participation - 2% --> 65% = B

Professor Ada is passionate about this course and going above and beyond to help students. She holds a weekly session going over project and class questions. This was very helpful. I did not pay much attention to this till half way through the semester. It really does help understand the project requirements. The TA's are also helpful in answering question in Piazza and Slack.

It was a lot of work but I'm glad I took this class. It really makes you appreciate what the Operating System does behind the scene. Even if you don't do Systems level programming in your career, you will have a stronger foundation in computing. Best of luck if you take this class!

GIOS was my first course in OMSCS and I found it to be a good place to start. This course does have quite a bit of material that you need to get through in addition to the projects, but I found everything accessible with my CS background.

The biggest advise I would give for students considering taking this course is to brush up on C ahead of time which will make your first project much easier. If you are taking this course, make sure that you start your projects as soon as possible. Waiting to the last minute just adds stress.

Overall, great course, great instructor. Would definitely recommend.

This is my first exposure to a OMSCS class. I would consider myself pretty well versed in C before the class and had some working knowledge of many operating systems mechanisms through using vendor OSs for embedded DSP chips which also lends itself to a decent understanding of computer architecture.

One of the best features of the class is the slack channel which one of the TAs has generously fronted the cost for. I saved myself many hours just by doing some cursory scanning of the issues that others were running into on their projects. The TAs that were active in the slack channel were generally helpful as well.

I feel overall the course was paced very well with ample time to do projects (assuming you don't procrastinate too much). Personally, I feel the exams aren't that great probably because they need to resort to a lot of multiple choice, true-false in order for the tests to be gradable. There was an extra credit project for up to 4% of your grade which was graded if you were near a grade border line. Overall, it seems that the curve is extremely generous (it's extremely easy to get a B).

Great class. I had taken an undergraduate course in Operating Systems years ago, and this blew it out of the water in terms of depth and breadth. You'll get to learn about some low level, classical OS material and get into more modern ideas supporting concurrency, virtualization and distributed systems. Some of the lectures are pretty dense, so you'll probably want to watch them in pieces rather than all at once. There were 3 projects and an extra credit project this semester, and they were all in C. If you don't know C already, this is where the bulk of your difficulty in the class will come from. Some of the code templates given used syntax and operators I'd never seen before, and this created a lot of difficulty for me. If you're well versed in C and navigating Linux man pages already, you're probably fine. Exams were tricky, but I didn't find them exceptionally hard despite their reputation. The course is curved, and the boundaries seemed pretty generous. If you mess up more than one project you can still walk away with a B if your exam scores are above average.

TAs are pretty responsive on Piazza, but don't rely on them to help you at the last minute - ask early and you should be good. Project grades take a long time to return, but this semester had an unusually high number of students so I kind of expected this going in. Make sure to pass Bonnie tests - they seem highly correlated with the end grade of your projects.

There was also a very active course Slack this semester where you can get fast help if the TAs are online. Professor Gavrilovska holds office hours every week (not just the TAs), so you can get help there too. I'd recommend this course early if you're looking into the Computing Systems specialization and need to brush up on low level OS material, but be warned - it's a deceptive amount of work. Definitely worth taking.

This was a great introduction to OS course. I have no background in C and I have never taken an OS course before. I tried to take this course over a year ago and ended up dropping it because I could not keep up. This time around I prepared a couple months in advance by reading through Learn C the hard way and completing all of the C courses on Lynda.

Use the class Slack channel. The TA's for this class are amazing and will always help you. They don't give you answers but they can point you down the right path. We had other students in the class with experience in some of the areas and they helped out in Piazza and in the Slack channel as well. Between the projects, TA's, and other students, there is a huge wealth of knowledge to gain in this class. Then add on the papers and lectures and its almost too much.

The TA's were very active on Piazza as well. The instructor held weekly office hours to answer any questions about the projects, lectures, papers, or tests.

Project 1 is really not that bad if you keep it simple, which is harder then it sounds when you're new to this subject. Its easy to over think the problem and create a mess but the project is really pretty straight forward. One of the main focuses of the project is multi threading.

Project 2 was extra credit for us. It had no programming but was a written assignment to design an experiment.

Project 3 was the toughest. It was a bit more free form in that you could design your program to work many different ways. Its best to plan this project out before you start programming it. I jumped right into programming and that was a mistake. I still did very well on the project but I could have saved myself many hours if i would have designed before programming. Shared memory and multi threading are some focuses here.

Project 4 was the easiest. Again its really straight forward but I can see it being another project that is easy to over think and make difficult for yourself. This one dealt with RPC and multi threading.

I found the mid term and final to be the most difficult part of the class. You have to read all of the papers and watch all of the lectures and really understand the material in order to do well on the exams.

I stayed within the class average for the mid term and did very very bad on the final. I got almost a 100 percent on the all the projects and did the extra credit. Walked away with a B in the class.

My background is 1 year as system tech, 3 years of COBOL on a mainframe and almost 2 years now in Java doing full stack.

I took this as a first course and was a little overwhelmed by the workload. The lectures are good, but the projects (especially project 1) can feel a little irrelevant to what's being covered in the lectures. My advice is to start the projects as soon as possible. Most of the learning comes from projects and preparation for the quizzes (midterm + final).

Excellent class, definitely one of my favorites so far! Projects were challenging and the exams were difficult, but I felt like I learned a ton. The TAs were great and very involved on Slack. Would definitely take again.

If you're thinking of taking this course:

1. Be comfortable coding in C
2. Start projects early -- they take a lot of time to complete!
3. Watch and rewatch all of the lectures

By far the best class I've taken so far. I don't have a CS undergrad but took C programming eons ago. TAs & prof are truly involved and vested in making this a great class. Exams are challenging and projects are like what all the other posters state. TAs on Slack were a huge help getting through the projects. Find yourself an IDE that you like. Extra credit opportunities. This class is one where you get out what you put in. I learned a ton and it was a really rewarding class. Definitely recommend! And definitely participate in their Slack channel!

I took this course with very little C programming experience. The first project had a significant learning curve for me in all aspects. The first two projects were 60+ hr of work each for me. I did well on the third because it was easier and also am more comfortable C. I'm guessing a student with a C programming background could complete the projects in a quarter the time I spent. It did take significant effort up front to understand the requirements of the projects. You can do this class without C in you skillset, but you will spend 10+ hours a week the first half of the course catching up on it because the projects require it. Working full time, tackling this course material, teaching myself C, and another class on top of that was not the best idea.

The professor, TAs, and Piazza/slack community were great in getting assistance with the projects and answering questions.

The lectures and reading material are well presented and organized. Due to my efforts catching up on C and taking another class, I did not get to dive into the material as much as I would have liked. One thing that I wish the class provided was more assignments related to the readings. Whether essay or simple quizzes, I think it would help students take more from this material to have it tested in more than just the two exams. Only half the readings relate at all to the projects. No textbook required, but you should have some OS programming reference material handy.

Overall very worthwhile course but A LOT of work if you don't know C!

semi-pro tip: Set up and get comfortable with an IDE ( I used VS code, many used CLion) the first week or prior to taking the class. You will need it!

Great class. I learned a lot from the projects and the lectures were clear and well planned. Definitely get started on the projects early and having some knowledge of C is a must. It's possible to learn C as you go, but your weekly workload will be substantially larger and honestly, you already have enough to learn in the class. I felt like the grading breakdown was fair, with ~50% projects and ~50% tests. There are extra credit opportunities. The professor and TA's are all very active on piazza and slack; probably one of the most active in the courses I have taken so far. This is great because questions get answered very quickly. There are 4 projects, with one of them being extra credit only. I would say all 3 projects require substantial time, with project 1 being the most work. Be prepared to spend at least 30-40 hours to do project 1 or project 2.

Great class. As someone who did not know C before taking it, some of the projects were BRUTAL. However I learned a ton, much of which is applicable to my work and any software development job.

Highly recommended if you feel like you have a gap in knowledge in what is happening under the hood when the code is running, what is really happening with threads and memory, etc. At the end they go into virtual machines, distributed computing and cloud computing which was really interesting too.

The class was extremely well run, the Professor and TA's were always available to assist and answer questions on Piazza. Even on Sundays sometimes!

I did not like how heavy the grading favors the tests - I spent 100+ hours on the projects and probably less than 10 studying for the exams, but the exams are weighted as 60% of grade. However this may be necessary because projects do not go into a lot of the information presented in the course. And apparently last semester the curve was such that a 55% gave you a B, so maybe it doesn't matter too much.

Great class and great introduction to the OMSCS program for me. I came in without much background in C and found the projects(especially the first one) to be hard. If you know C well then you won't have this problem. I spent a significant amount of time catching up on C. The class material was not that complicated. The instructor is very clear in her explanations and was present almost every week during office hours. One of the best things about this class was the slack channel and the TAs on there. They were very active as were the fellow students and it was fun discussing projects. The class is very well run and I highly recommend it to anyone. Ended up with an A.

This course was very challenging for me because I did not have any prior experience with C (despite all of the warnings). If you already know C, then you're probably fine and this might even be alright to take as a first course. I would definitely not recommend following the approach that I did though by thinking I could pick up C on the fly; as far as I can tell, I spent way more time on the projects than most of my peers, and most of that time I was way out in left field anyway. If you're still determined to take this course without knowing C first (hey I get it, I was stubborn too), then do yourself a favor and go pick up a copy of The Linux Programming Interface (I found one pretty cheap at a local used books store) right now, because it'll be your lifesaver for the first few projects.

That said, even though I really struggled with the programming assignments, I still really enjoyed the class and feel like I learned a lot from it. The lectures are great: clear and easy to follow; the professor actually does office hours every week and goes over some great and useful stuff; the TAs are super helpful (and a pretty funny and entertaining bunch on Slack!); and all-in-all the course was very well organized. I am definitely going to miss this class!

This was my first class in the program and I absolutely loved it. Coming into this I was hoping for a solid introduction to OMSCS, computer science, and C and I would say that it was very successful on all fronts. I’ve consolidated my thoughts / tips about the class below based on topic.

Projects

1. The project code always contains a base set of functionality which you enhance. PR1 for example gives you most of the code for a working C program, you just need to cover the business logic (creation/parsing of a GETFILE protocol message).
2. TA’s always provided the CMakelists file if you prefer to use CLion and that also makes things easier.
3. PR1 – GETFILE PROTOCOL
4. I had very little C experience before this and I was a bit scared coming into the first project. Consequently, I began PR1 as soon as I could and finished about two weeks early. I spent a lot of time in the beginning establishing best practices for how to do things. It forced me to work slowly and do a ton of research on various C aspects, but by PR3-4 I was very confident in my C ability.
5. PR2 – Extra credit research project
6. I went above and beyond and did the experiments, which was not required. It took me about 4 hours to complete.
7. PR3 – Shared memory-based IPC
8. This one was pretty easy for me. I completed it in about 6 hours total, including both parts.
9. PR4 – RPC
10. This program is basically PR1 and PR3 where RPC abstracts all of the communication. It’s pretty easy, but took me about 12 hours to complete because I stumbed on the MT section.

Knowing C

1. I was completely new to C coming into this and excited to get some exposure. The first project will force you to use strings. Working with strings in C can be challenging. If you're like me and eager to learn new lower level languages, this class is perfect for you.
2. The other thing that was pretty complicated was the implementation of a thread pool. You don't have to do it like this, but in terms of performance its the best way. Once you get a working thread pool implementation, you can use it for subsequent projects in the class.

Tests

1. Test 1 – 25% of your grade. I found it harder than the second exam. Median was a 76%.
2. Test 2 – 30% of your grade. IMO, it was easier than the first exam by a long shot.

TAs

1. Overall, the TAs were highly responsive, but very shame based. I suppose it’s an industry problem. The expectation is that you know the readme very well. Questions about well defined things on the readme or C related questions you can google will get you ridicule. Always try to find the answer on your own before you ask.

Tips

1. Use the study guide to study for the test. It seems obvious but, I studied everything I could get my hands on for the first test and felt like I made it much harder on myself. I found that other students were doing similar things. Since this is an introductory class, there are certain topics in which the rabbit hole goes deep. Make sure that you’re studying the material as it relates to GIOS.
2. I would strongly recommend using CLion. They make an IDE for every language used in the OMSCS program and its heavily used in the industry. I ended up installing this on my Ubuntu VM and using it from there.
3. There is a slack for this class and I would recommend it. The TA’s are very responsive.
4. I would recommend the environment setup they use. I tried doing PR1 on my mac and had all sorts of problems.
5. For debugging, there are a few tools which will make your life easier. I found these to be most helpful:
6. Telnet – must have for the first part to test your server before you finish the client
7. Wireshark – to confirm whether client or server is breaking
8. CLion debugger – self explanatory
9. There is always a performance metric component to the test. These are based on the readings assigned during the semester. Know those very well, it’s low hanging fruit on the exam.
10. Execution flows are a big part of this class. If you don't understand the math, I strongly recommend that you draw out the flow. The questions on the test are usually small enough that you can draw them out to achieve the answer. This is what I did for test 1 and 2 and it worked out well.
11. At the end of the class, they added a lot of material and I felt like the amount of time required increased per week. Take this into account after the midterm and stay on-top of your lectures.
12. Some of the last readings are unnecessary and very long. The RPC reading, for example, is unnecessary, dense, and 40 pages long. Since it was not present on the study guide, I skipped reading it altogether and it paid off.

Overall, this class was really well ran. Appreciated the active TA community and that Ada was present / hosted most of the office hours. The number one thing I would suggest (like many) is to start the projects early. I didn't do that for the second project and greatly regretted it.

The projects were my favorite part of class but also can be extremely time consuming, knowing C is very helpful and suggested on class pre-reqs. The tests weren't cumulative and were written fairly. But keep in mind the second half of class had considerably more content than the first.

Overall, great class and glad it was my first in the program.

This was a fantastic first course for me. I am an experienced software engineer with a few years of experience without a CS undergrad degree. OS concepts was something I wanted to learn out of OMSCS. This course provided a nice introduction to these concepts, at least to a point where I know where to look for for more information. It is not as detailed as a standard OS course at a top-tier school, though. For example, in my undergrad school, I know that CS majors had to actually write an OS from scratch as the project for this course. This course only requires us to use some of the OS features to implement some applications. This course covers a breadth of information in an easily ingestible way. But it does not go deep into any of the concepts.

Basic knowledge of programming is absolutely necessary. If pointer, references and SIGSEGVs scare you, this course is probably not for you. You don't need to be an expert in C, but you need to be comfortable developing small applications, and with basic debugging. Nothing you can't learn in ~1 week if you already know Java or another equivalent language.

The instructor, Ada, was fantastic. The lectures were very well made. Ada was available in Piazza to help out fellow students. The exams were great, the TAs were always prompt. All in al, a very well-organized course. I feel spoiled for future courses! :) Highly recommended!

I enjoyed the class! The course was well structured, and the professor explained things well. In the end, the grade was curved by a few points: I think an A grade was curved by 4 points but I don't exactly remember.

My second course in OMSCS. This was an extremely well run course. It's set my expectations very high for other classes. The professor was highly engaged on Piazza. The TAs were well organized and responsive. The projects overall were very good and well defined. I highly recommend this course.

Now to the disclaimer! The projects are hard, like, if you don't know C at all, you are going to really struggle. So be prepared. I have experience in C, although rusty. The harder projects took me 20+ hours probably. Get started early on the projects and be prepared to spend a lot of time. Having said that, I thoroughly enjoyed them.

The exams were the usual closed book format - not my favorite thing in any class. Cram before taking, and you'll be okay.

What an amazing course! I had a weak background in the topic and programming in C, so it was difficult for me. I spent quite a bit of time each week but I learned a ton.

The lectures are put together very well, and the professor and TA's are extremely engaging. Questions on Piazza are answered very quickly and there was a separate Slack group run by some of the TA's. When you get stuck, it feels like there is always help available.

The exams are difficult but fair. They mainly consist of thoughtful multiple choice or fill-in-the-blank calculations. The one downside is that the exams account for a very large portion of your final grade.

The projects were fun and they were run very well. The instructions are overall pretty clear and you are able to submit code to Bonnie for testing, so you have a good idea how well you did before it's even officially graded. There were extra credit opportunities for every project.

This course is thoughtfully designed and made for an excellent introduction to the program. I would recommend it to everyone.

First class in OMSCS with no academic CS background (though I have an undergrad engineering degree), no C experience, and 2+ years in professional web development.

This class is extremely well run and I commend Professor Ada and all of the TAs for their efforts to make Piazza and Slack as helpful as possible. The lecture content is somewhat dense at times but Ada does a great job of explaining concepts and I found her lectures extremely useful. There are two exams that are certainly tough but you only need to study the lecture material to do well on them. I'd recommend reading the assigned papers but the main concepts from them are also covered in lecture and I didn't bother to re-read them while studying for exams. This approach netted me above average scores on both exams which largely contributed to my A in the class.

There are three projects whose difficulty will depend on your familiarity with C. I came into the class with no C experience and definitely had my struggles on the first project, but I managed to power through it and felt far more comfortable for the rest of the class. Despite this I'd caution against taking this class with little/no C experience unless you consider yourself a strong programmer, otherwise you may be in for a rough ride. The first two projects are both difficult and time consuming and I would start them as early as possible because you are going to run into issues with C/Bonnie/etc along the way. If you manage to get through those you'll find that the last project takes significantly less time. The good news is that you have access to the autograder (Bonnie) for all projects so you generally know what grade you're going to get when you turn the project in. I put significant effort into the projects and got full points on all three, though I know students got docked minor points for poor READMEs and other small things.

Yes this class is hard and you're going to get frustrated during the projects, but your efforts will be rewarded by a solid foundation in operating systems and you will no longer fear C.

This is my first class in OMSCS so regarding difficulty I don't have enough info to determine, but it's not obviously "easy" especially if you don't know C in advance. But I could get A without knowing C before taking this class, so you don't need to be too scared unless you even haven't never done any coding.

The former half of lectures are really well tied to programming projects and I loved it. There are 3 projects and all required C programming. I expected this class is for OS internal and it is partly correct but it spends much time on concurrency problem (a process and a thread) while it is still very fun.

I felt the latter half of lectures are bit dry, and because we don't have hands-on experience on them (memory management, file structure, spin-lock, hardware related subjects, and memory sharing) through projects, it was bit difficult for me to understand and absorb all of what I was taught.

20 hrs / week is just average and I always tried to complete a project as soon as possible, so after a project is open, I spent 70-80 hrs / week and after I completed it, I go back to lectures and spent 10-15 hrs /week. I recommend the same way if you don't want to be upset at the last moment...

Exams were not so easy, you should expect they are more complicated than sample problems. However they kindly offer a check list you should review before each exam, so by checking all of them, going through all quiz on lectures and sample problems, I think you can be ready for tests.

And if you want A, you should definitely try to get all extra credits. This class offers a lot of extra points. I'd recommend visit the Slack channel if you get stuck on projects. TAs are more responsive on Slack.

Great class, I didn't have much experience with C besides a Data Structures class in undergrad (15 years ago), but I still remembered how pointers worked. Projects didn't take much time to me, but I'm a somewhat experienced programmer.

Top notch lectures, although I love the fact that there exists a transcription with screen captures for all of them.

Great class, took it my first semester in. The class for the most part is very well ran. The lectures are great, and the TAs are very active and helpful. An example of how well the class ran is that It took me less then thirty minutes to get the development environment up and running. Having Bonnie pretty much grade everything is also amazing. The TAs are basically grading that you followed the guidelines more so then actually pass/fail the projects.

The lecture material was good a lot of subjects that were covered was not covered in my undergrad OS class. They were very well organized. Sometimes I feel as the quiz math is a little hand wavy but I think that's more of the approach on watching the lectures then the quality of the lectures.

The projects itself can be difficult. There are about about a month in between projects, Slack/Piazza are very helpful even if the TAs are not around. As everyone says start on the projects early, I program only in C at work, and it's also this flavor of programming style and I had some issues, I can see how other students can spend lots of time on the projects.

The exams are very hard, and in our semester there has been some mishaps with the questions, and even some answer choices.

Overall though the class is great and is very well curved. In my mind it's almost impossible to make anything lower then a B.

This course was FANTASTIC. Recommended to anyone. You will need to get familiar with C for the projects and overall understanding.

Projects were great. I honestly thought they were amazing experience into the world of multithreaded programming and really getting a good handle on C, and they complimented the lectures really well. I have never really wanted to hang out for a weekend, drink a beer, and do a homework project until this course. They will take some time though, so allocate time accordingly.

Tests were tough, but fair. Make sure you read the papers and the lectures, and study hard.

Professor is great. TAs were responsive and helpful. The lectures are packed and engaging and you are tested mainly on the content of those and the research papers. The projects were rough for me and it took me a very long time to get through them. I think the reason for this is that I come from a scripting language background. I spent a lot of time floundering with C, but the TAs and other students are helpful. The projects themselves are well defined, interesting, and fun. I learned a whole lot form this class and I recommend to anyone who is at least somewhat familiar with the basics of computer architecture. If you, like me, are not practiced in C, start the first assignment as soon as possible to see if this class is doable. I read "The C programming Language" as preparation for this course. It was not enough. The better your understanding of C, the fewer late nights you will have and the more you will enjoy this well organized, well communicated, interesting course.

There were a lot of great things about this course and a few things that could use improvement. The great things are the lectures are engaging, the assignments are relevant to industry, and the course staff was engaging on Slack and Piazza. The things needing improvement I felt were the assignment count and one or two questions on the exams. The first assignment and the third assignment were both rather difficult so you want to get a start on those as soon as you can. The fourth assignment was not as difficult so that was a great time to take advantage of the extra credit in the class. If you bomb the hard half of project 3 like I did, you're going to have a hard time bringing up your grade for the remainder of the course due to the lack of assignments .That's unfortunately enough to sink you with assignment 2 gone. However, with the curve, its still rather attainable to get a B (I received a B). The exams were rather difficult and tricky. Most of the questions were fine. I felt that one or two of the questions were cheap shots (obscure details in papers that aren't immediately obviously applicable to industry /historical ). I went over the videos over and over again but honestly still didnt do very well here. Definitely focus on understanding the details in the assigned papers and don't put the papers off until after the assignments were due like I did (this was a mistake). All in all, this course wasn't that bad from a difficulty perspective for being a systems course. It'd probably be a good fit as a foundational class for you.

Overall a great class and a must take for the first semester. As all great things it did have its ups and downs.

In this class you will learn about: processes and process management, threads and concurrency, scheduling, memory management, inter process communication and various sync constructs, i/o, virtualization, remote procedure calls, distributed file systems, distributed shared memory, and some datacenter technologies.

You will get to implement a multithreaded getfile client/server, proxy, cache, and play with an RPC (this semester's was Sun's RPC) think how awesome all of these would look on your resume, also you'll be able to answer all of the AOS prereg question list https://www.omscs.gatech.edu/sites/default/files/images/cs6210_diagnostic-preparedness-test.pdf. If your goal is to eventually take AOS, HPC, HPCA then this class would get you in great shape for them.

The lectures are great and require no outside readings to understand the material, professor Ada was very active on Piazza and held office hours regularly, and the TA's were friendly and very responsive on both Piazza and Slack.

The tricky part of the class were the exams, particularly the final which had more material than the midterm on it. So I suggest you study hard for it. There are some (few) papers to read through, but you can get through these fairly easy as there's few and concise.

KEY to this class is to make sure you start the projects on time, the first project in particular is trickier than the others. The more time you spend on it and the better you do on this first project will be worth it in the long run. For each of the projects you have about 1 month to complete which is more than enough. I didn't do as good on this first project, because I started it very late, but managed to do good on the last two. So even if you don't do as good on the first one don't fret, you can still do great in the class!

Some C will be good to know coming in, but I think that if you work hard you can pull it off with minimal knowledge, you just need to attack that first project really hard. If you're familiar with pointers, double pointers, function pointers, and using typedef and structs, then you're golden. If not then take the Lynda.com C classes (comes free for students) or grab the K&R C book and go through it (there's also a k&r c solutions book that can be bought for the solutions for the exercises) you can get those for under 20$ if you look hard enough, but just understanding the aforementioned will be enough and wouldn't take more than a few days of stack overflowing and testing on your own to get.

Make sure you're on Slack since Day 1, you can learn a lot about the projects and get hints on them by lurking in the channels. This semester we had a PAID Slack workspace thanks to one of the TA's, how cool is that? To top it all this semester there were some pretty funny characters on it which made lurking enjoyable, however there's always the usual troll tho in there, but hey it's still a great resource.

TL;DR: Just go for it; great class, doable/rewarding projects, friendly/active TA's, very active instructor, very C, such Threads, many Science, WOW.

Great course overall. Videos are structured very well. TA's very responsive and helpful. First project was fairly hard. I think it was the learning curve for C and OS-style programming. Slack channel was very active!

First, Professor Gavrilovska organized this course in a very straightforward and thorough way. I don't think it could be better presented, given the scope of the material. The class was a good introduction to a lot of OS concepts, and gave a decent survey of more modern concepts that many would consider to be application or domain-specific (e.g. data centers). The material was lopsided in that the final part of the semester was much more in-depth than the beginning, and hence the final exam had many more pain-points of memorization than the midterm. The projects were very illustrative of the concepts (I wish we'd had project 2, whatever that was) and didn't fall into the trap of being application-specific. Strongly recommend C programming background, familiarization with GDB, and (probably) a solid understanding of the Linux filesystem and make paradigm. As mentioned in other reviews, beware the details on the exams, and try your best to memorize graphs and charts as presented (they ended up being around 15-20% of the grade on the exams and are NOT re-presented as graphics during the exams).

I found this course to be a good introduction to operating systems, especially having never taken an OS course before. Since this is now my 9th course in OMSCS I've certainly run the gamut in terms of quality of courses. That being said, I'd say IOS is one of the better ones (my favourite and best being KBAI) for the following reasons:

• The video lectures are well organized, the concepts are explained clearly, and quizzes are thoughtful and helpful in reinforcing topics.
• Instructor and TA involvement was exceptional in Piazza. They fostered a collaborative learning environment which helped bring learning above and beyond just the video lectures
• The projects were helpful and fun to do. As rusty as I am in C, the projects were a nice refresher and departure from my usual day-to-day work in higher level languages. If you start early on the projects and get involved with class discussions, there's no reason you shouldn't succeed on the projects. There are also plenty of extra credit opportunities that weren't hard to complete and ended up saving my grade.

My concerns with this class:

• Exams: although mostly straightforward, they were tricky and sometimes required remembering one small lecture detail. The midterm and final exam weren't evenly split over lecture material with the final covering significantly more lectures. In this regard, I highly suggest that you keep pace with the class syllabus.
• Grades: We received our project 1 and midterm grades back fairly quickly, but didn't get project 3 grades (which was due in the middle of the semester) until nearly after the final. Not having a good pulse on your grade was mildly frustrating.
• Bonnie: Project submissions are handled through Udacity's testing framework, Bonnie, which had a few hiccups throughout the semester which were eventually resolved. I did like the instant feedback it provided.

How to succeed and other advice:

• Keep up to pace with lectures, projects, and reading material. With regards to the reading material especially towards the final, I found that just focusing on the papers that were discussed in lecture were most important. There were some lengthier papers that, although interesting, contained far more detail and concepts than the class exams or projects required.
• I bought the Silberschatz Operating Systems Concepts textbook but only cracked it open once or twice because the lecture material was complete in itself and Piazza was an excellent supplement for answering questions. I regret buying the textbook, but YMMV.
• Invest time in setting up and understanding your C development environment. It will save you time in the long run when you're trying to debug a segfault. Use an IDE like CLion (free for students). It helps highlight syntax errors that you could otherwise miss. Learn the basics of vagrant (virtual machine), valgrind (memory leak checker), and gdb (C debugger).

Overall I'd rate this course an 9/10 and would highly recommend it. It wasn't part of my specialization, but I'm happy to have taken it because it rounded out my understanding of basic CS concepts.

First the good points. Professor Gavrilovska does a good job in lecturing the content. The examples are nice and she brings in some new topics relevant to the modern world (VM, Data Center technology, etc). Generally the course content was a rehash of the undergrad concepts and some new ones. Well balanced and I liked it. The TAs were generally responding, not amazing but good. The negative was the C projects. Whoever says whatever, you need good C and a nice understanding of pointers. I spent very long hours debugging code which I felt was not necessary for the course. I did not learning anything about the OS. I learned about advanced C Programming (which I am not sure was necessary as part of this course). The other thing I felt very arbitrary was the extra points for the project work. The instructions were not clear on what exactly would earn us the extra points. TAs used discretion which did not sit well with me (but again this is my opinion). The final exam was difficult but I was more disappointed with the quality. Some of the questions were ambiguous and not well laid out. I think Professor gave extra points for those questions. Will I recommend the course? Absolutely.

This was one of my first classes and I went in with 0 experience with C. The concepts were well explained and I picked up on them quickly but the projects were absolutely the most painful projects still to this day. At the end of each project I could look back and it wasn't an unreasonable amount of work but I struggled at every step. I think the first project was creating a socket messaging app and not even understanding how strings and pointers work in C it was a big jump. All in all I'm glad I took the course and I learned a lot but if I went back I definitely wouldn't have enrolled without an intermediate understanding of C.

Project 2 was not included in fall 2017's syllabus. The other three projects had a steep time commitment and required knowledge in network programming and C. I probably spent 100+ hours on project 1, about 50+ hours on project 3, and about 20 hours on project 4. The two exams are proctored, tricky, and are worth more than half your grade. Most students did well on the projects but suffered severely on the exams due to the tricky questions. The class is curved, which makes up for the exams, but it would be better to reduce the trickiness of the exams and make the questions more straight forward so a curve wouldn't be so necessary.

Took this course as my first course in the program, and it was a great choice. It is a very well organized and well run course, and I learned a lot. I came into the program with no CS background, minimal programming background, and zero experience with C, so the first few weeks of the class I was working probably 30-40 hours/week on the project, but it was manageable as I had few other commitments at the time.

If you can get past the first project you're definitely over the hump, the other projects were a bit easier. The course is also fairly generously curved, I ended up getting an A when I thought I was solidly in the B range. Overall, I would highly recommend this course as it is well run by both the professor and the TAs, and you learn a lot.

Ten weeks into the semester, I've spent 125 hours on IOS. Six of that was initially setting up the development environment (mostly because I had a new and unfamiliar hardware setup), 70 on the projects, 23 on Piazza, Slack, etc., and 26 hours watching video lectures. (I log my hours with Toggl. ) It turns out that I have a pretty good background for the coursework we've done so far (concurrency and IPC mechanisms). The next 5 weeks may prove to be a bit harder for me.

The TAs have been very engaged, and there's a lot of healthy discussion on Piazza and the OMSCS6200. slack. com channel, which has been fun. (That explains why I've spent 23 hours on it. ) The prof (Dr. Ada Gavrilovska Habl) has been very fair, and is an excellent lecturer. This is my first semester, so I don't have a basis for comparison, but I'm very pleased with this course, and I recommend it.

Projects are individual and have been well-designed. Development is in C, which is entirely appropriate for an OS course. If you only know a scripting language such as JavaScript, R, or Python, you might want to hit the first project hard, right away, to climb that learning curve.

Fantastically done class! The lectures were great - they used a very accessible metaphor (consistent through the whole class) to explain the different problems to be solved by the OS, and the different roles that OS components would fulfill.

The projects were challenging, but were presented with just enough guidance to be manageable. Each assignment used Bonnie for autograding, which was exposed to the students and was invaluable during testing. It makes an assignment much less stressful when you have a live view of your grade, before you submit the assignment!

This is a good course for those who wanted to know about kernel, thread, memory allocations. The first project is very frustrating because not only you need a solid knowledge in C programming (like pointer) but you also need to memorize and understand the syntax. (missing asterisk, mismatch variables). The project feels like a quest to debug rather than learning and building. I finished C programming from Lynda but still at lost. Ended up dropping the class. Probably worth mentioning that the professor is moving the pointers a lot in the videos which is very distracting when you're trying to see the content.

Ada and the TA's were awesome. Only complaint was Project 2 was a little more difficult due to confusing instructions than it needed to be. Material was useful and projects were at the appropriate challenging level. The use of an auto-grader that was exposed to the students meant students could learn from their mistakes and make correctly functioning code. You WILL have to program in the C language.

I saw many posts recommending familiarity with C prior to starting this course, but I don't think this level of caution is warranted. I think this course could serve as a good introduction to C as well as operating system fundamentals, and it's not that hard to get an A despite not having experience with C. My background - technical undergraduate degree (non-CS, a little programming), web developer for 3 years using higher-level languages, and read 'The C Programming Language' as I was starting the course. Experience with the course - this course requires a decent time commitment, both for projects and for keeping up with lectures. Most weeks had 3-4 hours of video for lectures, and I worked steadily on projects every week, making sure I kept up with recommended benchmarks so I didn't fall behind. Not being familiar with C meant that I did a decent amount of googling for basics (and referring back to my book), and I also requested help [moderately] often from the slack channel. However, most of my problems were not strictly due to lack of language familiarity (the homeworks do not demand anything that complicated in terms of C) - more often I was confused about the concepts or made silly mistakes due to lack of confidence. The TA's are extremely helpful and responsive, and other students were helpful too. I believe there was also an introduction to C office hour held at the beginning of the course (but I did not attend).

I have an undergrad CS degree so based on the topic outline in the course description, the class did not seem like anything new. I took this class thinking it would be an easy summer class. For me personally, it required a lot more work than I anticipated especially on the project side (programming side). Might be just me, but I felt like the test were trickier, basically not doing as well on the test as I thought I did when I took the test. Make sure you know C or have done some C programming before you take this class, there are MANY people who drop out during the first project just for this reason of thinking they will learn on the fly and are not able to keep up. From the perspective of someone with a undergrad CS degree (obviously this will vary based on your undergrad CS program rigor) everything up to about a little after mid term I already had familiarity with or forgot (Obviously the class went in greater depth of the topics I already covered in undergrad so I learn't new stuff here and there in the first half of the content). On the second part of the semester is where It covers virtualization and distributed systems, RPC and was where I really saw new content for me personally. If I took this during the longer semester I probably would have rated this class a medium difficultly based on my background.

Like I said prior, unless you are pretty good in C, the projects will consume A LOT of your time and the test seemed tricky or maybe for the summer I was just a bad test taker.. Luckily I got the grade I needed and probably deserved. I would recommend this class to anyone wanting to build their OS fundamental and/or C or system programming knowledge.

Projects are interesting but not very difficult.. Exams are tricky..

Great course... appropriate breadth and depth for this topic. Instructor is excellent, and the TAs did a good job as well. Like most OS courses, it's based on the "C" language so students would be well advised to refresh their existing skills or acquire a solid fundamental familiarity (e. g., syntax, pointers, etc. ) in advance because you will be using them right from the start of the first project assignment. The course will build upon them and explore subjects such as the various forms of IPC, concurrency, etc.

This course covers a vast set of topics in a short amount of time. The projects are narrow in focus however. Although the lectures are excellent, I felt that the course would have been more effective if the course creators focused more on depth rather than breadth. Perhaps assign more projects, get rid of the midterm, and replace about 40% of the lectures with more in depth information about the other 60%. Also grading of the projects is extremely slow. Grades for two of the 3 projects are unknown even after taking the final.

this class requires a firm knowledge of C. If you haven't use or remember C this class is difficult. Only recommend if you know C.

This was my first course in OMSCS and it was absolutely brilliant. It set the bar incredibly high for what online classes should be.

This course should be required to graduate. The workload was very manageable and the lectures very interesting. I had been writing file systems for about 4 years when I took this class and I managed to learn a worthwhile amount.

If you have a background in C, take it, take it, take it. Enough said. If you don't, you'll probably struggle.

Great course! I'm not sure I'd recommend it to someone with no C background, but if you do have it - go for it!

The 1st, 3rd, and 4th projects in this course are excellent. The 2nd project is an incomprehensible and poorly-designed quiz in T-Square that needs to be scrapped.

The lectures are taught at lightening speed, though they tend to be relatively sufficient for teaching the material. I'd suggest slowing down some of the more critical lectures or providing more examples.

Overall this course was a pretty good one, and though I came in relatively knowledgeable about the material I still learned quite a bit.

A good course to start the program with, I enjoyed the class a lot more than I expected. The lectures were good and the projects taught the concepts well. I enjoyed it and learned a lot.

This class is a decent way to start your OMSCS career. It is a good refresher course that will dive into topics like mutexes, semaphores, shared memory concepts and other IPCs. The projects were interesting and the use of automatic testing helped make sure all requirements of the project were met. The only disappointment I had was Project 2 was a take home quiz that I would have preferred the original project that others took in the past. Overall, I highly recommend this class as Ada and the other TA's were awesome and the lectures were fairly engaging and easy to follow along.

I took this class my first semester in the program, alongside networks (6250). I almost feel like I shouldn't review this -- I didn't take advantage of the resources it offered. The instructor and TAs all seemed great and response time to questions and concerns was near immediate. But I acted like they didn't exist except the few times I had a specific question, and I suspect my learning suffered for it.

The lectures comprise the bulk of the learning material, along with journal articles assigned for most lectures. Most of those aren't too difficult, skewing towards older and easier to digest articles. Ada's a great lecturer and I have few complaints about the quality of the lessons. The recurring "toyshop" metaphor felt like a gimmick and wasn't particularly edifying, however. Some of the topics chosen were a little mysterious -- it's unclear to me how remote procedure calls, for example, are a good topic for an OS fundamentals class.

You'll spend most of your time on the projects. If you know any C at all they shouldn't be too difficult... though through a combination of poor planning and lapses in intelligence I couldn't figure out the synchronization necessary for Project 3 and received an extremely low score. Avoid my mistakes and start early. Each of those projects should be an easy A, if you're careful with your time and ask for help.

The tests, on the other hand... There are two and they jointly account for 55% of the grade. They are also pretty tricky IMO, so take 'em seriously. Also make sure you understand and can work out the problems from the lecture quizzes that need to be done by hand, some of those will surely come up.

All told I'm glad I took the class. I'll likely get a B, but if I'd applied myself a little better an A would have been achievable. More importantly, I've grasped the fundamentals well enough to have a base for continued learning. Edit: ended up with an A. My course grade was ~81, to give some idea of curve generosity.

WORKLOAD: This class consists of lecture videos, two exams (midterm+final), one "quiz"-type project, and three C-programming projects. The programming projects are based on 1) socket programming, general C, and multithreading, 2) IPC, and 3) RPC. The first two projects were sizable endeavors, and the third was much less intense. I had very little general programming experience (no industry experience, some C++ in undergrad, and some Python scripting). The first two projects took me about 50-80 hours each, I'd wager.

TESTS: There is no required text for this course, and all you get for material are lecture videos and papers. So studying for tests consisted of watching videos over and over for me. The tests themselves are kind of vague, but they are achievable, and you will learn a lot studying for them, but I would like to see more concrete test questions with less subjectivity. One "project" was a take-home quiz, where you decide on test parameters for some fictitious experiments. This one was super vague, and I would have much rather actual ran experiments and written a paper.

LECTURES: I don't know if this is true about all OMSCS videos, but she waves her hand a lot in front of the screen, which causes the text to be projected on her hand. Not a big deal, but I found this distracting. I ended up watching the lecture videos over and over, because that seemed to be the best way to pass the tests. Would rather have been pointed to more reading.

OVERALL: My first course in OMSCS. I think this class was great and was not too hard, even without much programming or OS experience coming in. You'll learn parallel programming, scheduling, file systems, memory management, IPC, Linux, systems programming, etc. You touch on some concrete Linux examples but I would have liked more.

You need to know C. Don't fool yourself thinking you can learn it in the first few weeks as may be suggested by the materials. If you don't understand pointers, referencing, dereferencing, data structures, etc you'll be in for a very rough ride. I 'thought' I knew C from my experience with Arudino work, but boy did I really have to play catch-up. Had I not had the Arduino experience before hand, I would likely have dropped. (A lot of people drop in the first two weeks due to poor C skills. Repeat you must already have some C experience !!)

The lectures are good and Ada know's her shit and does a good job of teaching it. I had almost no knowledge of how operating systems really worked until I took this class and now I have a much, much better understanding. I was taking this class just to fill electives, but it's one of those classes where I was surprised how much I learned (and how much I didn't know). I'm not planning on writing kernel software anytime soon, but the understanding you get from the class definitely helps even if what you mostly do is front or backend web dev stuff.

As with most other of the challenging course, start the assignments early. The forums move quickly, so if you fall behind your classmates on the programming schedule, your "I'm just starting part A" questions will get a lot less attention if everybody else has already moved on to Part C. If you stay up or ahead of the assignments, then the forums will greatly assist you. (My C got a lot better because I was able to stay in the general flow of the class. Had I fallen behind, I don't know that I would have made it. )

Some of the later assignment build off of earlier ones, so design flaws can catch up with you later in the game. You're given very broad scope to design however you like and grading is through an API. I had a design flaw that I didn't understand that bit me on the last assignment in the extra credit sections. Nonetheless I got an A.

Really enjoyed this course. Had very little C experience going in, so I had to learn it on the fly. Not a huge deal, but someone with more C experience would find it easier. The autograder was a complete pain in the ass. But it was very rewarding when you finally got your code to pass. Some of the later stuff wasn't as interesting to me and we didn't have projects that covered it. Overall, I highly recommend this course for people that haven't taken an OS course or are looking for a refresher.

Professor Gavriloska is exceptional. She is dedicated to her students and making the course smooth and well organized.

Ada is wonderful. You will want to be good with C programming to do well on the projects, and you should be okay as long as you have that. Linux experience is good too.

Projects were not terribly difficult. Built a good knowledge base on OS in this course. Definitely brush up on C skills. I program in C professionally, but many students really seemed to struggle with it. Once you're passed that hurdle the projects get much easier I would think. All in all pretty good course

This course was great. I had an uphill battle from the start not knowing C, but was able to learn it on the fly and complete all of the projects. The projects are challenging, but certainly not impossible. The TAs and the rest of the class are very active on Slack and Piazza. You almost always have someone to talk through problems, even very late at night.

I feel like I learned the most from the projects. This is definitely a class where you'll have to dedicate some time to, but if you haven't taken an OS class or it's been a while, this is a great one to go through.

Great way to start OMSCS! This was my first course in the program and I really liked it! You will learn about foundations in Operating Systems, some abstractions and work hard on programming assignments! To me the best part was actually the programming projects, where you will learn how to code in C using a Linux VM. I've never worked with C professionally, just a few semesters on my undergrad. As a professional Java developer working for quite time, I found the projects hard but really interesting to do. If you are a developer you will find your way. It took me the first project me to adapt to the "C" style. Used and abused of logs in my code. Never used a debugger in this class... Projects 1, 3 and 4 are about writing some programs in C. 2 Is about a performance evaluation. Professor Ada and TA as awesome! They are there to make you succeed! So if you work hard you will get there... A few things to improve:

• Project 2 descriptions are ambiguous. Although its meant to be straightforward, the way the questions / possible answers are written were confusing.
• I found exams to be overvalued. 55% for 2 exams are too much compared to the project's workload. Overall I learned a lot enough to improve my developer experience. Totally recommended.

This was my first OMSCS class, and I really enjoyed it. I have a lot of experience with C/C++ and Windows internals. Overall, IOS was a great class for learning more about Linux OS internals, developing against a Linux VM, and getting familiar with the whole OMSCS process. I’ve been out of school since 1995, so this was a nice way to ease back into academics.

The course grade was 25% midterm, 30% final, 40% projects, and 5% Piazza participation. The midterm covers the first 3/8th of the lectures, and the final covers the last 5/8th. Both tests used lots of multiple choice questions with multiple correct answers to be selected. Overall, the tests were tough but fair. I really liked the coding projects (P1, P3, P4), and project 2 was an interesting experiment. Dr. Ada and the TAs were great overall, and the autograders for the coding projects were very good.

Over the 16 weeks of the course I spent the following hours per week: 16, 27, 19, 5, 9, 14, 12, 11, 28, 11, 14, 7, 16, 0, 17, 12. That’s 218 hours, averaging 13. 6 hr/wk. I stayed ahead, read all the referenced papers (14), and did some additional research. The weeks where I put in 27 and 28 hours were when projects 1 and 3 were first assigned.

I’m only taking one OMSCS course at a time due to family and work commitments, and this was a great first course. I got an A without the curve. My only complaint was that we didn’t get grades for projects 3 and 4 until after the final was over. So, for most of the course, you have to guess how you’re doing based on whether your projects passed all the autograder tests. But when you’re only paying $500 for a course, you have to give up something, which in this case was quick grading feedback from TAs who are also GT students.

This was my first semester, and I took this class along with another course. I took this class in order to strengthen my understanding of OS's, as I wanted to improve my grasp on fundamental CS concepts. Professor Ada and the TA's were amazing and responsive. Since this was my first semester, this class has set a high bar for my courses as it was very well organized and lectures were quite clear.

Assignments were very helpful in deeply understanding some of the OS concepts we covered. Two of them were time-consuming, and I learned very quickly that I needed to start early in order to succeed. That said, it really helps to be familiar with C before the class; I think a lot of people will agree that one of the reasons why the first assignment is so tough is that many people are learning C in the process of doing that assignment.

The exams (midterm and final) are tough and cover a wide range of concepts, some of which can get very dense. So again, it is best to start very early when studying for the tests -- do not cram!

This class was definitely challenging but certainly worthwhile. Grading was tough but fair, and you are set to succeed if you put in the effort, even if you make mistakes along the way. It was intense at times and sometimes stressful, but so worth it. Would highly recommend!

Though this course has a lot of assigments in C, the best part of this course is getting to read all the seminal papers, that pretty much introduced what is mainstream in most of the operating system. Exams and assignments were well managed.

Context: I have no CS degree, but some previous classes with C++. This was my 1st OMSCS course.

I feel that this course is a great introduction to the program. It is well designed and executed, touching on a variety of very fundamental CS concepts that are relevant to many other courses in the program. The instructors and TAs were readily available and concerned with students learning the material and being able to make it through. The lectures and papers covered a lot of material, particularly after the midterm, so it pays to stick to the schedule even when there are no firm deadlines. Two of the four projects (1st and 3rd) can be quite time-consuming, particularly if you aren't strong in C. I found the grading to be fairly lenient on the assignments. About 2/3 of the material happens after the midterm, making the final challenging. There were several extra credit opportunities, and the instructor indicated that there would be a fairly healthy curve on the final grades, so there is room to make mistakes and still get an A.

The one weak spot of the course, in my mind, was the second project, which seems to have evolved over time, but is still hanging onto an accompanying Udacity sandbox that is irrelevant, at best, or misleading, at worst. The grading for this one also struck me as strange. I see the point(s) that the project was trying to convey, but think that it could be accomplished better in a different format.

Overall: This was my first class in the OMSCS program. Assignments are challenging but overall fun. Lectures are well prepared and easily understood. Had a hard time to understand questions in quizzes and exams, which led to anxiety throughout the semester.

Lectures: Very easy to understand and instructive. I learned a lot in this class. Definitely worth all the time you need to put in.

Projects: This course is a lot better if you have a C/C++ background. In particular, you will need to understand how to allocate memory and pointers in general (i. e. pass-by-reference, etc. ). That being said, this class had the most challenging-but-fun projects that I have ever seen. You get to work with Linux at a very low-level. You also get lots of feedback and general help from the TAs so the projects should definitely help you get a good grade.

Exams and quizzes: I had a hard time understanding the questions and didn't do well overall. I had a lot of anxiety during the semester because I thought I would fail the class. In the end, I got a good grade so it's definitely doable.

Overall: I think this course should be mandatory for those of us without a CS bachelor's degree. I learned a ton about how computers actually work, and even though I am a front-end Javascript developer, a lot of the stuff I learned somehow kept coming up at work. Now that I've finally finished, I really want to go back over everything to solidify my knowledge. I would recommend this course to everyone, regardless of specialization.

Prerequisites: I wish I had spent more time preparing for this course by learning C better, and doing the 'C for programmers' course on Udacity. I'd also recommend going through the free online book 'OS: Three Easy Steps' (it's pretty short, and there are exercises that go along with it). If you do this, I think you'll get a lot more out of the course.

Lectures: With a couple of exceptions, the videos are good but can be pretty abstract. The most enjoyable lectures were the ones that tied into the projects very obviously. You can get away with only watching the videos, but for a fuller understanding you will need to read the recommended textbooks and do a fair bit of googling.

Projects (40% of your grade): I found the first project very difficult indeed, and I think this is one of the reasons why this class has such a high dropout percentage. However, if you can mash your way through project 1, then you should be able to get to the end of the course with a good grade, as projects 2 and 4 are much easier. Project 3 required a few late nights too, but at this point you should be better at C. Start early on P1 and P3, and do not underestimate them.

Exams (55% of your grade): The two exams (midterm and final) are short, and while I found the midterm relatively easy, the final exam covered a lot more material and was acknowledged by most of us to be pretty difficult. If you follow along with the recommended schedule (which I didn't), you should be fine.

Slack/Piazza (5% of your grade): Very active/helpful TAs and professor.

Lectures - great content. Ada communicates all the concepts clearly and at a sufficient level of detail. Lots of quizzes built into lectures that actually solidify your knowledge retention. I learned so much, and covered so much breadth as well. Projects - I really enjoyed these as well. It is all C programming and I've never done C, so there was some growing pains in the beginning. I recommend you at least take some intro to c course, and definitely review c strings (and what the str* functions do vs mem* functions), and pointer management, and the difference between c strings and buffers. Those were the gotchas that seemed to get majority of the Piazza posts. Exams - These were pretty difficult. A lot of gotcha questions as well. You could know the concepts yet still do poorly on the exam. Also the midterm only covered a small portion of the material.... and that left the majority of the material for the final. And that was a lot to study!

Now the best thing about this class was actually the unofficial slack channel. The TAs hung out on there and were so active, always responding to questions, carrying on discussion of concepts... I do wish I run into more classes with TAs like these.

The worst thing is the amount of people that thought they could get away with cheating in this class. The TAs here spend considerable effort at discovering and pursuing cheaters, on both projects and exams. They take this issue very seriously and managed to catch many. It's unfortunate that so much of their time and effort had to go into something that shouldn't happen, instead of on grading and improving projects. Be a considerate person, don't cheat.

Intro to OS is both a challenging and rewarding course

The assignments all require some research to complete, and they require a good understanding of how C works, most notably pointers, strings, and structs. Even though the assignments were all challenging, the TAs and other students were all very active and helpful on slack and piazza. You can submit the projects as many times as you would like before the deadline, and there are automated tests written for each project that give you immediate feedback on each submission. The projects deal with topics such as synchronization, multithreading, remote procedure calls, and different forms of interprocess communication. There are also often a few extra credit points you can get on most assignments, but usually you need to be to complete the main part of the project before attempting the extra credit.

There are only two exams: the midterm and the final, and they both cover a lot of material and are worth a pretty large percentage of your grade. Even if you remember all of the material, you have to be able to understand it and apply it in new ways on the exam. The questions are either multiple choice, check all that apply, or fill in the blank. I recommend taking thorough notes while watching the lectures to prepare and asking questions on slack or piazza when you need clarification.

To succeed in this course, I recommend not procrastinating, especially on projects 1 and 3, and once again taking good notes on the lecture material. Stay active on slack and piazza. Also, it is helpful to get some practice with C before starting.

Coming into the course I had about 4 years of professional development experience, mostly in C# and Python, but also some experience in C in undergrad and some professionally (programming micro-controllers). I don't have a CS degree so had never taken an OS course. This was also my first course in the program.

The class is extremely well run. The TAs are very active and helpful, and both Piazza and Slack are active and great resources. The lectures are thorough, well done, interesting, and generally translate well to the material needed for the exams. The projects (with the possible exception of project 2) are well done and very helpful to understanding concepts.

The style of the exams was multiple-guess and fill in the blank, timed, proctored (ProctorTrack), taken through T-Square. The questions needed some improvement, though. Some of the questions are a bit nit-picky, and some are written in such a way that I spent more time debating the intent of the question than figuring out the answer.

As for workload, the projects consumed most of the time I spent on the course. When I was working on a project I might spend 20+ hours a week on the class. Otherwise it was less than 10. To be successful on the projects I'd recommend starting early, being comfortable writing C in a Linux environment, using the command line, and debugging with GDB.

Last, don't cheat. One of the TAs mentioned that they caught something like 10% of our class cheating on the projects. That's ridiculous. Start early, keep at it, and hit the Slack channel when you get stuck. You can survive a bad grade on a project but a course F due to cheating might end your time in the program. Don't be dumb.

Overall, the class covered a lot of content and the instructor (Ada) and TAs did an excellent job working with the students to learn the content. For me, it was a great refresher in both OS concepts and C programming. The class does take quite a bit of time; the lectures are long and the projects are involved.

The curve on this class (at least when I took it) was quite generous. For those who are concerned about the amount of time the class consumes, those times are mostly based on students satisfying all project requirements, studying to do well on the exams, and completing the extra credit. If the curve is consistent from semester to semester, you can probably cut quite a few corners and still get an 'A'; if you are only shooting for a 'B' you can do even less (do so at your own risk!).

Note: The structure of this class is learn about an abstract OS concept and then develop an application that uses that linux implementation of that OS concept. For example: learn about threading -> implement a program that uses linux pthreads. This is not a class where you have to implement the OS construct (I think that is reserved for AOS).

Before coming into the course, I had 10+ years of experience in developing C and C++ based distributed networking applications that used IPCs such as Sockets in a big way. Still I had to sweat a bit to complete all the assignments in IOS. C was not a problem, but the autograder warrants/enforces implementation in a certain (generic) manner which reflects constraints on real-world commercial applications such as web-servers.

Having said that, the assignments were fun, the video lectures even more so. The class is very organized. The instructor and TAs are very active in Piazza and go above and beyond in clarifying concepts. Office-hours are held every week.

Recommendation to students: Stick to the schedule specified and start your assignments early. Even if you are GOD in C, you will end up spending sizable amount of time for all assignments.

Overall a great class. I learned a lot about the mechanisms and abstractions that go on under the hood in an operating system (specifically Linux) as well as how to put them to use in building applications. For me this was a perfect class for the earlier part of my degree program (2nd class).

That being said, this learning came at a fairly high cost to me. Going into the class I considered myself a 'novice' in C and 'intermediate' in a couple other languages (I didn't graduate as CS undergrad). The first project is estimated to take ~30 hours, and it took me 70 hours. The next two took me ~45 and ~25, respectively. I'd say if you are already proficient in programming in C or have the time to make yourself proficient, this class is definitely worth the effort.

Also, Prof Ada, the TAs, and my classmates were all very active and very helpful on Piazza. Prof Ada held office hours every week via Hangouts On Air, so they could be reviewed on YouTube at your convenience. Very engaged staff that really want to see you succeed, regardless of your familiarity with C / Linux stuff.

I'll start off with the fact I've been building enterprise-level server software for years, so the client-server programming assignments in C (where most people struggled) weren't too bad. Lectures were solid, based in the required papers or the optional recommended reading (OSTEP book as prep material is great if you're weak on OS concepts). Gavrilovska is a published OS researcher, so knows the material intimately. TAs were incredibly helpful on Piazza with quick replies and knowledgeable (Tony Mason completely rocked it).

The only complaint I would have is that the Udacity autograder was configured to execute code that was different from what we were provided to test in local VMs, so several times I found myself ripping my hair out trying to figure out why some client-server test was timing out on Udacity after 10s but completing in milliseconds on my local VM. It seems the TAs love to set up network partition errors for client-server tests. You know who you are... ;)

Overall great course, got more in-depth OS knowledge than I came into it with, and feel like it was one of the best-organized courses I've taken so far (3rd in the program). It definitely makes me think twice about how I'm about to implement a multithreaded and/or multiprocessing solution.

I took this course to satisfy my 2nd foundational course, and passed it with an A. This is an intensive and rewarding course if you're interested to learn about OS design. It will hammer you to learn Linux System Programming with C using POSIX API.

The projects are time-consuming, but they're fun to do. Most assignments and exams include optional questions to gain Extra Credit. In addition, grades are curved generously. The average final grade was A.

If you'd like to take this course during Summer, note that you will end up allocating your weekends to complete the C programming assignments.

I will compare this class to Intro to HPC since it's the only other class I have taken.

Compared to HPC this class was way easier. The gotcha here is that the testing style is not my favorite to be sure. It's multiple guess multiple select for the majority of the questions. I also thought it was trying to be tricky on some of the questions just for the sake of trying to increase the difficulty level. There was a ton of information to study for the final and I feel the test with only 15 question did not sufficiently test that material. Instead it was written too narrow and specific with too many gotchas. The programming assignments did take a while to accomplish but compared to HPC it was way easier (orders of magnitude easier). The bulk of the time I spent on the programming part was testing my code against a black-box auto grader.

The lectures in this course were good - interesting and explanatory without being pedantic, for the most part. The class projects were difficult even for a veteran ex C programmer, so prepare accordingly. I would have liked to have done more smaller projects rather than grind out old C memory allocation issues. Thankfully this semester's TA was an amazingly talented guy! The length of the programming assignments kept me from doing all the reading I would have liked in the OSTEP book. The assigned papers were weak: out-of-date material and just not interesting. The exams were exercises in minutia. Understanding the concepts is not enough. 15 questions for a final that's 30% of the grade? No.

Very interesting topics. Very interesting programming assignments.

The professor was excellent. She was very active in the forums and held Google Hangout office hours even while sick or travelling. The TAs were great too. For the first assignment, my TA did Google Hangout grading with each student, and I found it very helpful to get feedback in this way, and it allowed me to explain my decisions in ways I might not have otherwise. Unfortunately it was only for that assignment, as I'm guessing that it took too much time.

The programming assignments were practical and challenging enough without being overly difficult. Prior experience with C made them very manageable.

I definitely got a lot out of this class.

This is my first course of the OMSCS program, overall great learning experience. The course covers many OS topics with focuses on design and implementation of concurrency system, i. e. , CPU, memory, IO and file systems. I would say the course is very well prepared and taught, the lecture is organized, the teachers and TAs are very engaged , and the piazza discussion is very active and fun (well, it could also be discouraging, when you see your classmates are way far ahead of you in the project works).

I am not sure if the project assignment is my favorite part of the course, but it is definitely where I learn the most. I am not a programmer but as a PhD in electrical engineering, I do have quite some experience in programming (not C unfortunately). However, I did have a hard time with picking up C. I believe, this is the reason that most of people dropped the course, ~ 40% according to the unofficial survey. On the other hand, I do see there are a lot of students who are professional software developers, these are usually the people who do the project much faster and lead the conversion on piazza. (trust me, I looked at the more than 15 LinkedIn profile of the students who are active on piazza). I was a teacher myself in a European university before, I know how challenging it is to design a project assignment given heterogeneous background of students. I suggest to add more exercises or provide more code for the early projects to cut the steep curving curve. Most of people's feedback is "I thought I know how to program in C until I started CS8803 Intro OS" :)

Thank you Ada and also the TA s for the fantastic course.

Generally a very good class. The material is presented well, and is very interesting. It definitely favors people that already are familiar with C and Unix. If you're not a strong programmer, you might be in for a surprise, as the assignments can be quite involved.

The TAs went far over and above the usual level of support, and did a great deal to make this class run smoothly. It wasn't perfect... they're using a somewhat new autograding system that had quite a few kinks. They worked out a lot of them, and it should be much better going forward.

Professor and TA's were excellent. The lectures are very polished and intuitive. Programming projects can be very time consuming (especially the first project). Start projects early. Exams are medium difficulty. They follow the lectures pretty closely but require good understanding of the material. I watched every lecture again in the week or so leading up to the exam to refresh everything. Without doing that, I think the exams would have been much harder. There is a generous curve (80+ was an A in our class).

The programming projects are all in C, so if you are not familiar with C, it would be a good idea to take a refresher. If you are not a strong programmer, you will really struggle with the projects. I had very little C experience, but did my undergrad in CS and have been a software engineer for about 5 years and the first programming project probably took me about 50 hours to complete.

Background: No undergrad CS degree but have taken several non OMSCS courses for CS (DS and algorithms, obj. orient. design patterns). 1 year of industry experience. Basic knowledge of C. Received an A in the course.

Lectures are well done. However, the projects go over only several of the topics covered in lecture. Resist the temptation to save all of the lectures for later.

Projects are done in C. Skeleton code is given, but a lot of thought needs to be put into how your implementation can play nice with the pre-written code. Also, a lot of time is spent wrangling with the autograder; sometimes the autograder doesn't provide any meaningful or consistent output. Projects are judged against several test cases; a difficult point for me was anticipating some of these test cases, but the project rubric and other people's questions and answers on Piazza gave helpful hints on what cases to anticipate.

Speaking of Piazza, questions are answered quickly, either by students, or the TA/the professor. Office hours are also consistent.

Number of hours spent: I had to work during lunches (every day during weeks when projects were due or an exam was being held), and an hour or two after work if I'm not already wiped out. Also had to devote several hours on weekends for projects and studying for exams.

Overall, a very solid and straightforward class. There aren't any tricks or gotchas in my opinion, and results will accurately reflect the amount of work you put in. Be prepared to put in a lot of work though.

Lectures: Very well done, the professor was very knowledgeable in the subject matter and provided enough information for you to get started on the projects.

Projects: All were written in C. If you are completely unfamiliar with C i recommend taking a quick refresher. The projects were very challenging but I feel I really learned a lot while completing them. Even though the project were challenging, the slides provided enough information most of the time for you to get started and use google to figure out the rest.

Exams: Standard proctored exams that cover a specific set of material. Not cumulative. As long as you study you will do fine.

Grading: Grading was extremely fair i thought. A lot of the projects used a "unit test" method through Udacity and the results of those tests gave you a pretty good understanding of what grade to expect. Final grade was curved.

Overall: Great class but very challenging. Do not take this with another class unless you have a lot of time on your hands.

First course in OMSCS. Highly recommended.

With only hobbyist-level experience in C, I could dive into the meat of the projects and found all of them challenging but fulfilling. Lectures kept my attention and sample exams proved useful in studying. Professor Gavrilovksa and TAs stayed very responsive in Piazza all semester.

I would prepare for this course by establishing familiarity with (a) running VirtualBox VMs, (b) using source control in projects, (c) editing and understanding Makefiles, (d) debugging with valgrind or gdb, and (e) browsing system documentation such as manpages.

On Project 3 I got more pain than gain from Udacity autograder, but TAs allow you to tarball whatever you want and submit in lieu of Udacity. In my case they graded my tarball very fairly.

Lectures: Good quality, and most of the readings were summarized to some degree during lecture, which helped to get through some of the dense parts of the assigned readings.

Projects: 4 projects (10% overall grade each). Project 1 and 3 took a lot of time. Project 2 was mostly analytical, no programming. Project 4 was a shorter project since we were at the end of the semester. You could do optional extra credit for projects 3 and 4. This extra credit added a lot of time and since I was in another class I didn't make much of an attempt at it.

Exams: midterm (25% overall grade) and final (30%). Exams were multiple choice/fill in the blank/short answer kind of questions. Exam averages were around 75%.

I took CSE6220 in Fall 2015 (previous semester) and this class is a bit easier and a bit less time intensive. I took CS6300 with this course and it was a doable double (A in both courses) but I didn't get to read as much of the book as I wanted. I bought the book "Modern Operating Systems" (by Tanenbaum and Bos) for this course and I found it to be a good book. I don't think a book is necessary to succeed in this course, but it was nice to have a solid reference when I needed things explained another way.

It's a decently hard class, but not overwhelming. You just need to do the work. FWIW, I got an A, though it was curved upwards from a low B. I found the exams to be more difficult than the assignments personally, mostly due to the format. Sadly, I didn't do as well on them as I would have liked and feel I could have done better on them. My recommendation is to take detailed notes as you watch the lectures and read the papers. Especially take notes as you read the papers. Some of the material is a little dense, and the lectures can be sometimes circuitous. If you're watching the lectures through the web, you can set the speed to 1. 25x for the youtube player. You might find this helpful if you're having difficulty focusing on the lectures.

I had professional programming experience but only a little bit in C. I found the programming part difficult only as I was becoming acquainted with the problem. After that, the assignments are very straightforward. Projects 1 and 3 are time consuming and will take 20-30 hours of your time. Projects 2 and 4 will only take 3-5 unless you do the extra credit.

Judging by my interactions with other students, if you're going to take this class and are not comfortable programming, you should:

• Learn how to work inside a VM. Learn how to set up a shared folder between the VM and your host machine in advance if you think you'll need it (you probably don't)
• Learn enough C. The C programming in this course is not hard, but if you're not comfortable with the language's semantics you'll be overwhelmed on the first assignment.
• Learn how to work in GCC, GDB, Make and Valgrind. There are plenty of great tutorials out there.

My only complaint is that the sample exams in Udacity didn't adequately prepare me for the real exams. Other than that, this course is excellent. Professor Ada and the TAs were super responsive. I don't recall ever having to wait more than 20-30 minutes for a response ever. I definitely recommend taking this course.

This is an introductory course to the fundamental OS concepts, a good review of all relevant OS topics. The last section of the course covers a few topics about distributed systems: file system; distributed memory; datacenter technologies, which are becoming more popular in the growing cloud computing field. In my opinion, it is a must-take course for students in CS background who need some refreshment for their undergrad OS class. OS knowledge is a core background requirement for almost all CS programs.

For the projects: there are 4 projects in total and 3 of them are coding projects. The projects are in C and some familiarity of C is required. I already have C background but the challenge is to complete the projects and pass the Udacity online grading. The online grading can be tricky sometimes because the online grader sometimes does not give you sufficient failure information, besides it is usually more rigorous than your local test run on VM. Many times, you need to insert fprint to just debug. That always takes a lot of time. The piazza forum is always very active and helpful. I would not be surprised if someone has to spend 40-50 hours on one particular coding project. The tip is to start early so you can spread the whole work into 2 or 3 weeks instead of trying to finish it during last weekend. My impression from Piazza is that people who do well in the projects tend to start very early and engage the discussion very early.

For the exams, it is closed book closed notes exam. You need to study the videos and read the materials. It is not very difficult, but you do need to spend some time studying them since there are a lot of concepts and details there.

Overall, it is a very good class. It can be frustrating in the beginning, but if you stick to it and go through the whole semester, you will probably learn a lot.

Excellent class. You should be comfortable with C before taking this class. The projects really help solidify some of the material.