The course is insightful and covers good ground in terms of operating systems and how they work - This course is great for any CS student who isn't sure of what the OS does and how. The course gets into the weeds of the Linux kernel which depending on your point of view can be good or something that will haunt you for the rest of your days. There are very good reasons why you should take this course but be sure of your reasons and make sure you have the time to dedicate to this course because it is time-consuming and mentally draining in some ways. The rest of this review can kind of be summarized in -"Workload is hell be ready for the pain going in" PSA: If you're a masters student who already understands OS well enough and isn't from the software systems track and doesn't really need to enhance their C/linux kernel programming - DO NOT TAKE THIS COURSE (unless you like to suffer in which case nothing better really) Hours upon hours are spent staring at the Linux kernel and going one level deeper till you've opened up 70 tabs and you've forgotten where you've come from who you are and why you even exist. The first homework has really strict grading but is otherwise easy, aside from that though the rest of the Homeworks are a pain although they do broaden your horizons I would have been happier to not deal with them Office Hours are a must if you hope to survive and are not already a kernel GOD and luckily we had a good bunch of TAs who understood the material and were mostly willing to point you in something of a direction(god help your souls if you gets a bad bunch of TAs which is unlikely). If you get a bad team you will get torched and the 40+ hours that it usually takes per homework could easily turn into double that (I lucked into a good team but I saw the fate of others) The finals and midterms due to the COVID semester were open book/note and coding based and quite related to the homework and not so much linked to the theoretical lecture content. I think it will go back to whatever it was earlier after COVID
OS with Jason Nieh is the most painful yet rewarding studying experience I've ever had in university. It is also one of the few moments when I feel Columbia is worth its tuition fee. AP turned to out be a very easy course for me and I grew so arrogant that I thought the rumors out there about the insane workload of OS are just rumors. But these "rumors" are real. THE WORK IS INSANE. Nieh's lectures are pretty clear, but they are not easy to follow if you don't read the textbooks or kernel codes in advance. I didn't do the readings for some lectures and I had no idea what he was talking about after he went to "out handy dandy source code." I agree with the last review that he did try to talk about things at both high and low levels. Most of the kernel codes he walked us through did help with the homework. The Homeworks are just everything they say. Homework 1 and 2 are easy. Homework 1 is a simple shell and some assembly, the number of hours I spent was similar to Lab 7 in AP. Homework 2 is adding a system call and it is basically used to familiarize us with kernel programming. But HW3-6 are crazy. Each of them easily took more than 40+ hours. Textbooks didn't help. Google didn't help. Reading documents didn't help. Lectures didn't help much. The only thing that helped was tracing thousands of lines of Linux kernel source codes. Debugging was very difficult in the kernel. Every time I triggered a deadlock, my heart would freeze together with the system. I seldom went to office hours for other classes but I did this about twice a week for OS. Xuheng Li is one of the cleverest and most careful TAs ever! However, the grading of homework will only ruthlessly use a script to test a bunch of if not all the corner cases and deduct a lot of points. The average grade for HW3-6 is around 50%. A final word about the comparison between Nieh and Jae: they are both great teachers but their styles are different. Based on my experience taking AP and visiting his OS website, his lectures and homework instructions seem to be more hands-on. His OS section also covers some advanced user-space C programming, which is not touched in Nieh's section. I guess taking OS with Jae will have more work to do but the process could be potentially smoother.
"I'm a really big fan." - Satan
Echoing the most recent review (from January 2020), this course lives up to its reputation and is a ton of work, but is very rewarding. The workload is still the same 6 homeworks involving written and programming, with the last 5 programming projects done in groups of three. Averages on the hw are regularly around 50/100, and they are a serious time commitment. The rubrics (especially for the early hws) are very difficult and you need really robust error checking to get a good grade. Get a good group and start the homework early, or your projects will not work. The kernel development can be very confusing, and even if you know what to do, you will run into random quirks in the kernel code that takes forever to debug. In general debugging is very difficult. So the course is definitely very difficult. I took it during a relatively light semester, had a good group with one member, in particular, carrying a lot of the work, and this class still made this semester pretty stressful. The first homework which is individual involves writing a shell program, and I would say is as hard as the harder AP labs (maybe slightly easier than lab 7?), and the next five get way way harder (though you have a group). I also agree with the 2020 review that I don't think Jason's class is that much harder than Jae's, but Jae seems to give you a little more guidance in how to write the kernel code for the hw. Jason's lectures are sometimes very high-level, but for some of the later hws, he definitely shows in class the parts of the kernel code you need to understand to do the hw. Understanding the kernel code is just hard. But overall, this course also makes you learn so much and makes you really understand how your computer works. If you are an upperclassmen CS major who still feels like you don't understand how computers actually work and did decently well in AP, I really think you should try to take this class (either this section or Jae's). You will learn a ton and become a much better programmer, both from doing lots of low-level programming stuff and from how much better you understand how computers work. If you struggled in AP, though, this class will be very challenging and you should take a few more programming intensive upper-level courses before taking this one. But if you're a CS major who actually wants to have a decent grasp of how a computer works (which as a CS major hopefully you should!) take OS before you graduate.
It is everything they say it is, but Prof Nieh is one of the best professors I've ever had the pleasure of studying with at Columbia CS. His lectures are very clear and he's super kind and approachable. Also, comparing notes with my friend who took OS with Jae, I'm not sure Jason's is the harder rendition as it's been rumored to be. The TA's this semester (Fall 2019) are also very good and went out of their way to help students with the assignments, and preparing for the exams. Granted, I took the class with a 4-course semester so maybe that's part of why I managed it okay. Still, if you're interested in how the operating system works, would recommend that you throw away your fears and just take it.
Given the last review for Professor Nieh was written in 2013, I figured it is worth to share some more thoughts on this class. This class is everything they say it is. Nieh will teach you everything you need to know about Operating Systems, and then some more. His lectures are fast-paced, dense and sometimes difficult to keep track of. However, he is a very good lecturer with an impressive command over the material. He will answer several questions during class, which sometimes gets frustrating as he digresses. If you pay attention, you will learn a lot, but you will often have to back up the concepts with the textbook to actually master the material. And then there are the homeworks. Oh God. Nieh will talk about the concepts in class and he will talk about the homeworks a little bit, but to be honest, you are all alone. They involve writing code into the Linux kernel. Not only do you have to read A LOT (I mean, A LOT) of C code to figure out what you need to do, you also have to be really good at C to actually implement what's expected of you in a reasonable amount of time. Expected to spend 10 hours figuring out what you actually need to do before you write a single line of code. Expect to actually skip homework on other classes to finish these assignments. They will make you a great coder (especially if you want to be a systems programmer), and you will actually master reading Linux source code by the end, but it's a ridiculously rough patch. You will also have to demo your completed homework to a TA after it is done. Here are the breakdown of each of the programming assignments: - Writing a bash shell. This one is the only individual programming assignment and also the only one not involving kernel programming. It is probably the easiest to do, but it'll still take around ~10 hours to finish. I see this more as a weed-out assignment for the students who aren't as confident in C. - Writing a system call to keep track of Android's interprocess communications. This is the first time you will write code for the Linux kernel and also the first time you will write a system call. It's not actually that difficult, but takes a lot to get used to the programming environment. - Writing an interface that sleeps selected Android processes and makes them wait on designated light intensity levels. The main emphasis here is concurrency / synchronisation. Starting from this assignment, you will actually be using a physical Android device, which Nieh makes you buy. Expect to pay a total of $200 as a group of three. - Writing a process scheduler for Linux. This is easily the most difficult assignment in the class. Most of the teams actually didn't do it and dropped the assignment. My team spent over 30 hours and still got a failing grade. I'd still recommend you to attempt it, since you may be tested on the homework. - Exposing process memory to the user. This is the assignment that has to do with memory and paging in Linux. Conceptually can be a pain to figure out, but it's not actually a lot of lines of code. There are some weird Linux-related bugs which slowed us down, so expect to find hacky ways around them. - Writing a file system for Linux. This wasn't that bad because the TA's set the homework up pretty well, but just like all the other homeworks, it's again a lot of time. Don't expect the grading to be nice because the homeworks are hard. We were constantly tested on weird edge cases that we didn't think of. Nieh expects the highest of you despite how difficult it is to even set up the groundwork for a lot of these assignments. TA's: Some are very good and some are very bad. Don't expect office hours to be helpful, they are overcrowded and if there are students scheduled to demo their homeworks, you won't get to even ask questions. Textbooks: There are two. One is very helpful for programming for the Linux kernel, especially early on. The other is helpful for the written components of the homeworks and for studying for the midterm and the final. If you could get one, get the Linux programming one. Both of the tests are also difficult, with class averages around 50-60 percentiles. You may be asked on anything you did for this class, from the lectures to the homeworks. Finally, grading is OK with a mean around B+, but you leave feeling it could be more generous given how much work and patience this class expects of you to even get a score around the mean. Despite all of that, if you do your work, you will learn an incredible amount about operating systems, C, Linux, systems programming, concurrency, and even more.
A benchmark class, indeed. I am happy that I took it and improved my "C" programming skills, especially in the OS domain. Prof. Jason Nieh teaches the course very well. Apart from the skills and experience in the areas - Operating Systems, Linux kernel programming, this course demands a lot of your "C" skills. If you are a HardCore "C" fan and would love to experiment at system level in "C", then read on! This one class is for those who crave for "C" programming a lot! You will get your hands dirty while building crucial features of Linux kernel on an Android device in "C" involving Synchronization, Scheduling, Paging, File Systems, etc(as per the projects in Fall 2012). You will fine tune your "C" skills yourselves mainly in the area of optimizing the usage of the kernel resources in terms of memory. You keep an eye on what each function ends up returning to determine its success or failure - this comes with practice if you aren't in the habit! The grading rubric is the most comprehensive one I have ever seen in my life. For each of the assignments/homework, the rubric would cover every nook and corner cases that a novice "C" programmer for Linux kernel would definitely ignore. Well, in the beginning you would find each of your submission being bitten by checkpatch, for not abiding by Linux kernel coding style. But, with time, your "C" coding style becomes smooth and elegant if you start respecting what that seemingly strict master(checkpatch) says, trust me! Ah, userspace programs for each of the assignments! Well, I enjoyed much by dwelling in "C" while building the user space test programs for testing the Linux kernel features implemented in each of the assignments. You would be asked to demo each of the Linux kernel features you would implement in each homework and during the demo, well, how dedicated you were in testing your code gets rewarded when the standard test code(which they would have in their repositories) completes without any problem and you hear TA saying, "That's cool!". TAs were very helpful in answering the questions we had. Sometimes, we had to bug them and get the information what we want - but, they were all nice and had good hold on the subject. Among them, I found through live and piazza discussions, TA - Alex to be damn good in the subject. I feel it's important to mention that the solutions they would publish are simply beautiful. The solutions implemented by Christoffer Dall were mesmerizing. No, am not exaggerating at all - his coding style is so pleasing to eye and his code looks very simple and precise! Peer reviews: Yes, you would get opportunities(or responsibilities?) to review and grade other people's code. Here, I was annoyed at certain times of seeing some seriously senseless code from other people. At other times, I had also the chance to look at some brilliant code. So, overall, there was a good exchange of knowledge and suggestions between our team and various teams. Yeah, btw, try to form a good competent team - believe me, it's better to have arguments and come up with some kick-ass code which scores beyond the average code resulting from an average interaction or no interaction at all between you and your teammates. And this is from my experience!
Well, this is one course of Columbia of which I am proud of. There is nothing compared to this course that Columbia can offer and I guess Prof Nieh is THE best person to teach operating system course. Prof Nieh is great teacher and goes in great details whenever required. His classes are great, even if you miss in person, you can view them on CVN later. It was really helpful. If you are lazy to work because you have a job already and just want to pass this course, then you might not like working so much, but otherwise if you have genuine desire to learn operating systems, you will be grateful to Prof Nieh. Assignments are challenging and you will spend time reading linux kernel code. Best resource to get help is good TAs. For our course TAs were really good and helpful. I spent almost few hours with them before doing any assignment and it helped. Cool thing about this course is that if you do assignments on your own and are able to finish it, you will become good enough to answer any question on kernel that you are expected to know and even more. Make good teams for your assignment. If you have problems with team mates better change team, hire or fire someone else you will end up struggling alone and that doesnt help. Just remain above average in exams, assignments and your grades will be great. If you outdo average in all cases you will get a very good grade.
Your experience in this class will depend almost entirely on your team. If you come in with people you know and trust to be competent, you will be at a monumental advantage. If you sort into a random group, well... godspeed to you, brave soldier! The professor's lectures were of extremely high quality, though the recordings are not. TAs were top-notch. The two books were, respectively, completely useless and extremely useful. You will be given problems from the extremely useless book, but should instead spend your time reading the book on kernel development for the homeworks. (45%) 6 homework assignments, lowest is dropped (15%) Grading on your reviews of peers' work (15%) Midterm (25%) Final (00%) Extra Credit Note: there were programming problems on the two exams.
Too much workload that equivalent to, or even more than the rest three courses I take this semester. Besides the endless projects, you need to review others' homework which also takes up much time. The grading sheet is really harsh, you never know what parts will be deducted points according to the grading sheet. The homework instructions are ill-organized sometimes, you were not clearly told what were expected to do in order not to lose points.
Real men take Operating Systems. And, of course, hard as nails women too. This is by far the hardest class I've ever taken. The workload is about 30-40 hours per week on project weeks, almost none on off weeks. And there are like two off weeks. The course itself, as in the things you get examined on, is actually relatively simple. There are two components: a concepts component, which you can get entirely from reading the textbook, and a practice component, which consists of endless hours of reading through C source code, followed by more hours of implementing your design, followed by a frantic 24 hour code marathon once you finally figure out what you were supposed to be doing from the start. Some prerequisites: Firstly, you need to know C really, really well. I mean like, you need to be able to write memory-safe in C in your sleep. You will be taught thread and interrupt safety in the course itself. More importantly, you need to be able to read C code. There is no manual for the Linux kernel. It's C all the way down (well no, it turns into assembly at some point...) I mean, yeah there are some documentation notes, but the real deal is the code. If you can't figure out what a method is doing in one glance, you're going to have to brush up on your sight reading. Oh and also, the projects are based around modifying the Android Linux kernel. I mean, how cool is that!
This course is the best CS course I have ever taken. I entered the course with very little C experience and with hardly any Linux experience - let alone any kernel programming experience. After taking this course I did a project for the professor next semester and I now feel confident to take on large kernel intensive projects. Further, even if you're not going to be an operating systems developer, taking this course will make you understand all those details, which are unavoidably important, but always seem vague without having real OS experience - such as memory management, device drivers, threads and processes and more. I have taken another OS course before this at another institution, and I have to say that a course like this should be mandatory for all CS students. Jason is an excellent teacher, who is very approachable and answers any question with insight and dedication, so take this course with him if you have the chance. Only criticism is that I think there should be a homework related to writing a driver/module instead of for instance changing the scheduler, as it is more relevant for most of the kernel work to be done by the majority of people. Also, the classes do seem a little slow at times, but I guess that's more of personal preference.
This is by far the most demanding and rewarding class I have taken as a CS grad student at Columbia. The famous 6 Linux kernel homeworks were just as time-consuming as could be expected. However the Prof and the TA:s were very helpful and there is a good discussion board belonging to the class. It was possible to skip one homework without a grade penalty. The first two assignments were not that difficult but 3-6 was very challenging. The exams were in general pretty straight-forward if you had attended the lectures during the semester. The lectures however were rather slow and somewhat obstructed by irrelevant questions. The level of the lectures were much lower than what was required to finish the homeworks. The best advice I can give for this class is to preferrably get familiar with C and Linux as much as possible before starting the class. No previous kernel programming experience is necessary but not having to spend time with syntax problems is very nice. But anyone interested in low-level programming should definately take this class.
Hardest CS class you'll take at Columbia, hands down. Also, the class you'll learn the most from. Work hard in this class and you will be rewarded. Work not so hard and, well, you'll know the theory fairly well, but that's about it. This class requires a highly intimate knowledge of C--if you don't know it very well, then either skip the class or be prepared to read the K&R book thoroughly. The course covers the internals of the Linux kernel and we worked specifically with 2.6.11. Nieh covers mostly theory in class, and there is one text which goes over theory in more detail, and one which is a god-awful dry textbook (more like a manual, actually). The assigned readings aren't that long, and you will definitely need to do them--otherwise you will have no idea what the hell is going on. That being said, his lectures compliment the readings very nicely. Nieh was one of my better profs in terms of not "teaching out of the book." However--Nieh is the person you go to if you don't understand theory. If you need help with the homework, skip him and go to the TAs directly (he has little involvement in the homeworks). For each homework, you write a patch to the kernel that does something. After you submit, you have to meet with the TA for ~30 minutes to demo it, and they will also run their own test program on it. Be careful as they are NOT AT ALL forgiving if anything goes wrong--if you can't get it to work (even for a stupid error like you submitted the wrong file), you lose practically all points. Also, each HW has a written portion (~10 questions, usually 50% of the grade). HWs: 1. Basic stuff, write a small shell, etc. 2. syscall logger: not that hard, just an introduction to syscalls/the virtual machines you'll be using 3. waitqueues/locking/threading stuff: you don't have to write that much code, just be careful what exactly you write. 4. implemented a new scheduler type. most of the class just skipped this HW entirely, i recommend you give it a shot, but, don't bother if you can't get it. 5. memory tracker: write a syscall that can track what chunks of memory you're using. requires you to go low-level with page tables, etc. tough but doable. 6. process tree filesystem: make a filesystem that reflects the processes on a system. it's a lot easier than it sounds; he gives some examples of other pseudo filesystems in class.
This class was the class I have learned the most from, and has also been the class from which I have gained the most marketable skills I have and have at least indirectly landed me job offers. Sometimes professor Nieh presents material in a suboptimal order, but he is very good at explaining low-level system concepts and hardware interactions as well as higher-level algorithms. Exams are definitely fair, but homeworks can be ridiculously difficult in some cases, but others are a good amount of work and are very educational. He is also very approachable in person and will help with concepts outside of class and welcomes feedback as well.
Professor Nieh is generally an amiable person. He provided us with Halloween candy during the midterm and held a pizza party/review session for the last day of class. His teaching style of writing bulleted lists and making diagrams on the blackboard is mildly helpful -- at least it's not Powerpoint. The material was actually really interesting, and concretely brought together things I had learned in other CS classes. Unfortunately, all of this pales in comparison to the torture of the homeworks: endless hours of staring at a computer trying to understand somebody else's LInux code that is hardly discussed in class. The material taught in class was how an operating system works. Ability to do the homeworks was in NO way a function of how well you understood this material. Take this class if you don't care about your grade or have no social life.
If you're going to look for a job in I.T. after graduating with whatever degree you're working towards, this class is a must. The fact that Linux is used as a case study throughout this course is *immensely* useful, if only that OS courses at other universities are taught with merely pedagogical operating systems such as Minix or Nachos. That said, the programming part of the homeworks was arduous and time-consuming (yet rewarding once you gradually grokked a solution, which ended up being less than 50 lines of code for most of the assignments). An able CS undergrad would spend anywhere between 10 to 20 hours a week on the homeworks (written + programming parts combined). Nieh's lectures are very straightforward, and they are very much worth attending. The class is all about *detail* -- for those in systems, there is mounds of it to drum into your head, and this class gives you good practice. The worst part of the class is not the homework, but the morons that you can be potentially be paired up with for doing the programming assignments. Your partner may contribute nothing, yet s/he can get all of the credit for your hard work. Luckily, you get to submit reviews of your partners and they swap around the programming partners based on those reviews after the first two assignments.
Ok, here's a simple test to determine how you'd do in Nieh's OS class. Rate yourself on a scale of (1=low to 10=high) on each of the following: C/UNIX programming; low-level debugging (i.e. pointers, memory traces, locking/serialization); Linux kernel. Now take the average. If greater than 25, you'll do ok. If greater than 15, expect to spend at least 10 hours a week in the CLIC lab. If less than 15 then **don't bother**. For real. If you are not an expert (or at least very very good) in C and UNIX, then *don't bother*. Now about the class itself. It runs at 200 miles per hour. If you can't keep up with the homework, then you are basically screwed. The programming part is **all Linux kernel hacking** and it is *not* covered in class. Don't expect the TA's to debug your problems and don't expect the prof to give much help except conceptual stuff. Of course, if you have munched Linux kernel code already, then this course will be a breeze. BTW, the cheating policy is outrageous (if the TA suspects you in the least, you are screwed.) Like the other review said, trust the prof/staff less than they trust you and you'll be fine. Prof is okay at office hours, but doesn't have time to give you detailed explanations and stuff -- either you go *very well prepared* or get thrown out in less than 5 mins. But if you can keep up with it, you'll get something out of it.
In my opinion, Prof Nieh lives in the unrealistic world where a day has 48 hours or more for a student. The work load is way too much and his lectures are absolutely useless when it comes to doing the programming assignments. He might be an intelligent guy but anybody can handle an operating systems course by repeating what is in the text book. I dont understand how this course has become so popular over the years. The regrading procedure is bureacratic crap and it makes life more miserable for the students who dont have the time to write down lengthy explanation as to why they require a regrading, as they are otherwise busy trying to complete the programming assignments. I believe there are easier more effective ways to learn Linux than trying to cramp it all in 2 and half months. I would never recommend this course to anyone.
Great teacher, definitely one of the best lecturers in Columbia CS department. This is a rough class, but any class that involes with operating systems is rough, there's no way out. Hacking the linux kernel will be the most frustrating thing you''ll have ever done... but you'll get a lot out from this class, in terms of programming skills and systems knowledge in general. This class will also definitely help you to get a job if you are interested in doing IT as a lot of big firms are now hacking the linux kernel for their own benefit. One warning: WATCH OUT FOR CHEATING FOR THIS CLASS, this class is notorious for cheating and THEY'LL CATCH YOU!!! But this is definitely a fruitful class, definitely one of the best CS classes i took at Columbia
Prof. Nieh is a good professor. His lectures, although boring at times, are informative. My main quibble with this professor is the manner in which he interacts with his students. He has a real disdain for them. Be careful not to get on his bad side, or you will be subject to some of the most twisted, Gestapo-esque student-teacher interactions you have ever witnessed. Trust him less than he trusts you and you will do fine in the course.
A relative new-comer to Columbia, Nieh is a VERY smart guy, and when it comes to OS, he is THE specialist. His lectures are one of the better ones here at Columbia, and you'll actually learn a lot - BUT, you really need to be awake and ready to participate, as he likes to shoot off questions, and expects you to be able to answer them. He is willing to help outside of class, but make sure you have your questions ready, as he tends to get frustrated if you go to him and don't have a clue about what you need/want to know. As far as homework goes, the theory part is fine, but the programming part is NOT. When I took Data Structures with him, only 3 of 50 or so students was able to finish one of the later homeworks... he really expects you to know how to code (god knows where you're supposed to have learned!). Thankfully, his tests are more manageable (mostly due to the fact you don't have to code!).
A good lecturer who, unfortunately, seems to hold students in genuine contempt; it irritates him that we tend to insist on quality of education. No complaints on the lectures, and problem sets are ok, since they're book-based; it's the programming assignments that ruin the class. They're a true mass-nightmare, since students are given literally no preparation for them, and lectures have nothing to do with them. Honestly, with no way to learn how to do the project on your own, can he really be surprised that so many of his students cheat? The plus side is that if you work your ass off (and I mean work your *ass* off) and pay close attention, OS I will teach you two semesters worth of Linux and Unix OS mechanics. Unfortunately, if you have to take OS, there is really no other choice than Nieh. Either hold your breath and scrap together a B, or split up with your boyfriend/girlfriend and move into the lab... just be glad that not all teachers care so little about coddling you as Nieh does. Hopefully, you'll actually learn something in the process, as he knows the material inside-out. And if Linux is old Hat for you, you might possible find yourself enjoying the class. But not likely -- Nieh, like so many other cs profs, confuses a ridiculous 'sink-or-swim' approach for academic rigor. He should wake up and face teaching like an adult; you should avoid him.