Course Details

Pros: 1. Learn a wide array of topics, including containerization, microservices, serverless etc. 2. Can work in teams for labs 3. Fair Exams Cons: 1. HW seemed too "linear" 2. TA's unresponsive on edstem at times 3. Detailed Review: What I liked most about this course is how in the lectures we covered new topics regarding containerization, microservices and serverless, all hot topics in the industry today. The exams were fair, and it seemed they were graded fairly as well. My main issue with this class was the labs. The setup for the lab itself was a bit convoluted and many people using the local setup had issues and had to request remote access to a UT machine. The labs themselves were fill-in the blanks where it seemed like we used someone else's implementation, and the prof went in and just deleted a few methods that we had to fill back in. While it wasn't hard, it seemed like we didn't learn what each step was doing in depth and why we were doing what we were doing, rather just following the hints provided as sort of a roadmap of what code to write. The TA's were helpful during office hours, however, I felt like on edstem(piazza's replacement) it seemed like there would be 2-3 days before TA's would respond to a question at times. However, a lot of the office hours (especially in the last 2 months of the class) were cancelled/rescheduled. One good thing about labs is the ability to work on teams, however, since each lab built on each other and every part of the code was interconnected it was a bit inconvenient switching between teammates to split the coding part, and we ended up having one person doing the coding for last 3 labs.

Pros: 1. Exams were fairly graded and were of decent difficulty level 2. Container and serverless lectures were interesting 3. Project/labs are group based Cons: 1. Project was painful to setup and even more painful to solve 2. Lecture videos were originally recorded for on-campus covid batch and are unengaging 3. Some videos are way too long 4. Extremely bad TA support on Ed 5. Projects are graded slowly, manually and very harshly, missing a line could lead to a loss of valuable marks Detailed Review: Lectures - These lectures were recorded for the on-campus covid batch. Hence, they were not taught with online students in mind and I found them way less engaging than other subjects which have slide based lectures. It made revision before the exams tough too as you can't just glance over the video frames. They also didn't include the guest lecture videos for us for some reason which was disappointing. The second half of the course on containers/serverless was much more interesting and easier to follow, however, the videos could have been broken down into smaller chunks had they tailored it for online offering. The prof, however, knew his stuff and looked at ease throughout. Also, a lot of lectures had incorrect subtitles at places (and one video didn't even have subtitles). Exams - Exams were not too difficult and were perfectly doable even with less than thorough preparation. The grading was fair and I feel I scored in proportion to what I had studied. The endterm is cumulative on paper but I didn't see a single question from the pre midterm topics. Labs - The labs have multiple issues in my opinion. Firstly, it was a nightmare to setup the labs on the unreliable UT machines hence I had to find an old machine to run it locally. The labs are group based (upto 3 people, min 2 people) which is the only face saver. The downside is that these labs are not meant to be solved in groups because of how monolithic they are, and not knowing how a previous lab was solved impacts your ability to solve the next one. TAs refused individual groups because labs are graded manually and it takes a lot of time and hence they wanted to reduce their workload. The solution for the previous lab is released 5 days after the next lab is out due to late day allowance, so one has to wait for that long to start the next lab in case their previous lab submission had issues. Also, there is little to no way of knowing that your submission had issues, because even when it seems to work fine, points are deducted because of missing a line/argument etc. My group could not solve the last lab completely, and there was nothing we could do about it. Ed Support - This was shockingly bad, given that the same head TA ran AOS smoothly. The responses on Ed were vague and delayed more often than not, and office hours were cancelled/moved liberally in the second half of the course - making life tough for people in Asian timezones who have to stay up late to attend these. Ed in itself is a downgrade from Piazza too.

Pros: 1. The projects altogether give you a sense of how a hypervisor works from a programming standpoint. 2. The exams are tight for time (tightest of all the courses I have done so far) but fair. The questions test your knowledge and conceptual understanding well. 3. The lectures explain concepts well, and the content is quite interesting and modern. The first half goes through the inner details of virtualizing CPU, storage, etc. The second half looks at the main virtualization technologies and research (Unikernels, containers, Kubernetes, etc.). The slides aren't the best for the second half, but it conveys the ideas well. Cons: 1. Projects are group work but are not structured well for group work. You can implement the various functions separately, but you likely won't understand what's going on unless you do them all. For later projects, that missing understanding will hurt. Also, you typically can't tell if isolated functions are working correctly; if 1 function is incorrectly implemented, all you can tell is that something is wrong. In some cases, everything can seem to work well and you still have mistakes (that you won't know of until they hit you in later projects). 2. Projects are marked overly pedantically harshly. Missing 1 or 2 error checks could result in losing half or more marks for a given function. 3. Other notes: Try to make sure your setup works as soon as you can. I ended up having to use the faculty-provided cloud resources after the 2nd project because there was something wrong with my setup causing the 3rd project to fail just for me. I didn't do AOS before taking this course, so it's definitely not required.

Pros: 1. Serverless and Container lectures were super interesting 2. Groups of 3 was nice 3. TA's were responsive Cons: 1. Projects were hard and lectures didn't help with them 2. Some of the lectures were out of date (although he mentions this) 3. TAs tended to give overly vague guidance which didn't help Detailed Review: I really really hope they refactor the projects -- throughout the semester, you're working on an Academic VM which is not really well-written and there's some sloppy comments that guide you but for the most part you're on your own to figure it out. It was really cool to learn more about serverless and containers; I can talk intelligently about those now. Really hope one of the projects is tailored towards those sometime in the future because it would be nice to get some hands on practice with them. I also think that some of the papers we looked over are really interesting but it's been years since they were published; let's see where those studies are at now? Basically, a new batch of videos per semester would make sense, to me. I did email the professor with those recommendations so let's see what happens.

Pros: 1. Containers and serverless were useful/interesting 2. Not a huge time commitment 3. Projects in groups of 3 Cons: 1. Irrelevant and boring projects 2. Long, boring lectures 3. Advanced topics are pretty useless Detailed Review: I really wanted to like this course and came into it excited, but I can't help but feel disappointed with how it all went. My main gripe is with the projects - they're super boring and entirely irrelevant to what we learn in class. I felt this way in AOS, but the feeling was more acute with this class. This could also be a me problem - I don't know C very well and I'm not a systems programmer, so the projects generally just felt like a slog. The only plus side is that the projects were in groups of 3 so the onus wasn't entirely on me to do it all (I had a good group). The lectures are also very long and boring...and like a previous review said, I'm likely to forget everything from the advanced topics. The professor feels more at home in these lectures vs AOS, which is good. It's probably more interesting material for him to teach. The workload was also pretty light, so if you're looking for an easier course then this is a good candidate. It just feels like a missed opportunity - we could have dug into some Docker code, or some serverless code, or just anything more interesting than what we did. But oh well.

Pros: 1. Midterm and final (each 25% of the grade) were very fair, nothing unexpected, very possible to make an A if you prepare adequately 2. Get to be in groups of up to 3 for the projects 3. Interesting, very industry-relevant content; 2nd semester is entirely on containers and serverless architecture Cons: 1. Some project assignments could be dense and tricky to figure out 2. The textbook probably isn't worth reading; everything you need to know comes from the lectures and the hands-on knowledge you get from doing the project, and the textbook is too dense to be really useful 3. N/A Detailed Review: I'd heard it's preferable to take Advanced OS before this class, but I went out of order and was OK. I'll take Advanced OS in the upcoming semester so I'll see how much of it would have been useful to know beforehand, but at least it's really not a requirement, just a suggestion.

Pros: 1. Doesn't require much time per week 2. Grace days allow for turning in assignments after the due date 3. Labs are straight-forward Cons: 1. Lectures are a slog to get through (i.e. could be shortened) 2. Advanced topics are a waste because I won't remember them 3. Projects are plug-code-in-and-play type Detailed Review: I was underwhelmed by this course, but not because of it being disorganized, or from a bad instructor or the TAs being contradictory/unresponsive as with some of the reviews for other courses. The course is organized well and straight-forward, the instructor knows his stuff and explains it clearly (could even be briefer), and the TAs are the ones mostly running the class and were responsive on Piazza. I may just be growing tired of courses in general as I'm nearing the end of the program, but this just seemed like a missed learning opportunity. The lectures were a drag for me and too slow (even though I watched them at 2x speed). I may just not be interested in the subject matter overall, but I think if the lectures dug into the details more then I might have been more interested. I think some topics get too much time and attention while others don't. The whole second half of the semester seems like a waste being spent on advanced topics. There are so many papers covered and I will likely remember none of them. They are all touched on at a high-level and we are encouraged to read the paper. In place of all these advanced topics I wish there would have been more focus on the fundamentals with even more projects, including ones for containers and serverless. That brings me to the labs - they are too easy, but not because of the subject matter -- mainly because they are plug-code-in-here-to-complete. We are encouraged to read through the rest of the source code, but I didn't find that intrinsically rewarding. I would have liked if we were required to write more code for more of the systems, so that we could anchor in these fundamental concepts. Also, the difficulty curve is not gradual: lab0 and lab1 were too simple and just require filling in a few lines of code; lab2 and beyond get considerably harder and the lectures fail to provide enough detailed information to complete (a lot of extra reading); lab3/4 are around the same level of difficulty. As a convenience to others I'll post a breakdown of where my time went from week-to-week (as I do with all my other reviews): - W1: 4.25 hours [2 hours (intro, W1 lectures, dev setup); 2.25 hours (W2 lectures)] - W2: 0 hours - W3: 3.5 hours [Lab0] - W4: 3 hours [1.5 hours (readings); 1.5 hours (W3 lectures)] - W5: 6.25 hours [0.75 hours (W3 lectures); 1.5 hours (W4 lectures); 1 hour (W5 lectures); 3 hours (Lab1)] - W6: 0 hours - W7/W8: 3.25 hours [1 hour (W5 lectures); 0.25 hour (midterm review); 2 hours (midterm)] - W9: 3.75 hours [1.5 hour (W9 lectures); 2.25 hours (Lab2) - W10: 3 hours [Lab2] - W11: 7.5 hours [1.25 hours (W10 lectures); 6.25 hours (Lab3)] - W12: 3.5 hours [1.5 hours (W11 lectures); 1.25 hours (W12 lectures); 0.75 hours (Lab3)] - W13: 6.25 hours [1.25 hours (W13 lectures); 0.5 hour (W14 lectures); 4.5 hours (Lab4)] - W14: 1.5 hours [0.25 hour (W15 lectures); 1.25 (final review)] - W15: 2 hours [final]

Pros: 1. Project/software development based assignments. 2. Learn about interesting and relevant virtualization topics (docker, serverless, etc.) 3. Straightforward & fair exams. Cons: 1. Projects are not discussed in class - you're on your own. 2. Piazza support is limited. 3. Lectures can ramble on a little, and it can be difficult to pick out the important takeaways. Detailed Review: Overall, a pretty good course. I feel that I learned things here that I otherwise wouldn't have if I just tried to research virtualization technologies on my own. Projects within the course are centered around building a hypervisor in groups of 3. There are 5 assignments where you will implement a little 'piece' of the hypervisor within an already largely developed code base. It's a little harder than it sounds with projects 3, 4, and 5 giving you more trouble than the first 2. Plus, there is virtually no course support for the projects - you're pretty much on your own to figure everything out. The projects were not discussed at all in the lecture videos or in supporting materials and I didn't find asking for help on Piazza to be worth the time to type up a long post explaining the problem - I would usually get a 1 sentence response that caused more confusion on my end. Otherwise, there is a midterm and a final. Both are fairly straightforward to study for and are just short answer response style canvas 'quizzes'. The professor doesn't make you download any invasive monitoring software or record yourself taking the test (pretty creepy if you ask me @ ML Summer '21) - this is a big plus and very appreciated! I'd recommend some systems background before taking this course - Undergrad OS/Adv Operating Systems or equivalent. There is a fair amount of assumed background knowledge (paging, processes, isolation, etc.) that you will have a hard time understanding if you've never taken an OS course before.

Pros: 1. Great Prof with engaging lectures 2. Content is very relevant and bang up to date 3. Very fair exams - Open book, take home - if you are paying attention at all you should not fear them Cons: 1. Group based projects drive half of the grade 2. Some material only delivered for the onsite class - not clear why 3. Not enough time spend covering the code framework you have to use for the projects Detailed Review: Prof examines the world of Virtualization, starting with some good history on how we got here and covering off the latest problem space and a glimpse of the future. Very good course, well delivered. There are some guest lectures and a second, individual project that are only for the in class version and as we share the same content it is sometime confusing which applies to us (and a little disappointing that we don't get it all), but on the whole still very worthwhile. The workload is medium at the start, lots of setup work, but drops to literally nothing by the end (good if you need to study hard for a very theory based exam in a different subject). The exams cover the subject matter and are open book so are really nothing to fear. The project is hard in so much as you are not writing your own Virtualization engine (that would be waaaay too much work for a semester) but gluing code into someone else's that has had key bit ripped out. The one thing the course could do with is a lecture aimed and briefing you on how the example is actually structured - you have to spend a good while analyzing some code that isn't as logically put together as you might hope to understand what it's trying to do - then writing the missing code is almost trivial. To answer the question of should I do Advanced OS first (which everyone asks), yes, it's a good idea - they fit together nicely, no you don't need to, yes you can easily get an A in this if you haven't. Unless you are very familiar with C, you will have to spool up fast to manage the projects (we are not talking about being a C expert here, but you want to be comfortable) and the AdvanceOS course had a much gentler ramp up for the C component IMHO. You also get a very good grounding in many of the concepts that are relevant to Virtualization (after all, you are writing an OS for OSes in effect). Prof will cover what you need to know if this course, it's just that much easier if this is revision rather than the first time you've seen it. If you've taken a good undergrad OS course recently though, you will be just fine. Definitely recommended.

Pros: 1. Topics are recent and very relevant to the industry 2. Good balance between high level lecture content and in depth programming assignments 3. Professor articulates content well Cons: 1. Disconnect between lectures and programming assignments can make the programming pieces difficult to tackle, especially if you are not strong in C 2. Projects are done in groups, can be good or bad depending on how you feel about that 3. Detailed Review: Overall this was an amazing class, perhaps one of my favorite ones in the program. The topics are really relevant and can easily be applicable to full time jobs. I liked the lectures the most, they are high level and easy to grasp. Programming assignments were a bit difficult because the lectures don't actually help you much with the assignments, but if you are willing to set aside time for them and have a good group to work with then it shouldn't be an issue. I also recommend taking the Advanced OS class taught by the same professor prior to taking this course. That course provided good background knowledge that can help with this course as well.