Course Details

Pros: 1. PintOS projects definitely help demystify how OS works. If you do not have a CS background or your undergrad CS does not go deep in the OS as you wished, this is good. 2. Lots of C programming practices. The 2025 TAs are quite active. 3. Well, you have to practice self-sufficiency Cons: 1. Course videos are outdated. 2. 3. Detailed Review: It is a love-hate relationship. At the beginning of every project, I will hate it very much because reading the long project instructions will get me overwhelmed. After that, I had to consult the materials available online - that is what I meant by self-sufficiency. It's a lot of self-taught honestly. I ended up reading 2/3 of the textbook OSTEP. I did not read the concurrency part because I had already taken Parallel System. But the textbook is great and enjoyable. Half-way or when I finish the project, I will get a huge sense of accomplishment because I now 'get it' how VM / storage works. And then next week I will hate it again because the next project begins. Ps. I think the Prof. has a great style of teaching. He explains things well and usually mixes that with history/narratives. I kind of enjoy the videos.

Pros: 1. Pintos was pretty good and interesting. 2. The book was pretty good. 3. The exams were easier Cons: 1. Horrible TA support 2. They ask you to pick teams - The ones I chose didn't lift a finger, I had to do all the pintos assignments by myself and submit. I got 99% and guess what, they also got 90+% because the projects were weighted 70%. Thats frustrating. 3. Instructor's videos were heavily outdated. He never engaged with students.

Pros: 1. Easily accessible and informative textbook 2. First half of the class is relatively well structured 3. You can improve your C programming skills relatively quickly Cons: 1. Projects 2-4 are incredibly time consuming and difficult to get done in time 2. Material after the Midterm is almost useless (Professor is also not a gifted lecturer) 3. Very little support from the professor/TAs Detailed Review: Overall the first half of the class (pre Midterm) is pretty good, its decently paced and provides a lot of informative material (especially if you needed a refresher on some basic O.S principles). However, the class falls apart almost immediately after this. Projects 2-4 are incredibly taxing and require a lot of time to get comfortable with the codebase before you can actually start coding. You're given less time to complete the harder projects in this course for some reason and they time it poorly where you have spring break, the midterm, and a project due pretty much back to back to back. The lectures are not geared towards Pintos at all either, and for such a tricky project it seems unfair to just leave students to their own devices without any sort of helpful tips or tricks to get started. Overall, while this course has some good aspects almost all of them (textbook, projects, etc.) are freely available anyway and the parts which are negative are unique to this course specifically. It seems strange and almost negligent to change the projects in such a severe way from before and not change any of the other aspects of the class to try and provide more support. If just a few things were changed/updated I could see this class improving dramatically, but in its current state I would not suggest any student take it.

Pros: 1. The textbook is great and (somewhat) helped me understand the theory needed to complete the projects. 2. The PintOS toy operating system is used for grad and undergrad classes at other universities, so lectures and helpful resources are somewhat accessible from KAIST, CalTech, Berkeley, etc. 3. You can't finish the projects without understanding the material on a fairly deep level. Cons: 1. The lectures on edX weren't the best. They were out of order, sometimes didn't cover the basics, and overall felt lacking in terms of cohesion and continuity with the rest of the course content. 2. Group projects can be a blessing or a curse depending on your group—few project tasks could be done in parallel. 3. Engagement on ed was lacking, basic questions went days without an answer or were given short shrift. Detailed Review: As mentioned in every review from this semester, the key takeaway is that this course has changed from previous iterations. The new set of PintOS projects are long, grueling, and lacking in terms of documentation and support from the course staff. The midterm and final exam were just comprehension checks for the lectures. If you watch all of the lectures, take notes, and put together a solid notes sheet you will do well. No extra studying needed. The projects: Project 0 Wish Shell — Just a warmup for writing in C... briefly touches PintOS but is quite easy. If completing this project is a struggle then the rest of the class could be a disaster for you. Project 1 Threads — Already a tough project with a huge amount of edge cases that are tough to test or catch. Thankfully the test suite was quite forgiving, but even a solution that passes all of the test cases is likely to be riddled with bugs that would bring the OS down under a stress test. Project 2 Userprogs — Same difficulty level as the previous project, but now you start to touch a larger portion of the codebase. The tricky thing here is that it is frustrating to test until you have your stack loaded correctly... and achieving just that first part is very time consuming. Project 3 Virtual Memory — A significant step up in difficulty from the last two projects. Again, brutally hard to test. You need a good mental model of what should happen before you start coding anything. There are some peculiarities about how the base virtual memory system is implemented to PintOS that you won't understand until you really dive deep into trying to understand the codebase. This is where the KAIST lecture videos are needed... without them I wouldn't have even known where to start. Project 4 Filesystems — Ever so slightly easier than Project 3, but this project touched a greater portion of the codebase and required more code. The frustrating thing here was that you needed to write an absurd amount of code before being able to run a single test. Overall, I can't claim this wasn't worth taking—I did in fact learn a lot about operating systems... but at what cost haha!

Pros: 1. The lectures do give a good understanding of the topics covered. 2. The textbook is probably your best friend if you truly want to understand the concepts. 3. The TAs were (mostly) responsive (kind of abrupt in replies though), and Ed was mostly active and helpful due to the students helping each other out. Cons: 1. There is absolutely no relation between the lecture videos and the assignments. Lectures cover xv86 and assignments are on pintos. 2. Expect a requirement document (which is sometimes pretty vague with the requirements); we get no clarification on the assignments unless we ask a specific question on Ed. 3. Way too much effort went into the assignments. I felt the workload was skewed heavily towards completing the assignments and then watching the videos whenever I had some time. Detailed Review: It is a good course if you want to learn about OS concepts, though honestly, the textbook (which is a free e-book) itself is the best source of information. The lectures are good, but they are way out of line with the assignments. 5 assignments over a semester honestly don't sound too bad, but wait till you actually start coding for them. The complexity grows with every assignment, and you are more squeezed to finish work on time. You do get 5 grace days, which you can use as a group. But I honestly advice not to rely on them and just start your work early, because you will need all the time you can dedicate.

Pros: 1. If you're rusty on your C, this course will throw you into the fire and force you to learn it quickly or drown. 2. If you enjoy a course with heavy coding emphasis, and a learn-it-yourself structure, you'll more than likely do fine here. 3. Book is a great read. Cons: 1. TAs not responsive 2. Lecture material is not sufficient for the new projects. 3. Project team structure is not really beneficial because the workload split is not immediately clear. Detailed Review: This class was recently 'restructured' to use Pintos as the class project. Since this is the first semester, I hope this doesn't apply in the future, but that was about all the restructuring done here. The lectures are outdated and still reference the old assignments, providing no guidance on the new assignments. To top it off, I think the project requirements are also just ported over from Stanford, so that is about all the guidance you'll get. Nothing helpful is produced by the TAs on the Ed discussion boards, if they answer at all. In total, there are 5 projects - the first an introductory shell, and the rest are Pintos projects. Projects MUST be done in groups, with little flexibility to work by yourself. Here's the issue: since the projects are so poorly guided, you'll likely not be able to take advantage of having teammates because you won't even know what work needs to be split. In my case, that meant everyone on my team working on every project by themselves hoping something would work. If you're unlucky, that might mean you implement the working solution every single time and your teammates get to stop suffering before you. On top of the coding portion, assignments also have design documents, which by themselves, are not terribly bad. These are worth 20% of each project. Lastly, the timing of the projects felt slightly off. The introductory project seems to get a lot more time than the last two projects. As is, the last month of class has you churn out a midterm, 2/5 projects, and a final. Not fun. On top of projects, the course kept its 2 exams - 1 midterm and 1 final. Exams are worth 30% of the grade. Due to how much of the course is devoted to the projects, this part of the class really felt like a separate course. You are allowed a cheat sheet for the exam, and it's wise to spend it on the outdated lectures. However, the exams were not terribly difficult. Overall, this course does let you learn a lot on your own at the expense of a stressful, high workload. You can expect to spend a good chunk of your weeks working on the Pintos projects, including referencing outside material trying to get some background knowledge. If tweaked, the course could be an enjoyable learning experience for those who are interested in OS. I would not recommend taking this course with another class.

Pros: 1. Helped me learn C and quickly 2. Learned some OS basics I didn't know before 3. Cons: 1. Projects are in "required" groups of 3-4 and you're on your own picking a solid group. If you care about your grade, you will probably end up doing everything yourself. 2. Projects were not spaced out well in comparison to difficulty. The easiest project had 3 weeks and the harder last projects (while you're trying to study for the Midterm and Final) only have 2 weeks. 3. Very little Prof or TA support Detailed Review: Not a great first impression of the program. This class was not designed with working professionals in mind. Projects were due on Fridays, instead of Sundays, so you didn't get the final weekend to work on the projects. Having two exams while doing these Pintos projects were awful. I hope the professor and TAs take the feedback from our cohort and make improvements for the next.

Pros: 1. Great if you want to learn open source PintOS crap that is already freely available 2. Great if you want to do projects that are completely disjoint from the lectures. 3. The material got an upgrade but the lectures are still from 2019, so you will be taking two subjects for the price of one (p.s. they both suck) Cons: 1. Refer Pros Detailed Review: The assignments are copy paste from Stanford PintOs which is about 10 years old, the lectures still talk about advances in CPU architecture from 2019. The course got an updgrade by going back 5 more years. The assignments are upgraded but there is no support for it, refer the KAIST materials to get an understanding of what's going on.

Pros: 1. Very interesting subject matter 2. Learn a lot of content 3. Amazing lecture book Cons: 1. Lectures are from 2019 and don't relate to class anymore 2. TA support is terrible 3. Assignment revamp leads to this feeling like two entire classes Detailed Review: The class projects are based around an educational operating system. The punchline to my review is that they switched this class from being based on one such OS, Xv6, to another, Pintos, without any update to the course material. The class is now group-based, but they don't actually have that information in the syllabus, it was announced only on Ed-Stem. The lecture material that relates to the projects only relate to Xv6. The distribution of Pintos they gave us didn't have GDB set up properly, so they had to send us a new copy. Instructions on assignments are extremely vague. I get the impression that with Xv6, this class was challenging but doable, but now this was easily a 20+ hour a week course for me. As a side note, the textbook is amazing and available for free. It was not relevant to the projects, but I learned a lot from it. It is really a shame, because the subject matter is fascinating and I found that I learned a lot from it. I think this is still a class to take if you are interested in learning about operating systems, but be prepared for a stressful semester if you are also working full time.

Pros: 1. Course is oriented towards programming. 2. Engaging topics on operating systems. 3. Cons: 1. The class relies heavily on group projects, yet many participants lack sufficient C programming experience, making it challenging to contribute effectively to some of the more demanding projects. 2. Both teaching assistants and the professor were unhelpful. 3. The project schedule was poorly planned given their complexity. Detailed Review: The structure of this course is fundamentally flawed. While the subject of operating systems is fascinating and crucial for computer scientists, this course fails to facilitate effective learning. Firstly, the lectures were entirely pointless, outdated, and provided no aid in understanding the projects. I ceased watching after the first lecture due to their irrelevance and the professor's poor presentation skills. Secondly, every project had to be completed in a group, yet most students did not possess the necessary C programming skills to manage them effectively. The Pintos projects could be completed in a week if all three members equally contributed. In reality, if you care about getting a good grade, you will end up doing all the work. I had to change group members multiple times because one would drop the course and completely ghost us until the deadline. My group members often gave me false hope about their progress, only to reveal at the last minute that they had only written a few lines of non-functional code. Consequently, I had to take holidays from work to complete all the projects myself. I also had a group member who tried to give me a psychological lecture on forgiving another student for failing to write a single line of working code for several projects, instead of properly addressing the issue with the TAs. Ultimately, I had to complete an entire project by myself. Why would someone enroll in a coding class without coding skills? Why claim to have a good level of coding skills when forming a group, only to leech off others? Additionally, when we raised some of these issues with the TAs, their solution was to split our group into two, letting the slacker be graded on the complete project that we implemented instead of his failed attempt. This is not proper conflict resolution. Lastly, the teaching assistants and professor were extremely unhelpful. Their inability to provide meaningful support made external resources like YouTube a better option for understanding how to complete projects.

Pros: 1. The PintOS projects are very interesting and I think the perfect amount of challenge for a Masters program, it is definitely not too easy, and in my opinion appropriately difficult. 2. The class does teach a lot and I think one will feel like they improved a lot at C and understanding OS. 3. There are many resources online to help you deal with PintOS, just unfortunately, none of it came from the professors. Cons: 1. Professor and TAs were not responsive on edStem. 2. Lectures were completely useless, I had to rely on outside lectures 3. Textbook was useless to me. 4. Pacing of the class is terrible, project 0 is wayy too easy but given 3 weeks. Last two projects are very difficult and given the same or arguably even less time. 5. Groupwork in the class was terrible Detailed Review: Overall, I actually liked AOS, I feel like I learned a lot and tackled interesting problems related to kernel programming and understanding how OSes are designed. Unfortunately, the class overall kind of saps your morale. There is literally zero support from the TAs, professors and lectures. In contrast to some reviews where it said the Professor posted frequently, the professor posted 0 times. We only had an adjunct instructor. The recorded lectures are from 2019 and do not talk about PintOS at all, and are overly general and not very interesting. It is hard to watch them. The TAs my semester were completely unhelpful, and did not help with debugging any code issues. Lastly, the groupwork was a serious stressor and exacerbated a lot of the problems with the class. I did multiple projects entirely on my own with no assistance from my groupmates, who all seemed to just give me lip service, barely were able to push working commits. I didn't understand why they were in the program if they didn't seem to want to learn, it looked like they were more busy with their actual lives. Which is fine, I understand some people just want a piece of paper rather than learn. I changed groups in the middle of the semester, which I think a lot of people did, and still was unhappy with my group overall. Lastly, the pacing of the class should be fixed. We were given 3 weeks to do project 0, which was practically trivial and could be done in like 2 days by most people solo. I wish we were given those extra weeks in January doing the very hard later projects. I was super demoralized by project 4 and just wanted the class to be over. I strongly think that the class should just move to individual projects. Whatever help i got from groupmates was just totally wasted by having to manage them, it was like herding cats. Maybe in an in person university we could form better relationships, but in an online asynchronous class where everyone doesn't really know each other, and cannot really meet in person, or choose group members they know and trust, I think it caused a lot of bad feelings and animosity in the class. I know real life software development is about working in teams, but my gut tells me what I experienced is not how real SWE collaboration is. After saying all that, how did i manage to enjoy the class? I did so with the help of my substitute professor, Professor Youjip Won from KAIST: https://www.youtube.com/@ee415intro.tooperatingsyst8 I strongly recommend anyone who takes this class just listen to all his recorded lectures on Youtube and to ignore Vijay's lectures, he has a very detailed rundown of how the PIntOS codebase works, offers useful hints on how to do the projects, and sometimes even has tips on how to debug your code. And he teaches you OS concepts too. He easily made the class the reason I am giving it not a 1 overall. And he is not even a UT Austin employee, which is why I am so disappointed in the program. Overall, this class made me disappointed in the quality of the UT MSCSO program. Most of my learning was from a different professor, using a project that was copied from Stanford, a different university. I was not impressed with the caliber of the other students. Why am I paying money to this University? To get a piece of paper? I wish i had given $1000 to some stranger who could have told me to spend a semester doing the 4 pintos projects, publicly available online for free, because that is exactly what happened.

Pros: 1. Textbook is fantastic, very readable. If you just want to get by the midterm, just watch lectures. If you want to go more in depth and learn, read the textbook. 2. Lectures are overall not too bad, worth watching at 1.5x. The lecture content hasn't changed since 2019 afaik, so all the previous reviews mentioning lectures apply. 3. After grinding out the projects, I got way better at C/systems programming. Cons: 1. Grouping mechanism needs work. Had unauthorized people try to join last minute before a project was due w/o Canvas issuing any notification whatsoever that someone joined your group. In general, people can join your group at will. TA said Vijay will be looking into this. 2. Like the previous 2024 review mentions, the class switched from xv6 to Pintos and the projects became significantly harder. 3. Some say harder than Parallel Systems now (I haven't taken PS, so no comment) Detailed Review: Last two projects took 30-40 hours/week easy. A few TAs carried the whole semester while the other ones were afk. Lecture material on xv6 hasn't been removed, and only one Pintos lecture (an overview/intro guide) has been released so far, so our cohort got scant Pintos guidance other than the assignment descriptions and EdDiscussion responses. Everyone was watching Youtube videos from other universities for project-specific Pintos guidance.

Pros: 1. This course is very challenging and will greatly increase your C programming skills. 2. In hindsight, pintos is an awesome project, and would be a lot of fun to work with in free time for OS enthusiasts 3. Cons: 1. The first semester of the new PintOS projects made this course wildly more difficult than previous reviews made it seem. 2. With the new course format, the lectures are effectively useless. 3. Expect workloads of 15+ hours per week unless you are already familiar with the PintOS project or another lightweight x86 OS. Edit: I'm modifying this and dropping the rating further after taking the final exam. The final exam is even further removed from the course content than the assignments and midterm and has multiple extremely nuanced/tricky and even opinion based questions. Detailed Review: I'm not sure what happened when they revised this course, but they are still clearly working out the kinks. In hindsight, conceptually the assignments themselves are not particularly difficult. The issue that arose for the group I worked with (and I assume many others) is the fact that PintOS is a moderately large code base. As a group we spent tens of hours over the course of the semester just figuring out where things were located and what they did. For reference, there are 17,000 lines of code in the code base and each project will add/remove ~1000 lines across 10-15 files. You are provided the benefit of working in a group, but unless you know where to start and what needs to be done ahead of time, you typically just end up working on the same portion of a given project until one of the group members finds something that sticks. All of this would have been fine, except for the fact that the lectures and reading material are entirely disconnected from the projects. This course is currently advertised as a course where an introductory os course is not needed for success. I don't think that is the case. For reference, I took parallel systems prior to this course and found the assignments and content far more straightforward and frankly less difficult. On the bright side, successfully implementing the projects does feel very rewarding and it will genuinely improve your knowledge of operating systems and virtualization. However, this comes at the cost of slamming your forehead into your monitor half the time trying to run down a 76 line kernel panic that it turns out was just trying to free an already freed file in the file system. Breakdown of projects and time: Project 0: Wish shell ~4 hours per team member/week Project 1: Threads ~10 hours per team member/week Project 2: User Programs ~15 hours per team member/week Project 3: Virtual Memory ~24 hours per team member/week Project 4: File System ~20 hours per team member/week TLDR: tough projects, lack of piazza support, and meaningless lectures. The projects are tough and not particularly fun, but they would be significantly more valuable if the rest of the course was centered around them.

Pros: 1. The lectures align well with the course material and help to build on the more practical knowledge gained by doing the assignments. 2. The exams were very fair. You can use some notes, and the honor system was used instead of formal proctoring. 3. The projects are very reasonable workload-wise, and do help you to connect the major ideas of the material being covered. You can get an idea* of how you will be graded by running the grading scripts locally prior to submission (* does not cover all areas of grading, however; see Con 1A). Cons: 1. The course now has two curveballs that weren't present in prior iterations: A) Projects must be completed individually (no group collaboration), and B) The project grading now features "hidden test cases" - i.e. we'll grade you on some things we didn't ever tell you to code in the assignment details, but hope you did anyway. 2. Brush up on memory management in C or you will suffer during the first couple of projects, which require you to compile with the "-fsanitize=address" flag (meaning fairly innocuous memory warnings will instead throw errors and prevent your project from compiling, even if they wouldn't make much difference in the real world).

Pros: 1. TAs are extremely responsive and helpful 2. Pre midterm course videos are good 3. Gentle ramp up which is helpful if this is your first course in the program 4. Fair exams in terms of difficulty Cons: 1. Some assignments had tricky test cases buried in a heap of posts on Piazza 2. Professor was non existent, course was entirely run by TAs 3. Post midterm, the lectures got longer, drier, and almost a pain to go through. Detailed Review: This was my first course in the program and the only subject I took in the semester. The C ramp up was gentle with Assignments 1 and 2, but can be intimidating if you have 0 C experience. Project 3-5 were the actual OS projects with xv6 and can take considerable amount of time. The patch submission process was efficient but stressful at times. TAs was brilliant with the Piazza support though. The Prof looked more at home in the first half of the course, however the second half was borderline unbearable for me personally due to the length of the videos and almost 0 direct practical applicability and relation to projects. This course won't demand much if you studied OS in your undergrad. The exams were well formed and good enough to test whether you studied the material well or not. Overall, I would recommend this as a first course in the program to get used to the system.

Pros: 1. 2. 3. Cons: 1. 2. 3. Detailed Review: Pros: 1. Project not too hard Cons: 1. test cases are hidden, be sure to check if your memory is leaked 2. there are hidden test cases 3. you only know your grade after the project deadline, no gradescope

Pros: 1. TA's were helpful 2. If you have A good background in C its easy, and if you don't it is a good intro 3. Cons: 1. A lot of work during the summer 2. Lectures and hw didn't really match 3. Hidden tests for hw can be annoying Detailed Review: During the summer it is a lot of work, and I felt like some of the assignments should have had more time. However, the course is a decent intro to C if you are new to it, but it will be better in that scenario to take it during the fall or spring as you will have more time to learn as you go. In the summer I only recommend it for people with a decent background/understanding of C. TA's generally responded quite fast. I only watched the lectures around exam time as thats the only place they are quite useful. One big complaint for me were the hidden tests, due to limited submissions onto Canvas, you had to try and figure out all edge cases and hidden scenarios and be able to test them which added more time, which was a bit hard during the fast pace of a summer course. Textbook isn't necessary but I found it useful in understanding the concepts to prepare for exams.

Pros: 1. Very doable for people without systems/OS background from work or undergrad 2. Will introduce those unfamiliar with C to pointers, memory management, Makefiles, gdb, etc. 3. Manageable workload even for accelerated summer semester pace Cons: 1. Depth explorer is at an undergraduate level. Advanced topics only touched on at a surface level 2. Lectures only really needed for exams. Textbook and xv6 guide a far better guide for homeworks 3. TAs were very helpful but assignments had some contradictions/unclear instructions that took some time to resolve Detailed Review: I would recommend this course for anyone early in the program. It gives a good background on systems programming and OS concepts (CPU, memory, and storage virtualization) as well as some good practical experience with C through the manageable projects, which is valuable for any software engineer or developer. Anticipate needing some catch-up time at the beginning of the course if you have never worked with C before. The course does cover several “advanced topics” but does not go in depth. All that is needed is pure memorization (for the open-ended response exams) of points from broad lectures concerning topics like containers, persistent memory, multikernels, etc. There’s nothing stopping students from pursuing research in these advanced topics beyond the course, though. Overall, good course, but do not expect this to be a truly “advanced” operating systems course. ~12h/week due to accelerated summer pace. 8-10 is probably more accurate for a normal fall/spring semester.

Pros: 1. Great professor, knows what he's talking about 2. Low/Medium workload 3. Very lenient grading Cons: 1. The lectures for the most part are unrelated to the projects 2. Steep learning curve with xv6 Detailed Review: In my opinion, this is a great first course. The professor is great and the TAs were reasonably helpful. The setup for the assignments was a little painful and there was some confusion around which Ubuntu version would be used for grading. It takes some time to understand the xv6 codebase but after that, the assignments themselves are not the most challenging things. The mid term exam was not easy, there were questions which tested the understanding of fundamental concepts like paging however grading was very lenient. The final exam was very easy.

Pros: 1. Lectures are easy to follow 2. Plenty of time for projects 3. Professor offers "grace days," which can be used to extend deadlines Cons: 1. Lectures seem to drag on; could be shorter 2. Midterm had a few tricky/esoteric questions that didn't seem well covered in the material 3. Lectures cover too much material that isn't relevant to the projects; so the course is disconnected in that sense (similar to DL) Detailed Review: I only spent 4.5 hours / wk on average, so this is a great course to pair with another course if you have some prior experience with operating systems or the C programming language. If you're wondering how to budget time, this was my breakdown per week: - W0: 2.5 hours [Project1: reverse] - W1: 1.75 hours [lectures] - W2: 1.25 hours [Project1: wcat, wgrep, wzip, wunzip] - W3: 1.5 hours [1 hour (Project2: setup, shell); 0.5 hour (Project1: cleanup and submission)] - W4: 5.25 hours [3 hours (lectures); 0.25 (Project2: shell); 2 hours (Project2: syscall)] - W5: 0 hours - W6: 4.75 hours [Project2: shell) - W7: 6 hours [5 hour (Project2: shell); 1 hour (Project2: syscall + submission)] - W8: 8.25 hours [4.75 hours (lectures); 0.5 hour (quizzes); 1.75 hour (readings); 1.25 hours (midterm)] - Spring Break: 11 hours [7.25 hours (Project3: null-pages); 2.75 hours (lectures); 1 hour (readings)] - W9: 7.25 hours [7 hours (Project3: threads); 0.25 hour (Project3: submission)] - W10: 0 hours - W11: 1.5 hours (Project4: mmap part 4a) - W12: 2 hours (Project4: report, misc., submission) - W13: 0 hours - W14: 9.5 hours [6.25 hours (lectures); 1.25 hours (readings); 1.5 hours (quizzes; final prep); 0.5 hour (final)] - W15: 8.25 hours [7.75 hours (Project5); 0.5 hour (Project5: submission) - W16: 0 hours

Pros: 1. Fun homeworks 2. Helpful TAs 3. The textbook is actually fun Cons: 1. Easy to get lost in the C sauce Detailed Review: I really enjoyed the class and the group projects - I think it was very manageable and clear and interesting. I wish that we could have a little more explanation of the basics of XV6 (the sandbox OS for the class) before getting started, since it can be really confusing to have to dig for things all over the file directory.

Pros: 1. Course content is excellent for anyone who has never taken the OS before 2. Project is simple at first, and nice for beginners. 3. Midterm and final exams are simple 4. Group project, so you can help and work together with your teammates Cons: 1. Poor lectures; do not waste time listening to them 2. 3. Detailed Review: I have never taken OS before, so I really learn a lot in this course. I would suggest that anyone who has not taken OS before take this one. Poor lectures and poor slides. I have watched all videos, and I feel confused about most of the lectures. The contents are given without clear logic. Later I spend several days watching an undergraduate OS course video from Remzi on Youtube, and his lectures are much much much better and easier to understand, and his slides are also much much much clearer. DO NOT WASTE YOUR TIME IN THE LECTURE VIDEOS if you haven't taken any OS course before. WATCHING LECTURES FROM REMZI ON YOUTUBE instead. OSTEP (https://pages.cs.wisc.edu/~remzi/OSTEP/) from Remzi is excellent, and I read it more than 3 times (before lecture + after lecture + before exams), and I really lean a lot in this way. Read all the books instead of just the selected chapters required by the teacher. This book is like a novel, you need to read everything from the beginning to the end. I like the projects, and I am very lucky to have two teammates, who helped me debug my codes, and criticize my work. I wrote almost all the projects myself, and I really enjoy this process.

Pros: 1. Straightforward exams and assignments. 2. Good if not interested in doing heavy systems-related work. 3. Responsive TAs and Professor. Cons: 1. Bad if interested in learning more about low-level systems and OS. 2. 3. Detailed Review: I liked the course and thought it's a good course for folks coming into the degree. I am not particularly interested in systems-level programming and what it entails, so it was refreshing seeing the level of difficulty this course was. It's an upper-division undergraduate OS course so take that into consideration if you expect OS-related research etc. Most of the time you will spend reading over xv6 documentation not so much programming the solution which is the norm when it comes to large codebases. In exams, you are allowed one page of notes and not proctored, even then if you pay attention to the videos and do the assignments you probably won't need this. I had a fine time and not having to be stressed over a course for a semester was nice.

Pros: 1. You get a systems credit for the degree. 2. 10-15hrs a week. 3. Book is easy to read. Cons: 1. Lectures and book to not correspond to the assignments. 2. Lectures are generally a waste of time, so only the advanced topic lectures are required if you read the book. 3. Assignment are challenging simply because the course does nothing to help, and instead they require googling. Detailed Review: I found this course to overall be the an equivalent workload to NLP, at about 10-15 hours a week average. The majority of my time was spent reading the book and getting through lecture material that is not in the book to prepare for the exams. The course materials only pertain to the exam topics. There are 5 assignments and I found the second assignment to be the most time consuming. Assignments 3-5 involve modifying the Xv6 operating system. Unfortunately the course materials, including the Xv6 commentary book, do not actually discuss the areas of the Xv6 OS that we have to work with in these assignments. For example, modifying malloc system call is required, and if you search for malloc within the Xv6 commentary there is zero discussion or notes. This is basically the result of searching for any course materials pertaining to the assignments. The lectures also do not discuss anything related to the assignments, other than surface level discussion on CPU and memory virtualization. Therefore you must google and research to find discussions and materials from other classes that give more guidance and discussion on the areas of the Xv6 OS that you will modify.

Pros: 1. Excellent range of topics, explained in a detailed and easy-to-digest fashion 2. Implementation-heavy course, hands-on work with C & kernel development 3. Exams are reasonable and high-level. Cons: 1. VM setup can be very tricky without a guide from TA's 2. Grading is very slow, and not automatic. 3. Advanced topics are very high level, sometimes difficult to comprehend without hands-on experience. Detailed Review: Excellent course, I really enjoyed it and felt that I learned a lot. Time commitment and projects were reasonable. Exams were short answer with no invasive proctoring software. I highly recommend this course.

Pros: 1. Good assignments 2. Textbook was informative and easy to read 3. TAs were responsive on Piazza Cons: 1. Some of the lectures were a bit slow 2. If you've already taken an undergrad OS course this will mostly be a review 3. Detailed Review: For background I don't have a CS degree, have never taken OS before, and didn't know C before taking the course. Overall it wasn't too bad. There are 5 assignments and 2 exams. The first 2 assignments are fairly easy and allow people to ramp up on their C knowledge. The later assignments were more difficult but the TAs and Piazza helped. I spent about 20-30 hours a week on this course in the first month because I was learning C while trying to do the assignments but afterwards I averaged about 10 hours a week.

Pros: 1. Exams were fair and good for learning 2. Learned a lot from the projects 3. Info very relevant to industry Cons: 1. If you are looking for more of an advanced look at operating systems, this probably won't scratch the itch. 2. 3. Detailed Review: I really enjoyed this course. I started out with very little OS knowledge, and pretty weak C programming ability. By the end of the semester I feel much stronger working on large (ish) systems code, and I think I gained a pretty solid OS foundation with exposure to advanced and current topics. If this isn't going to be complete review for you, I highly recommend it.

Pros: 1. Good introduction to OS fundamentals 2. Practical experience by working with the xv6 kernel 3. Lectures and book are well aligned with projects and exams Cons: 1. "Advanced" topics are covered, but far from the focus of the class 2. Team projects are difficult to collaborate on Detailed Review: As I hadn't taken an OS course before, I appreciated how this covered the fundamentals (as the book is titled "Three Easy Pieces"). However, if you have already taken an OS course, I suspect much of this will be review. Some advanced topics were covered, but they weren't anything too novel. The projects heavily rely on C and pointers, so if you aren't familiar it will take self directed time to learn. Projects count for the vast majority of the grade. They are done as a team that is formed by the students, so it's luck of the draw if you get a team that is able to contribute or not. The projects can be very difficult to divide the work and will likely have a single person doing most of the heavy lifting. Fortunately, tests are provided before submission which can be used to validate your solution. Exams followed lectures closely, were open notes, and overall not too difficult. Overall, I recommend this course so long as you aren't looking for truly "advanced" OS work.

Pros: 1. The course is quite practical. You learn by doing during 75% of the semester. 2.The first programming assignments are a great C refresh. You must learn C to an intermediate level to continue. 3. The professor is really comprehensive and helpful. He and the TAs put a considerable effort to understand why your homework fails and give partial credit if needed. Cons: 1. The lectures tend to deviate from the core concepts and the teacher spends too much time repeating the same diagrams over and over. This is not necessarily bad but I feel is kind of repetitive. Maybe it was better to have prepared material and draw/write just the difficult ideas. 2. The lectures are way too long. I'd prefer to have several 5-10 min lectures than a few 45-60 min ones. 3. The time spent looking at advanced topics is limited, and it's a brief overview over only a few topics. That is not enough to call it an "Advanced" course Detailed Review: I really liked this course. It was enjoyable even-though I didn't have any previous preparation on OS. The homework is practical and that's a relief for a part time student like me. I feel that the lectures can be improved to give away some studying material (like slides) and should be a bit more digested. The teacher and the TAs were nice. I didn't like that the lectures lacked of enough information to tackle the homework. You needed to figure out several aspects of it. Such homework had always hidden test cases and a newbie on OS like me never figured out those hidden features to implement. Another bad point is that the homework is an exact copy of the xv6 exercises. Didn't like that part. The homework should be at minimum a slight variation of that material.

Pros: 1. Good refresher and general overview of OS principles 2. Projects are not difficult if you're comfortable with C 3. TAs and Professor are responsive and knowledgeable Cons: 1. More of an undergrad upper division OS course 2. Didn't get into networking, internet protocols, security, etc Detailed Review: You need to be fluent in C to do well in this course. The project are very manageable and the deadlines are extremely generous. The professor really knows the topic, and the lectures really helped unravel some rather tricky topics in OS like memory management. During our term, we had three very dedicated TAs who went out of their way to provide clear guidance both during OH and on piazza. All in all, pretty fun class and you learn how to write kernel code. My only gripe was that we didn't get into networking and security.

Pros: 1. Good overview of OS 2. Helpful TAs Cons: 1. Moves a bit slow 2. Doesn't cover a ton of advanced topics Detailed Review: The class is overall decent. The professor is knowledgeable and seems to want to teach, but can be extremely dry at times and has some long lectures. The textbook can be helpful if you want more knowledge. The first half of the course felt like more of a review basic intro to OS concepts and the course didn't get into anything all that advanced until the second semester. Projects are doable but not all that interesting. They'll take a bit to do if you're new to C. The xv6 projects will mostly consist of trying to understand the xv6 kernel and trying to find random edge cases that were briefly mentioned in a piazza post. TAs were generally helpful and usually got back in a reasonable amount of time.

Pros: 1. Not to difficult. 2. 3. Cons: 1. Class is slow. 2. Projects are not covered very well. 3. Detailed Review:

As others have mentioned, this is a C-heavy course, so make sure you brush up before the course, or plan 20-30 hours extra at the beginning to pick up the core concepts. Note that some of the difficulty in this course comes down to understanding a lot of the nuance of how memory is managed in the system and how you manipuate it in C. The exams align well with the textbook and lectures, but the projects are a separate beast. The projects build on one another from the beginning, so you really need to keep up with them or you can get behind quickly. As a professional software engieer, this course was very relevant and I picked up a lot that helps day-to-day work. Top-notch instructor! Total time end-to-end was 222 hours, which is roughly 14 hours a week.

The lectures were good, the textbook is amazing but still giving it 2 stars coz 70% of the grade comes from projects and the lectures barely relate to them. I found the xv6 projects to be very hard and think that they should have at least explained the xv6 code base in the lecture videos. Being a systems course, there should have been some programming in the lectures but there is almost none and for the most part you have to constantly look up stuff on the internet. I do not have any experience in systems programming and found the course to be quite stressful.

Great class. The lecturer is decent, but the textbook is very good, and free! The assignments are easily painfully easy or quite frustrating; there were a couple of moments where I hit a roadblock and it was impossible to make any progression without TA help. Midterm and exam were fairly easy; just watch the lectures and make a few notes.

I personally really enjoyed this class. The teacher knows exactly what he's talking about and explains things very clearly. I have no background in OS and had to listen to certain parts several times to really get it. But the professor explains things very in basic concepts very well, quite helpful for me. Exams are straightforward short answer. Study the lectures and you will do great on the exams. Projects are more tricky. Not much introduction to xv6 is given before asking you to understand a lot. Google saved my life. There are Medium articles and Youtube videos about small things like adding system calls that were very very helpful.

I really enjoyed the subject matter. Teachers were cool as well. I have pretty heavy experience with C/C++ so the projects were relatively easy compared to the other classes I've taken.

The book is your savior and is absolutely hilarious, ridden with sly jokes. The author and I must share a very similar sense of humor. The exams are not very fair. Review 3 said the projects are dry. This is a severe understatement, they are drier than your mother in laws chicken she unequivocaly makes every time you come over--hopefully this statement resonates with at least one person and provides he or she the comfort that they are not alone in this unspoken subjugation. The projects require a dummy amount of research.

The class was simple. The lectures and homework is understandable. The exam was pretty easy as well. But I did not like how optional lectures were needed during the exams.

Need to do a fair amount of reading to really understand how to complete the projects properly. Follow the course readings and the additional documentation for the homeworks. It's dry, but worth your time. If you don't know C, you should be able to get up to speed just by completing the assignments. You'll probably start to feel more comfortable after the first few. Had a light C++ background, a bit of assembly knowledge, and a Computer Architecture course under my belt before taking this class.

The textbook is awesome and the projects were great and I learned a lot. The lectures were kinda rambly and just summarize the same content in the textbook. Honestly, just skip the lectures and read the textbook. The professor is very responsive and helpful on Piazza which also helped clarify a lot of things. I found this course easier because I already knew C and Assembly, I recommend brushing up on your computer architecture before taking this course.

Theory lectures are good, but majority of the grade comes from c based projects, where if you don't know the language, you're in for a bad time. No solutions are posted, and you're exptected to figure things out for yourself(very little programming done in lectures)