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).

1. 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.

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 well prepared and taught, the lecture is organized, the teachers and TAs are 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 into 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 C. This is mostlikely 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. (I looked at the more than 15 LinkedIn profile of the students who are active on piazza). I was a teacher before, I know how challenging it is to design a project assignment given heterogeneous background and skill sets 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”.

The content of the course is really straightforward, i would rate the difficulty for the course content 3. However, the programming assignments are substantially more difficult for those who are not experienced with C. I rate it 4. 2. Given the fact that project assignment takes about 3 times more time than the course content, the weighted difficulty is 3. 9.

Thank you Ada and also the TA s for the fantastic course.

This is my first class in the program and I really like it. The lectures and materials are clear and well organized. Piazza is super active.

The projects are the best part. The requirement can be vague and require serious interpretation and design before going into coding. They are challenging but not too difficult. I have never programmed in C before the class, but once I am familiar with C and get all the caveats of low level programming, the projects get a lot easier. There is auto grader so you get constant feedback and guarantee to get a decent grade. Project 1 is the most time consuming so far, so don’t drop the class if you feel frustrated. It will get better. This class will definitely improve your programming skills.

Overall, very high quality course. Good for a first class. Highly recommended.

This is a great class. The target student is someone who has an OS course as an undergrad, but a while ago (or someone who wasn’t CS undergrad). You will learn new things, even if you’ve developed low-level code before. The projects are moderately challenging. You need to be comfortable coding in C, the language of Operating Systems. People who don’t know C find the projects incredibly hard. The Professor and TA’s are very active on Piazza, and go the extra mile to help out students who are stuck.

This class is fantastic - perhaps my favorite one so far. The videos are excellent, and it covers a ton of really fundamental topics. I think in my work, I’ve leveraged what I’ve learned in this class more than any other. The projects cover some really useful techniques for writing concurrent code. Highly recommended.

Coming from a background in high-level web development (and, earlier, scientific computing), this course taught me a very different style of programming. It’s taken a bit of effort to get used to the concepts in the course and I’ve really enjoyed the struggle. The projects are, for the most part, detailed, relevant, and instructive.

The lectures, on the other hand, are long, tedious, and often off-topic. The instructor spends excessive time and effort explaining simple (or easily-researched) topics and leaves large conceptual blocks unexplained. She does this in lectures that are often over three hours in length. The in-lecture exercises are completely unrelated to the course material.

The midterm exam was closed-book using ProctorTrack (which is terrible software based on a bad idea, but with excellent customer support) and largely memorization-based. The exam format stressed me out more than its difficulty.

tl;dr The topics are neat, but the course is badly formatted.

The course itself wasn’t too terribly hard. The instructor does a fantastic job of relating the concepts, is VERY active on the forums, and generally cares about you learning something - any one of these things are very admirable in a professor, as most professors usually have only one of them. She is also very generous with the curve, which is somewhat necessary as both midterm and final contain many GOTCHAS!

That said… the projects are an absolute bear - they are in C (not the friendliest of languages) and have ‘extra’ requirements that are time consuming to implement and have no relevance to the topics at hand. Project 1 is by far the most time consuming, so keep that in mind if you are struggling through the first one. We were basically given a blank C file to start - although I have heard this may have recently changed.

Its a good course, but set aside a massive amount of time and take excellent notes. Also, learn at least the basics of C first - otherwise, you are toast!

The lectures are well organized but very theoretical to me, and I had to admit that I hardly understood the last four lectures at all… Even though I watched the Videos again and again. So I had to guest the answers of the final… So sad. If you took this class, please take advantage of the office hours, I hope I could have time…

For the projects, they were very frustrating for me, and I had to submit them just before the deadlines becourse I don’t know how to do it… Until I got the hints from Pizza and I had to submitted an Imcompleted one. The good news is that there were lots of experts on Piazza and they really warmhearted and answered all my questions. Without their help, I can’t complete this course.

I really love Ada and the TAs of this course, I just hope I could understand the materials better, but I can’t at this point… I just don’t understand the lectures, they are too abstract and hard to me. I wish I could understand them better during my journey in OMSCS.

Programming projects You’ll see a lot of reviews complaining about all the C programming in this course. I assure you, as someone who had a couple of C-heavy courses in undergrad and no professional experience with the language, it is not that bad. They give you a ton of code and the assignments kind of write themselves once you get the hang of what they are after. Even so, you should probably expect to spend 20 to 30 hours on two of the four projects. Don’t bother with the extra credit options on the projects unless you really want to. They will add quite a bit of additional time while only affecting your grade by about 1% each.

Lectures/Tests The lectures are a little slow paced. I watched most of them on speed-and-a-half, which increased my focus considerably. The midterm and final ask detailed questions from the lectures and also contain quite a bit of application material. Strive for understanding of the lectures, rather than memorization, and you’ll be fine.

Overall comments I got an A in this class without having to sweat too much, mainly because the curve is generous - 81 to 100 was an A in fall 2015. It’s an enjoyable class with some interesting material that I didn’t encounter in undergrad. Biggest complaint: nothing got graded until the middle of the semester, because nothing was really due until then. The first project is already divided into four deliverables. Releasing separate grades for those components would help students who are unsure of where they stand.

To be honest I took this course because all others were full, not because I’m into the topics. However it turned out to be a great course, mainly because of the amazing instructor. A good range of topics were covered, including multi-threading, memory management, distributed systems etc. Nothing is really difficult but there’s a lot of memorization if you want to do well on the exams. Taking notes while watching the videos are necessarily to get good scores.

The projects are a different story though. You have to start early unless you are confident in C. I find them difficult since I had no previous experience with C. I ended up with an A, so don’t walk away from this course just because you don’t know C. There’s a huge learning curve, especially for project 1. I got great help from TAs and students on Piazza. Project 3 was tricky too because of multi-threading and memory sharing. Project 4 looks straight forward but might take some time to figure out what exactly to implement.

The curve is very generous and there are several extra credit opportunities. If you spend honest time on this course you’ll be fine.

It’s pretty hard for me to give an accurate commentary on this class because I have such an unusual background, but I can only really give advice that would be applicable to the general population interested in taking this course. About 35-40% of the students will drop, and this has been consistent throughout the terms so far. General programming experience almost doesn’t even matter, but having the right experience does. People with 10 years of programming experience struggled. For reference, I had maybe worked a job using a higher level language than C for about a few months before taking this course, and most of my academic and job experience was fairly nontechnical in nature. I did not even graduate in STEM.

Of course, understanding C is necessary to do well, but I can promise you that not knowing C is NOT the primary limitation that most people will suggest. Being able to take a spec, design a solution, test it thoroughly, and refactor to apply the right patterns are far more indicative of whether or not you will succeed in this course. I didn’t find the programming assignments particularly difficult, but a lot of people struggled against the autograder so a bit of gusto for debugging would certainly help you as well. You should still start the projects early so that you can let the ideas marinate in your head as you’re going about your daily routine. The tests were nothing to write home about; just your standard review of the details will do. What helped me most was taking screenshots of key video stills into OneNote and maybe writing a few supplemental notes to jot down specifics as I listened along at 2x speed. That workflow was sufficient enough for me to grasp the material.

Going by the reviews, this, Machine Learning, and Algorithms are by far the most time-consuming classes. I heard somewhere that AOS was easier, but the statistics seem to reflect an equivalent success rate (~40% drop). All of these classes will expect different things out of you, and this course in particular should challenge your programming abilities relative to other courses. Operating Systems classes are notorious for having the most legitimate programming assignments, whereas Algorithms on the other end of the spectrum expect you to have a higher level of mathematical maturity and the ability to write proofs, which fewer people possess. I CAN give advice on the latter, but this is not the review for that :)

Instructor and TA support was pretty top notch from what I saw, although this won’t be the case for every single course in the program. So I would take the course just because the experience was well made and well-supported, but definitely make sure that you have the right background before signing up!

A very good introduction to Operating Systems concepts, most specifically Multi-threading, Synchronization, Inter process communication, and Distributed systems.

This was my first class in the OMSCS program and by far this was the best class I have taken during my formal CS education. I did get an A in the course for some perspective. The course is made up of 4 projects, a midterm, final, and class participation on Piazza. The lectures are great and easy to follow. I highly recommend watching them on at least 1. 25x speed. I started doing this halfway through the semester (eventually bumped up to 1. 5x when re-watching) and realized I could retain a lot more info than having to keep rewinding because my mind was drifting. Only a handful of papers to read, most were pretty dated but helped drive some concepts home. If you are looking for an easy class though, this is not for you. I feel this has prepared me well for the workload/work ethic necessary to succeed in classes to come. You get out what you put in!

Also ‘Operating Systems: Three Easy Pieces’ is a free online book that I referenced A LOT to give me an intro into the topics discussed in the lectures. Chapters are short and easy to read/comprehend. Highly recommend it!

Full Details: The projects are, as mentioned everywhere else, difficult and clarification of parts are necessary. I would recommend being comfortable with at least the basics of C (pointers, func pointers, extern usage, getopts, string parsing, file manipulation, etc. ). For some that might be too basic but if you know how to read through the provided code then you should be okay to at least get through the simpler portions of the projects. You will want to start looking into the basics of socket communication, posix threading library, posix/sysv IPC mechanisms and synchronization. You will be provided enough material to get you going with each of the items listed in the last sentence.

The midterm and final are not easy and it is not enough to “memorize” formulas/concepts. You will need to understand the purpose and how each input to the problems/equations affect the output and then formulate what pieces are necessary to come to the correct answer. You will really have to understand the material. That said it is possible to do well. Participating in Piazza discussions, re-watching lectures, and doing the projects will prepare you well in understanding the concepts/problems on the exam.

One thing you might not expect is that you are provided an Ubuntu VM that is set up to test your projects in before trying the auto-grader in Udacity. Valgrind and GDB will be your best friend and help you find things that the auto-grader will detect and fail your submission even though things in the VM work fine. I would recommend some sort of version control too (I used git)!

A great course, with a great pro-active instructor and TAs who are very engaged with students (whether replying to Piazza posts or holding weekly office hours). The grading is generous (everything graded out of 100 points and finally weighed in). You better know C cause 3 of the 4 course projects are mainly C programming projects. The projects will take significant time to complete.

This was a great course. The lecture material was extremely well made. The projects were hard, but rewarding.

The only major con I can come up with is the “Udacity Autograder” which was used to test the performance of the programming projects. It is designed to provide feedback when a test fails, but more often it would simply fail with no error message, leaving you scratching your head for hours about what went wrong. Fortunately, the Piazza class community was good at providing tips for how to “debug in the autograder”.

This was the first course I have taken in OMSCS and frankly I was totally impressed. I would highly recommend this course. It’s not easy, but you will learn a lot.

I would say its hard but grading seems to be a little tight.. Really need to count your marks from the very first assignment. Course until mid semester is programming oriented and after mid-semester is information oriented. It is really difficult to get the assignments/projects right, if you are not well versed in C. Definitely a worth-taking if one is not from computer science.

• 25% Midterm Exam
• 30% Final Exam
• 10% Project 1: Multi-Threaded Webserver
• 10% Project 2: Experimental Analysis
• 10% Project 3: Inter-Process Communication
• 10% Project 4: Remote Procedure Calls
• 5% Class Participation

Projects require comfort in C and the ability to hand-code many things for which open-source libraries exist.

Udacity auto-grader is frustrating at best. So often, folks would succeed with their implementation in the VM just to discover the auto-grader would fail. This made debugging nearly impossible and extremely frustrating, as the specific test cases exercised in the auto-grader are not revealed.

Lectures are lengthy and detailed. Anything is fair game, so volume is high. Still, the instructor’s style is excellent. She explains topics clearly and concisely. At times, the real-world examples feel incomplete.

While I was exposed to a ton of material, I felt I could have self-taught that material. The projects leave something to be desired.

The lectures are long and boring. The projects are unreasonable. It has a 40% withdrawal rate and that should tell you something. This is the only class that has such a large curve. 100-60 is an A and 50-60 is a B. Really if it is that hard you are not teaching anyone anything. You better be a really good C programmer with lots of spare time. Do not take this class with another class.

Most comprehensive video material in any course that I have attended in OMSCS.

Lectures are high quality with tense content. The first project 1 requires a broad knowledge of C programming topics or the ability to quickly learn it. There is a Midterm and Finals. Professor is very engaging and active in Piazza. The whole class really feels like it’s intended to fill gaps as preparation for the Advanced OS course.

The lectures are of very good quality, the format is well-designed. Projects can be very overwhelming. I had some experience with C so I wasn’t totally lost (C is part of the requirements) but you really need to break down the projects in smaller parts, gradually building up your code. Project 1 gave some recommendations on how to do that. P2 was easier (no coding, just a report), P3 so far is as overwhelming as P1 and very intensive. They are very time-consuming. I’m spending too much time on the projects and not enough on the lectures. Midterm wasn’t easy to me, you really need to understand very well the concepts and not just memorize. Professor and TAs are active on Piazza, watching the office hours (1h once a week) helps a lot for the projects. Need to know some basic commands on Linux also.

Fantastic, well run course off to a great start. Must learn (or already know) intermediate C to stay afloat with projects- structs, macros, makefiles, memory allocation & release, valgrind, using libraries. Helps to have a basic understanding of VM usage and a unix/linux environment- ssh, scp etc, as the provided dev setup is a Ubuntu VM. Programming in windows is allowed, the student must make sure all programming assignments will run on the provided VM before submitting. ‘Works on my machine’ sadly is not a valid excuse in this course. Lectures are good and dense. Some exam questions require some additional thought beyond repeeating back memorized facts, which can catch you off guard if you’re not expecting it. Professor is actively involved and frequently participates in piazza, in addition to weekly office hour.

Don’t kid yourself - if you don’t know C this class will make you work. You will struggle (enjoy lots of time with) with the projects, even more so if you come from a higher level background. Midterm & Final together are over half the grade, and 4 projects make up the rest. Though the course work has been difficult, grading has been fair. Content is interesting and presented well in the lectures. Overall class administration has been relatively poor, but that is probably a function of being a first time offering for the Professor.

Overall, this is a great class. The topics are interesting, the professor is very engaging in piazza and the lectures are well made. With that said, the projects are veeery time consuming if you dont have a deep understanding of C. The projects consist of a page or 2 of descriptions and the expected requirements and thats it. Its up to the student to figure out how to put everything together. If you are proficient in C, this class will be a breeze. If not, make sure you brush up on your skills and have alot of extra free time.

I really enjoyed this class and highly recommend it. Its probably my favorite class taken so far. Yes, there will be coding and yes, it is in C. But its totally doable and a lot of fun. There are four projects (three of them coding, one is an easy report that you can complete over a weekend). I had very limited experience in C (just from college many years ago) and I mainly use higher level languages like Java, C#, JavaScript and Python at work so diving back into C was a little bit of a challenge. But its very doable, do not get scared just because its C and it has pointers and manual memory allocations. You will be fine. Start your projects early and use the Piazza forums. The students are super helpful and there are always active discussions talking about common bugs or sharing online resources. Use the provided VM! Do not try to write and run programs in your own setup! Its not worth it and will only lead to headache. When you start the projects, break them down into bite size chunks. The projects themselves are fairly large (all of your time will be spent here) but if you set small milestones/goals you will complete the projects in no time.

This is a very well organised class. Professor Ada is very active in the forum and always trying to make sure that every concept was learned properly. Projects can be overwhelming if you are not used to C, otherwise you can finish them in a short amount of time. First exam was designed in accordance to lessons and material provided. Tip: Start the projects as early as possible

Overall this is a great class. Pros: * Interesting projects * Excellent Lectures * Impeccable pacing: the lessons, readings, and projects are timed perfectly. I routinely get everything done just in time. I don’t feel like there’s a time crunch or downtime * Given my background as a CS grad a little over 10 years ago, this class has a great balance of reviewing just enough undergrad information to prepare you for the challenges it introduces * Professor Ada is particularly responsive and helpful in the piazza forums. Cons (basically all of them are about organization, and indicative of a first-run of the class. they’re sure to improve. ) * Grading is slow * The exams seem to need a little work in their wording and alignment with class material. There were many discussions of confusion in the piazza forums after the midterm and one of the midterm questions had to be regraded * If you’ve never done any C before, you’re going to have a huge learning curve on the first project. A brief intro to C concepts optional lecture could go a long way here. * This class used ProctorU. Ugh.

General Comments

I highly recommend this class. The concepts are logically laid out, the lectures are easily digestible, and the support from the Professor and TA’s are well above average. The midterm content was no surprise but it was challenging. The projects are easily the biggest time investment. Based on voluntary polls I conducted on G+ students reported spending on average about 40 hours on project one and three, and about 5 hours on average on project 2 and 4. There are also many opportuniteis for extra credit. There are very easy ways to prepare for this course, download an ubuntu linux VM and start writing C that reads and writes from files, sends text and data overa TCP/IP socket, performs string manipulation, and parses command line arguments. These skills were necessary to complete the projects, but not the focus of the project. Despite how much work these projects require, you have plenty of time to start on them (you can start project one on day 1 and it is due 6 weeks in). NOTE: I spent on average 10-15 hours per week, but this is because I worked ahead on light weeks. If you strictly follow the syllabus you will not succeed. For example the first two weeks of the course only took about 2 hours a piece to complete, but I used that time to start project 1 early and it paid off. Start early, use the forums on Piazza, get used to linux and C, and fight the urge to be a perfectionist. It is easy to self induce work on these projects and overwhelm yourself. There is no need to turn in production quality code.

The course material is very good and very organized. The instructor is very nice and she responds to all questions thoroughly and promptly. The biggest problem is the projects. Projects are in C language. You are expected to be proficient in C in order to do well in the projects. The help in the project is not so good from the teacher or the TAs. Also the level of the projects is difficult and it is not very clear what you need to do or the steps you can follow to finish the projects. Keep in mind that you also need to read a lot (papers) outside of the course material (slides) given by the instructor. I unfortunately dropped the course because I could not do the first project. I wish I can return to the course when I know C better and probably nail it with a B.

Great course. I went into this with VERY little understanding of how to program in C and I’ve had to learn a lot, but that’s the idea here, I think. You HAVE to start on the projects early, becuase they are complex and take a lot of work to complete, at least for those of us who aren’t already realy good at C. One thing to note… they’re relieing on Extra Credit assignments rather than a curve… so just additional coursework if you want the A and struggle with either the projects or teh exams… I don’t really like this setup, but oh well.

This is an excellent class. Conceptually not difficult to understand but it was very very time consuming for me since I had to come upto speed on C and I am not a programmer but do have good knowledge of general programming concepts. This class gives you a broad understanding about linux OS but does get into detailed discussions about multithreading and multiprocessor systems. I do agree with others here that the project descriptions are not very well defined but the office hours really helped in better understanding of what was required. Piazza was exploding with information and discussions with high level of participation from students, TAs and professor Ada. Infact I believe it was piazza discussions that really helped me with the projects. Knowing atleast a bit of C, functions and pointers in C and creating a robust linked list program prior to the course will be very useful. The linked list that I created for project 1, I reused it for project 3. The classes were very well organized and lots of effort and thought has been put into organizing this class. Really very rewarding and a blissful experience. This is my first semester and I really hope the remaining OMSCS is atleast or better than this class in terms of class organization.

The is an excellent class with an exceptional instructor. I didn’t have much C going in, so it took a lot for me to complete the projects. Detailed feedback on the projects is provided but only if you ask. While this was the first time this class was offered, it was incredible and it set a high bar in both quality and content. I do recommend you take it by itself: there is a lot of material, and the tests and projects are challenging. However, Prof. Ada is very involved and I would very likely take another class from her.

Exquisite course. Lectures, projects and tests. Very good!

Spring 2015 is the first time they offer this course so there are lots of rough edges.

The good part - lectures are very detailed and complete. Tips if you download the video to watch offline, remember to go to udacity to complete the quizzes, it counts towards 5% of the participation grade.

The ok part - this is an intro class and lots of people are in it. Piazza has lots of posts to go through. Also prof expect you to contribute in the forum (participation grade). The projects are not very refined. You should know C for project1, 3, 4.

The bad part - they don’t provide feedback to your projects. Sadly they cannot afford to do so because of the class size. But you cannot learn from your mistake so you don’t know what you did wrong.

Exams not that useful in testing how much your learn. You need to memorize a lot of details in order to do well.

A great, great class. The amount of work wll vary widely based on your background. I took this class because I didn’t feel confident walking directly into AOS and I certainly feel it prepared me well for it. If you are not comfortable writing C, the projects will be very time-consuming. I often fell behind on lectures due the amount of time working on projects, and couldn’t have imagined taking IOS alongside another class (while working). The lectures are dense but I wouldn’t say difficult to grasp, and the exams stick to them quite closely. One qualm is that exam questions are sometimes worded strangely, making them more perplexing than they need to be. A highlight was the class forum: my class had some brilliant student contributors alongside the TAs and prof actively involved. That really made the difference while working through projects.

First offering of this course. Prof and TAs quickly adjusted to feedback. All were very responsive. Projects require moderate C programming experience and time to learn new techniques (for me). Exams were challenging but unlike otjhers I ddid not feel that meorization was key - rather - picking out the fundamental principles and being able to reason about exam problems using those principles would be just as effective (if not more so) in doing weel on exams. The class member’s feedback and help on Piazza made a huge difference in my success.

Instructor and TAs have been outstanding. They are responsive on the forums, encouraging when students are in panic mode, and patiently responsive to criticism of content / organization. Really impressed with them. The relationship has felt surprisingly personal. Hopefully that persists beyond their first semester.

The projects can be very time consuming. I echo that you need to know C. Some specific C skills you’ll need and are expected to have for Project 1 are the following:

• string manipulation (i. e. , strcpy, strcat, strtok) and understanding/using null-terminated strings
• use of pointers; nothing too complex like pointer arithmetic, but knowing how to initialize them, malloc space for them, derefence a pointer, and use the address of a variable as a pointer reference
• general memory functions like malloc, free, memset – this might be challenging if you’ve only used more abstract languages like Java and C#; took a while for me to wrap my head around it
• file I/O: binary read/write, reading a file size (lseek)
• using proper header files for prototyping (. h files) and (in later projects) incorporating provided. h files to implement APIs
• creating a basic Makefile to build your application (though after Project 1 they started providing these)
• creating a queue (linked list) structure and the functions needed to queue and dequeue items in an instance of that structure (again, after Project 1 they provided a library for this; not sure if future iterations of the class would go ahead and throw that in as a resource for the first project)

You’re expected to be able to do the above with only the most basic and standard C libraries. We were allowed to ask if we could use a certain library to complete parts of our projects, but to my knowledge none of the small handful of requests were approved. But once C starts clicking and you get a handle on the basics, you don’t really need any special libraries.

There’s also a brief overview early on of how to create a basic web server and web client that communicate over a socket, which you’ll have to implement and expand on (every project is a client/server combination). I found it to be a little too basic, but I was also struggling to get my C legs (get it?). I’d recommend that if you’re a C noob, you also find a good introduction to connecting to, sending, and receiving over a socket. The first project requires that as part of its functionality, but while there’s a lot more to it than that, I found it to be one of the most time-consuming portions.

If that seems overwhelming, I can say that I started the course with no previous C experience. I had primarily done C# and Java coding prior to taking this class, and I was able to get up to speed. If you have decent coding experience, you’ll be fine. You’ll just learn how much you take for granted. :)

As far as the material/exams go, I found that to be very easy to handle. The lectures aren’t terribly long, they build on each other well, and (bonus!) they include a lot of fun graphics. I had no former exposure to most of the lesson topics, and I found the majority of the material very accessible.

Oh! A lot of people used valgrind and gdb for debugging, as well.

Great lectures, very hard assignments. Learn C if you don’t know it before this course. Exams are relatively easy, come straight from the lectures.

The professor is very involved in the class and you can learn a lot. Assignments do require knowledge of C and can be time consuming but you should do well if you have enough time to put into them. I found the exams to be the most difficult part of the class. The midterm and final are 55% of your grade. The material is not particularly difficult and questions come from the lectures but rely heavily on memorization of details that could be easily looked up (so you have to put a lot of time into memorization) and it can be difficult to understand the questions (with the question being open to interpretation). Grading is generous.

Projects are challenging and require some design – you can’t just sit down and start spitting out code (even with many years of hard-core C experience). I seemed to miss the mark on tests and come out with several questions that I had no clue about – even though I could explain and use most of the concepts.

The only reason I put difficult is because of the time investment. The material is not overly complex. It is very well taught and professor Ada is very knowledgeable and helpful. For me, the midterm exam was more of a semantic challange than a straight-forward exam the final on the other hand did not feel that way. If you do not know C you will be in for a lot of work. In my opinion, the material in this course is foundational and should be requried for every CS graduate. Start the assignments as soon as you get them!

Excellent class with a lot of material. Four projects, three programming projects which take ~40 hours to complete each, and one report. A ProctorU based midterm and final, which are challenging. I enjoyed the class and got a lot out of it, but it was a lot of work.

The class was very informative and offered a lot of base knowledge for Operating Systems. I suspect it would make taking AOS much easier. The lectures are very dense and should be watched carefully. There are 3 programming projects + 1 informational report project, they varied in difficulty. The tricky part of this class was keeping up with the lectures (+Udacity quizes), getting the projects done while preparing for the tests (Midterm and Final). The tests sneak up on you and were the hardest part of the class, given the breadth of information covered.

Coming from a C# background the the transition to C was a big change since we had to deal with memory and string manually. Exams were difficult for me but I hope thats because I’m out of practice. I wish I allowed more time for reviewing for the final. We had a curve in the end so if you do poorly on 1 or 2 items try and stick it out and do as best as you can on the remainder. I wish I studied more on the exams. Please do not wait until the last minute to start ANY project. Start the projects as early as possible and don’t be afraid to collaborate via Piazza. We had several strong C students helping weaker individuals. All in all I enjoyed the programing assignments and felt I learned a lot. I’d recommend this class to anyone, with the difficulty comes satisfaction of complition.

This was an amazing class. The lectures were exceptional, the TA’s and professor were very helpful and active on piazza. The course has a mid-term and finals which will make you take a lot of notes. The prjojects where the major time-sink for me even though I had a fairly good understanding of C. I may have easily spent over 100 hours on project 3. It was a struggle to get your code pass Udacity as the feedback was extremely vague but it also meant that there was a bug in your code. I would proablby have spent half the time on the project if it was not for submission through Udacity and ended up losing points for bugs I woulndt have caught other wise. Other than the TA’s, the other class mates were extremely helpful in ironing out many issues. The exams were well planned and didn’t need you to really rote learn anything. As long as you understood the concepts, you would do well.

If you are VERY comfortable with high level C programming and Linux you might be okay. There is no quarter for the inexperienced though. Give it a pass - neither OS class is required to graduate anymore. I will most likely be dropping. This class would strain the unemployed.

This class really required some quick development of C knowledge. It touches a lot of relatively basic concepts regarding threading, memory, hardware functions, scheduling, and more. The projects in the course were logically intensive and super time consuming for someone new at C. I spent tons of time trying to figure out problems that were just incredibly simple mistakes. It was very satisfying once projects were complete, but incredibly frustrating to get there. The course also has a huge breadth of information and the tests are more rote memory than logical deduction. The lectures were good, but the huge amount of information was often overwhelming and not as interesting as following a single line of logic. Overall it was a solid course and certainly filled a gap I had in OS knowledge.

I have mixed feelings about this class: Let me start by saying that the lectures are amazing and great for learning. They’re the best thing about this course. However, the projects are extremely frustrating. A lot of people think that it’s due to C programming. But I don’t think so. They’re frustrating because they’re contrived to be difficult. The instructor has only one solution in mind. But they don’t provide you any guidelines. And then you have to spend endless hours trying to figure out what they had in mind. Obviously there are so many other ways to solve the problem. But you’re constrained to figure out what to do with the terse and convoluted code skeleton provided without much explanation. And then there’s the whole mess of the autograder which only works with the solution they had in mind. Other working solutions might fail the autograder with mysterious messages. The TA’s would never acknowledge the problems with the autograder and would always blame it back on the student. The only help they provide is very genericand doesn’t help much. At the end of all of it, you’re not given any solution guidelines. So you don’t really learn what you did wrong and how you could improve. I have professional experience using C for a couple years. C is not the problem. I have a job that requires no more than 40 hours a week. But at the job I have to be intense and sharp. This course has definitely affected my job. All these hours of frustrating project work got to me and it was interfering with my work. I’m not sure I would recommend taking this course if you’re full-time employed. I definitely learned a few things. But was it worth all the effort and frustration? I’m not sure

This was a great class. I learned a lot about OS, and since I’ve never had a strong OS background, a lot of the information was new and fresh to me. The assignments are programming-intensive in C, so a good solid foundation in C is an absolute necessity. The assignments weren’t that difficult, but they are time-consuming (in a fun way if you like to program!). I think two of the projects took about 10 hours each, and the other two less than 5 hours. The grading scale was extremely generous.

This is a great subject which really helped develop my C skill - a language which I use on a daily basis. I got a exposure to different workflows and importantly now better understand operating systems. The projects are time consuming and there is a lot of depth and variety to the exam material. Regarding the projects I think there were a few misconceptions - firstly I don’t think that C is a massive hurdle here that it is percevied to be. I think the real challenge is coming up with a suitable design to fulfill project objectives. I acknowledge that the autograder can be frustrating at times but it did make me think critically about what I was intending my code to do and what it was actually doing. When I reconciled my design and objectives the autograder would be happy. Secondly, I spent too much time on design and underestimated the amount of testing that was required. The projects are a little thin on specification so it is more or less up to you to devise suitable test cases that match what you think the project objectives are. The marks that I lost in assignments were in hindsight I think due to not thinking more about testing. The problem here is that you will clock a lot of hours. At some point I just had to say enough and move on.

If you don’t know C well, especially concepts like pointers, pointer arithmetic, function pointers, sockets, string manipulation and memory management (malloc, free, and tools like valgrind), then it would be best to brush up on those in advance. Everything else is explained in the lectures. Projects 1 and 3 are large and complicated and will require a lot of time – especially if you have to try to learn C at the same time. I would highly recommend starting the projects as soon as they are available to make sure you have enough time to finish them (and try to get it through the autograder). The code skeletons and Udacity autograder are new this semester, as I understand it. I personally enjoyed the projects the most from this class, and while the autograder can be frustrating at times (when the feedback is too vague, or you don’t really get any at all), I was always able to find the issue by doing more testing of corner cases myself, which would uncover a crash or deadlock in certain circumstances. The benefit is that you once you’ve passed the autograder you can be confident that you’ve done things correctly. I also like the new phased approach to the first project, where you have a few ‘build-up’ assignments that you should complete before the main project. I personally didn’t find the code skeletons a problem or too restrictive, although understanding how it all fits together can be overwhelming at first. By looking at what is given in the skeleton and how certain functions are defined you should be able to figure out how to make everything fit together. Although, I’m not a programmer, so perhaps having some ‘embedded direction’ is more helpful to me than someone who has a lot more experience.

This was a really enjoyable class - don’t let the ‘introduction’ fool you though, it’s not easy. The course covers a good breadth and depth of operating systems - scheduling, memory management, concurrency, and then an overview of distributed memory and filesystems.

Loved this course! The material is very valueable. Videos are very Informative. Projects are interesting. Professor and TAs are helpful. Midterm and Final are long and cover many areas. Programming in C is the most challenging part of this class. If you programmed in a similar language like Java, you should be good. If you haven’t code in a while or are not used to a C-styled language, this is going to be hell for you. I strongly recommend going over the Lynda C programming course before taking this class. I wished I took this class in the Fall or Spring instead of the Summer session.

I understood the theory, but had lots of trouble with the application, since I’m not a programmer. Mostly have experience with HTML, CSS, Javascript, and C++. Be very prepared to spend all of your time aside from the videos on Piazza and trying to figure out where to start on Project 1.