Reviews

High value course that I took during the compressed summer term alongside with Deep Learning. I spent about a day at most to finish the projects, and I read every required chapter and used the Reading Responses as a place to take notes. Doing this gave me a B in the end in the class. Overall I think the course was easy, with a lot of valuable content and nice, but kind of short, projects. I usually got the programming projects right on the first submission. The theory/math homeworks were where I scored the lowest, but as long as you are brushed up on your algebra and calculus it will be a decent average. The final exam was difficult because you will face new problems you haven't seen before. You can get around this by making sure to do the exercises in each section of the book chapters. This is probably the most optimal class to pair with Deep Learning in the summer.

Great class. The assignments and projects are designed in a fashion that makes sure you end up reading lots of papers and learning a whole lot.

Fantastic course with a great professor. Good mixture of theory and practical coding assignments that engage you with the material. Really cool final capstone project as well with teammates, and no exams. Workload is much bigger during the final project.

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. Great lectures and text book 2. Most applied course in program I've taken yet 3. Peer grading is lenient - makes it easy for a good grade Cons: 1. Peer grading is lenient - makes it easy to not get most out of the course 2. Mandatory Piazza posts means discussion board is full of non-value added comments 3. Detailed Review: Lectures - The first part of every lecture goes over general concepts of what makes up a good visualization. This is material that can be utilized no matter what language or software you are using to generate the graphics. The second part goes over how to generate the graphics in R utilizing the latest in the Tidyverse / Tidymodels framework. The professor also has a shiny webapp at the end of each section which gives you a walkthrough tutorial on applying the code discussed in the lectures. This was extremely helpful and useful. Textbook - The textbook is free to access and goes over much of the same as the first part of each section. Great reference if you prefer a written text. All of the slides are also available on the course website. Homework / Projects - The homeworks are pretty simple. You could pretty much copy paste a lot of the code from the lectures and make a few modifications to receive full points. The projects were also pretty simple, although you did have to put in some more thought in than the homeworks. The last two were more open ended (choose your own questions for 4, choose your own dataset and question for 5) which allowed a lot more creativity on what analysis you did. However with the lenient peer grading rubric, a lot of lower quality reports still got an A even though you wouldn't want to share such reports in an actual work environment. If you are just looking for an A, you can likely get it without investing too much time or effort into the projects. If you want to get the most out of the course though you need to be self-motivated as the grading won't push you above and beyond. Piazza - 14% of the grade comes from participation points on Piazza. The first half of the course was sort of a train wreck. They had it were you needed to make 5 comments or post and get one instructor/TA endorsement to receive full credit. This resulted in students posting insane amounts of comments and posts fishing for an endorsement. In the second half they modified it so you could receive full points for either 6 comments/posts or 5 comments/post and instructor endorsement. This made Piazza much more manageable. Professor Wilke and the TAs were all very active on Piazza and it is clear they are passionate about the content of the course. Overall - It is clear Professor Wilke put a lot of time and effort preparing the material for this course. It is also one of the most applied course I've taken so far in the program. I am already applying the concepts I've learned in class to my day job. Overall great course. Also the work load is pretty light in this class, so it is very manageable to pair it up with a harder course.

Pros: 1. Learn a lot of concurrency/parallel programming patterns 2. Learn Go and Rust 3. Learn how to generate reports for labs 4. Learn performance measuring Cons: 1. Scattered knowledge points 2. A lot of programming work 3. Hard to get some help from office hours, because when you asking questions, you don't know what to ask. 4. Taking some time to understand the concepts 5. The labs requirements sometimes are vague Detailed Review: Only five labs, no exams. Lab 1: Prefix sums(C++) Prefix sums: Prefix sums, or cumulative sums, are a technique to preprocess an array so that the sum of any subarray can be calculated quickly in constant time. Prefix sums have many applications Pthread barrier: A pthread barrier is a synchronization mechanism that ensures all participating threads in a multithreaded program reach a specific point in the code before any of them can proceed. Work-efficient prefix sum algorithm(Blelloch) Lab #2: KMeans with CUDA(C) * GPU/CUDA parallel API * Low-level api, calculate the indexes * High level api * KMeans algorithm Lab #3: Binary Search Tree with Golang The goal of this assignment is to write a program in a language that restricts the programming model to simplify dealing with concurrency: Google's Go. You will use channels, go-routines, and signaling to compute binary search tree equivalence. * Golang concurrency pattern(be careful, a bit tricky) * BST data structure Lab 4: Two-Phase-Commit(Rust) * Rust language: no garbage collector, ownership, memory safe at compile time, high-performance(close to C++) * Two phase commit protocol for distributed systems * Hard to debug due to using one process to control multiple children processes Lab #5: MPI Barnes-hut * MPI: parallel computing pattern * Barnes-hut algorithm * OpenGL: for visualization

Really enjoyed this course. As others said, the first two HWs are pretty straightforward, particularly if you're using the example code the professor uses in his lectures. However, HW3 takes a large jump in difficulty and the HW assignments diverge significantly from the lecture videos. I strongly suggest getting a jump start on the material even before the semester starts to give yourself a buffer when you hit the later HWs. There's lots of little things that can trip you up, but that aren't clear how to diagnose. The TAs over the summer were awesome and quickly helped with questions, but if they were worse I could see this class being harder. Final project is massive, so definitely start early and get a group to do it together.

Pros: 1. Very well presented material. Shorter videos 10-15 minutes split logically. Best virtual presentation of material I have seen so far. 2. Great TAs and course staff, very responsive on Piazza and not overly paranoid on cheating because the course is well structured. 3. Programming assignments only and a final project, no tests! Cons: 1. Programming assignments take some getting used to, I required office hours and TA help often Detailed Review: The course comprises 5 Programming Assignments and a Final Project. No tests outside of some basic questions on Edx following videos which you have infinite retries. The material is released weekly in sets of short videos, but the previous semester course is also available in a separate website if you want to work ahead, although there can be some small tweaks on the assignments. This semester for example had a very different format for the Final Project, but other programming assignments were mostly the same. For the programming assignments, you get some scaffolding code which is typically well documented, but there are some tricky areas and functions that you sometimes do not use unless you want to go above and beyond in your experiments. I ended up not working ahead of schedule due to my work schedule. In general, I did not feel very pressed for time except for Assignments 3 and 5 which tend to be the harder projects. These assignments are significantly harder so start early! I attended TA office hours semi-weekly and especially close to the deadline, and very often some pseudo-code discussions would come up that were very helpful. There are a lot of different possible solutions and the TAs tend not to recommend you follow a specific method, which I appreciate because it allows you to learn some trade-offs on implementation of the models. This makes piazza discussions regarding approach interesting: Can I do this? - Yes. I think that would also work. So make sure you ask the right questions like: I went for this approach and I am hitting this problem, what do you suggest? The assignments use Pytorch and different types of Neural Networks. I did not know Neural Networks outside of the brief introduction we had in ML. I also did not know PyTorch because I did not take Deep Learning prior to this, but managed an a good grade anyway. I am very comfortable programming in general and picking up new frameworks so I relied mostly on this to get through the course. Professor Greg is an outstanding lecturer and very easy to understand, I am happy I got my neural network introduction in this course. However, I do think taking ML before this is a good idea. TAs are just outstanding, flat out the best I have had in the program. They are helpful even on debugging your code on break-out sessions, which is actually really hard to do for these models. The TAs that have worked on the assignment recently tend to be a lot more specific in their guidance, and that can be a big help. You do get the occasional wrong advice by accident, so follow your instincts and give yourself time to work through this. Programming assignments are tricky to guide people through, there are so many different ways to code a solution. The Final Project was very interesting, this year they gave us an option to partner up with someone and you have to read papers from recent NLP research, and explore datasets and come up with potential experiments and improvements. You have to write a paper on your approach in a similar format as the research papers. There is plenty of room to innovate and explore new ideas, and not as focused on the results so much as the analysis and the write-up. This is peer-graded but reviewed by the course staff which is again, a much better way to do peer grading. It is almost like the people who designed this course still remember how it is to be a student and truly care. Bottom line: I wish other courses were structured this well. This is a course designed to teach the concepts in a new and evolving field of research. Great scheduling, pace, format, assignments, and staff. You can easily understand and assess your knowledge and predict your grade as you go.

The projects were a ton of work, but they were really interesting and rewarding. Lectures were fun as well, and I really like the material.

Pros: 1. Quite broad 2. Great intro to pytorch 3. Really interesting projects Cons: 1. Will quickly go out of date (professor left) 2. 3. Detailed Review: I really loved this class. It was exactly what I needed to get comfortable with pytorch, with some really practical and interesting computer vision projects. The final project was learning to play a computer game, which I had absolutely no idea how to do before this class. In the end it just all fell into place and I made something I'm really proud of. While the projects were mostly related to computer vision, the lectures went through a lot of detail on different architectures, and how to solve problems like vanishing and exploding gradients etc. However, the material is likely to quickly go out of date. The lessons were recorded in 2021 I think, and the professor who made them left the program last year. The material for the practical lectures is on the professors own website and isn't maintained anymore. That made for a frustrating time trying to piece together dependencies and data in order to follow along. The graders were obviously made around the time the lectures were set up, so now you have to be careful with your environment setup, as you'll probably run into errors where you've used versions of e.g. pytorch that are too new. This is a rapidly evolving field, 2 year-old lectures are already starting to become dated, another year and they'll start to sound out of touch. Really good class, but I hope they find a way to keep it up to date for the future.