Video version: https://youtu.be/Azi7fpis-Hc

While this course isn't perfect, I really enjoyed it. Unfortunately, its shortcomings are amplified by administrative issues. If GA wasn't required for most specializations and wasn't so impacted, I think it would have much better reviews. As it stands, this is just about the worst class to have in your last semester because it's so exam heavy (read: stressful) and so different from other OMSCS classes; it's basically a math class.

I thought the lectures were great, as well as the required textbook. The weekly quizzes were OK. There were some ambiguous questions, but overall they were fair. The homework was a good barometer for what to expect on exams, both in terms of format and difficulty. One bit of advice--don't worry too much about your homework grade. Look at it as exam prep, and if you get any points off just make sure you understand why.

The exams are definitely stressful because they make up such a large portion of your grade and there are so few questions. With that being said, so long as you adequately prepare, they're not too bad.

Coding projects were easy and didn't take very long.

My advice: 1. Successfully complete all recommended practice problems under exam conditions 2. Watch all office hours (weekly and exam prep) and understand each explanation/solution 3. Actively participate in a study group 4. Don't stress

Yes, the class isn't perfect. The exams are stressful and some TAs can be rude. Still, this was one of the most interesting and enjoyable courses I took in OMSCS. I just wish the administration could figure out how to make it available to students earlier in the program.

Video version: https://youtu.be/kIWOmKljQqo

This class is extremely light, but a good introduction to digital marketing. It's well-organized with weekly modules. Lectures are clear and to-the-point.

There's a weekly writing assignment related to the lecture material, either a mini-case or a major case reflection (9 mini-cases and 5 major case reflections). Mini-cases involve reading a short (about 1 page) case study from the textbook and writing a short (about 3 paragraphs) response to 3 questions. Major case reflections are longer versions of mini-cases in which you read a case study (5-15) and answer 3 long form questions (about 2-3 in total).

The midterm and final are closed note, 35 questions each, multiple choice and quite easy. I studied an average of 7.5 hours for these exams and averaged an 93%. I just rewatched the lectures and reread the textbook chapters and case studies.

A very easy class, but very well organized and could be useful if you're interested in starting a business. I paired this with Graduate Algorithms while working full-time and I hardly had to think about this class.

Video version: https://youtu.be/pXluusB4CZ0

This class has a lot of potential, but unfortunately its current form feels very half-baked.

The lectures are very engaging and informative. They're targeted at someone with a technical background who doesn't have much business experience. I think this type of class would be very beneficial for many students in OMSCS, but they really need to improve the rest of the course.

The course centers around a semester-long group project. Your team generates an initial idea and conducts customer discovery interviews (15 per week) for 8 weeks. You also fill out a business model canvas and submit a short video presentation each week. At the end of the semester you submit a longer video presentation to summarize your findings.

The requirements for the presentations do not change over these 8 weeks and so they end up feeling very repetitive. Also, the requirements are very vague and our team received wildly different feedback and grades depending on which TA graded our presentation, even though we used the same format for each presentation. Sometimes we would get marked down for not including something that was not mentioned in the requirements. A few times a TA posted in the forum that many teams were getting marked down for the same thing that wasn't mentioned in the requirements, but this was always after the fact and we were never made aware of these expectations before they were included in the grading rubric.

The TAs were also very unresponsive in the forums, often taken many days to answer even simple questions, and unfortunately this usually meant that answers were given only a day or two before deliverable due date. In general, these responses were also very vague and unhelpful. The professor posted a few times and seemed pleasant, but he's just not very involved with the administration of the course.

This course is still relatively new, so hopefully the instructional staff can sort out these issues. I would love to see more detailed and varied deliverable requirements, possibly focusing on different sections of the business model canvas aside from customer discovery. Case studies would also be great assignments since this is a business course.

This course is well-situated within OMSCS and thus has a lot of potential, but the execution and involvement of the instructional staff really must be improved to make it worthwhile for students.

This was my first class I took in the program, and in general felt very unprepared. My background is basically having doing an honors math program in my undergrad, where I took 2 intro computer science classes (one in R, one in Python) my senior year. Then the last 3-5 years, I did a huge ton of python training on the DataCamp platform during covid when I was skill building for a job transition.

I have build and used some python skills in my current job heading into this course (working with modifying some pre-build automation tools), but came into this class feeling very unprepared.

This class for better or worse focuses on just doing practice, and less on the lectures. In fact, I think there aren't any mandatory recordings recommended at the first few weeks of the class except syllabus stuff. Although there are some short recordings, and a few saved full lectures from the in person course from a few years ago. To me, the videos felt not very useful, especially the ones that were based on in person lectures and were just tacked onto the course as supplemental materials.

You learn by doing the assignments. I will say in general the workbooks are detailed, and do go into a lot of depth. You basically get good at the homeworks by learning to google random comp sci terms, and get good at learning new syntax, and what to do if you're struggling with syntax. If you go to the additional boot camp seasons, they really try to help you with resources to become a self reliant coder.

In general, I feel very positive about the bootcamps. I never attended any of the ones live because of schedule except the first one, but they do put a lot of work in them. Unfortunately, it does feel like there is a huge skill difference in the kinda of basic things they help with review early in the course and jumping into the 2nd/3rd week plus of materials.

I quickly felt very behind. I managed to get through the homeworks all semester, but the exams were brutal. First exam I wasn't sure how to study, I was doing past practice exams and barely getting anything correct. There is extra credit on each exam, basically they are worth up to 14-16 points and 10 points on each exam is passing. 2nd exam our semester was complete hell. I got sick the week of and literally got a 0% after trying at it for 90 minutes. I think our class average was like 30-40% after the extra credit. They were nice and decided to curve it after, which they said they never do at the top of the semester lol. Final was a lot more reasonable, but still some impossible parts. I scrapped by getting all 1 pointers and most 2 pointers, never getting one 3 point question right on all 3 exams, and scrapped by with a C.

They give you some sample problems the 1st week and basically tell you if you can't solve enough of these problems, you might want to take some supplementary coding classes or self-study first. I would say if you're someone that thinks they have the time in their life to improve before taking the course, no shame in dropping first week to take an easier class first. I definitely plan on brushing up my skills a lot more before my next CSE course.

Video version: https://m.youtube.com/watch?v=ZYL1fKduJJU

This is a fantastic course, one of my favorites in the program. The lectures are extremely comprehensive, definitely the best set of lectures of any course I took in OMSCS. They cover a wide variety of techniques used in modern processors for executing tasks and optimizing performance. Each lecture goes very in depth, and overall they really feel like they come from a graduate-level computer architecture class.

The midterm and final emphasize problem solving, and while they are difficult because of the sheer quantity of material, the lectures provide all the material you need in order to do well.

The projects utilize the open source SESC simulator, written in C++. They are a combination of calculation, changing configuration variables, free response questions and modifying functions in the simulator code. They tie in closely to the lecture material. Because you work within an existing simulator, it's important that you feel comfortable working within a large codebase. You don't actually write much C++, but understanding the architecture of the simulator and what functions call other functions is very useful. The only downside of these projects is that they must be submitted by filling out a template Word document, which had the occasional formatting issue and obviously didn't have any auto-grading capabilities.

Nolan, the head TA, is extremely active in the forums and is one of the best TAs I've had in OMSCS. The professor also holds weekly office hours.

This course is great, and in my opinion is a fantastic course to prepare to GIOS or other systems courses that work at higher levels of abstraction.

Video version: https://youtu.be/Fq9B3s6guIY

This is a fun, project-based course. Your grade in this class is made up exclusively of the projects. I took the class in the summer—there were 7 projects (one was extra credit). In a normal semester (fall/spring), there are 8. For the most part, projects are in a fun "capture the flag" style that is common in security challenges. My favorite project was Log4shell and least favorite was Malware Analysis. Each project is run by a different TA, and they normally supplemental materials and video walkthroughs. That being said, some TAs are more helpful than others. For the most part, expect that you will be interacting with other students more than TAs in the forums.

While lectures for this class are actually quite good--and the open source textbook has many great resources for students looking to dive deeper into particular topics, something all OMSCS courses should adopt--they are almost completely unrelated to the projects. The Cryptography project description recommended watching the RSA lecture, but other than that the lectures weren't mentioned at all. This was exacerbated due to the fact that there are no exams, so the lectures were completely unnecessary when it came to your grade.

This class is a good introduction into the field of InfoSec and is easy-medium difficulty depending on your background. If you come into this class expecting a (mostly) fun set of security challenges with a solid collection of lectures and supplemental material, you won't be disappointed. Just don't expect too much support from the instructional staff.

Video version: https://youtu.be/Jwcl0iHCALU?si=vt6FsPlBPwfbCm3E

SDP is a fun, but very light course. I would only recommend this course to someone with no (or very little) professional software development experience. Most of what you learn in this course is what you'd learn in your first 3-6 months in as a software engineer. Things like version control, IDE usage, testing, the software development lifecycle and Agile methodology and OOP. There are few more advanced topics, like software architecture design patterns and different types of documentation like software design docs, test plans and UML diagrams, and static analysis.

The lectures are engaging, though quite surface-level. We had 6 assignments which ranged from extremely easy to fairly easy. All were done in Java. There was also a group project (building an Android app) and an individual project (command line file parser with flag support). There were no exams.

The group project was the highlight of the course for me. I was paired with two experienced software engineers and learned a lot from them. As a junior engineer at the time, I really enjoyed drafting the different design docs and designing the backend and database as these are normally tasks designated to more senior engineers.

Overall, a good class to take if you have minimal professional software engineering experience and want a light semester or looking to do multiple courses. Otherwise, I'd skip it.

Background: minor in CS in undergrad, working as a dev for a decade. Second OMS class, first AI-related class ever.

The class material and assignments in AI were really good, but time-intensive. The class covered everything from classical search to game AI to ML algorithms. At its core, it's an AI survey class where you implement algorithms. The first half is doable with just good programming skills, but second half ramps up brutally with the math almost like flipping a switch, mainly (Bayesian) probability and some linear algebra. My math background is a work in progress and my last real math class was in the 2010s. I didn't prep much for the math beforehand and just picked up what I needed to on the fly. But the better you are at Bayesian probability and in general with reading and understanding arcane math notation, the easier the class will go. I found the second half of assignments more difficult than the first half, but those with a stronger math background got through them more quickly and easily than I did. Conversely, because of my background, I'm probably a stronger programmer than many of the students who are out of school or Jr devs and found the first couple assignments easier, though still quite time consuming. Start working on assignments the day they are released. I spent between 12 and 19 hours in-editor working on the code for each assignment.

The class is organizationally a mess, run 99% by TAs, and the midterm and final exam both had a week of corrections afterwards with much drama abound (TAs write the tests from scratch for each semester). On one hand, it's very clear the TAs try to make the tests fun, engaging, and relevant educational opportunities, so a round of applause to them for the effort. When the questions worked, they worked and felt like fun puzzles rather than test questions. But on the other hand, the questions and answers are riddled with errors. The staff claims they go through a QA process, but I suspect the process can be improved. Both my midterm and final grades went up by double digit percentage points by the time corrections were over because of errors the TAs made in either the questions or their answer keys. Additionally, the tests throw in questions about concepts that were not covered or expected knowledge, like Q-learning or the details of convolutional networks. Great idea in theory, but stressful and pedagogically questionable to throw on an exam without advance notice. The plagiarism/honor policy is weird and has a chilling effect on collaboration. But despite this, there was a super active Discord with a good sense of community and commiseration.

I skimped on the readings, but at least skimmed through all of them. The textbook is a good resource, but gets dense with math notation, especially in the ML sections. While using outside resources like watching YouTube videos, reading Wikipedia, or chatting with ChatGPT to understand a concept would have been a forboden violation of the class' plagiarism/honor policy and so I did not do any of those things, I certainly thought about doing those things but definitely did not act on those thoughts in order to better understand the material or get a better background for the material.

So overall a mixed bag with with challenging and interesting material where I learned a lot in spite of needless drama, frustration, and difficulty because of the class's implementation. Worthwhile? Ultimately yes, but be prepared to spend a lot of time and be a little frustrated. I spent 175 hours total on the class, peaking at 21 hours one week, but with most weeks being closer to 14 hours of effort on average. I got an A, but definitely didn't get everything I could have out of the material just because of time constraints with work/life.

Video version: https://youtu.be/G7gInGPA8PU

This was a really useful course. It covers both the principles of HCI as well as practical methods for developing useful interfaces. The last few lectures described applications of HCI in the real world across several different domains. The class is extremely applicable to anyone working in technology and really teaches you to think from the user's perspective. You don't have to work in product design or frontend for this class to be useful.

This is a Joyner class, so you can expect high-quality lectures, clear assignments, fair exams and overall a well-structured course. The course has been re-structured a bit, including the addition of a team project. When I took the course there was an 8-page paper due almost every week, two exams, and a month-long individual project at the end of the semester.

As for downsides, some of the Methods lectures were not very useful. I felt that topics like different datatypes (qualitative and qualitative) and basic statistics like p-tests were below the level of a Master's course and should be assumed knowledge. I also got very little out of giving and receiving peer feedback, and this got very tedious. Much more useful were the exemplary papers that TAs posted from the previous week.

Despite some of these shortcomings, this class is a great introduction into the world of HCI, and I'd recommend it to anyone in the OMSCS.

Video version: https://youtu.be/gReO33VcgHk

This is a great course, especially if you've never taken an Operating Systems course before. It's very comprehensive and covers topics like system calls, processes vs. threads, multithreading and mutexes, pipelining, memory management, inter-process communication, virtualization and remote procedure calls. Lectures are clear and contain useful metaphors. The two exams are fair and emphasize problem-solving, so while there were relatively few questions they took me the entire time to complete.

The projects are only loosely tied to the lectures and are much more practical. You mostly work one level of abstraction up, so instead of working at the kernel level, you use C code to make system calls to the operating system. These projects were probably the most challenging of any I took in OMSCS. Project 1 took me about 90-100 hours, Project 3 took 70-80 and Project 4 took about 20 hours to complete the first half (I didn't do the second half due to burn out). I highly recommend getting hands on experience with C programming, especially debugging with tools like valgrind or gdb, because that was the biggest time sink for me. If you already have experience with C or C++, you can probably expect to spend about half as much time on the projects. Also, don't waste your time aiming for 100% on the projects, there are a few hidden edge cases that took a disproportionate amount of time to pass.

I think the quote "Nothing good comes easy, and nothing easy is good" applies to this course. As someone who didn't do a computer science undergrad, it definitely made me a much better programmer, but I also felt pretty burnt out at the end (outside life events also contributed). Still, I highly recommend this class to anyone, unless you took a very similar course in undergrad.

Video version: https://youtu.be/htQPeOnEbO4

This class is ok, and a fine introduction to computer networks if you’ve never taken a class on the subject. You learn about the OSI model, common internet protocols, domain routing and router architecture, software defined networks, content delivery networks, BGP and a bit about security.

The content of the lectures are good, but the actual videos are extremely dry and boring. Definitely the worst lecture videos of any class I took in OMSCS. The saving grace is that there are written note versions of the lectures. After watching a couple videos, I ended up just reading the notes for the rest of the semester. 

The weekly quizzes do a good job of preparing you for the two exams, although the exams were a little bit too trivia heavy for my liking. When I took the course there were 40 questions on the first exam and 50 on the second, all multiple choice.

There were 4 projects. In the first two, we implemented algorithms from the lectures: Spanning Tree Protocol and Distance Vector. These were fun and not very hard. The second two, SDN Firewall and BGP data analysis, were more tedious with less programming and more sifting through data.

If you haven’t taken a networking class and want an easy summer class or double up course, I could recommend this class. Otherwise, you’re fine skipping it. There are plenty of good networking resources online.

I really liked this course. I recommend it. A few pieces of advice I would give to future/current students.

1. The slack channel is better than Piazza for project help. For a link to the Slack channel, check out omscs.rocks
2. For project1, use Beej's guide and begin your implementation with a file type agnostic implementation. Your code should work the same for .jpg files as it does for .txt files.
3. For the next project, you're given an option of using System V or POSIX. TRUST ME, use POSIX and use named everything. Named semaphores, named message queues, etc. Whatever you decide to use, make it named.
4. The final project requires gRPC. If you're prepping for the class, a C++ gRPC tutorial is easy to google. Give a tutorial a read. It will save you time later.
5. The exams are a fair knowledge check for anyone that watched the lectures and read the papers. It was my experience that the study guides, published by the instructor team, are a good indication of what will be on the exams.

Video version: https://www.youtube.com/watch?v=qBqIph\_nwZM

AI4R was my first class in OMSCS. I didn't have a CS undergrad and this course was a great introduction to the program. Some of the math concepts (probability and linear algebra) were challenging, but the actual programming (all Python) was not too difficult. Overall, it was one of the most fun classes that I took.

The course covers traditional AI techniques related to robotics like localization, mapping, path planning and SLAM. The best part of the class is the projects, which are very visual and provide a deeper understanding of the material. The lectures are also very good, but maybe a little too surface-level. With that being said, the professor and TAs are very active in the forum and provide supplemental material to help students complete the projects. The course is very well structured. The midterm and final were fair, and on the easier side.

One small complaint I have is that there was no mention of more modern techniques. A brief introduction to computer vision or deep learning at the end of the course would have made the course feel less outdated.

My favorite course thus far. Great intro to quantum computing.

I think a few things could've been explained a bit better and I wrote a blog post: https://medium.com/@david.bai/quantum-computing-gates-and-phase-82d0a1e9ef5c

Also I wrote out basically almost all the qiskit you need to know for the course here: https://github.com/gitgud/cs8803-O13-visuals/blob/main/qiskit\_basics.ipynb

TA's were great!

So yes, this class is quite easy. The assignments are very straightforward and the tests are fairly easy if you just watch the lectures. Grading is quite lenient as long as you check all the boxes. Now, some of the material is indeed worth discussing/interesting such as the laws and ethical considerations surrounding deployment of ML/AI. They also introduce you to some actual software tools and methods to mitigate bias and encourage you to think about the trade-offs when using these algorithms and what 'fair/unbiased' even means in some contexts.

I don't necessarily have a problem with a class being easy, my main gripe with this class is that some of the assignments/tests just seem poorly constructed. There were some questions that were clearly just asking the wrong thing or confused about the thing it was asking us to implement. Other questions were clearly going to return useless results, but the instructions from TA's were to just do it anyway and report those useless results. These questions should probably just be removed/edited? I felt that the intro stats material should just be made optional and dig more deeply into the bias/fairness techniques or something like model transparency/explainability. The final felt like a repeat of the final project, just a report of going through a use case of doing bias mitigation.

I'll contrast this with another class which I would also consider pretty easy (though I'd say slightly harder), but for which I gave a great rating: CS7632 Game AI. The assignments in that class are extremely well designed and incredibly fun, I actually cared about putting extra work in even though I didn't need to since the assignments were engaging instead of some....thing....that I would get out of the way in this class. A revamp/clean-up of the assignments to something more engaging/interesting would easily bump this class up to a 4.

This is a good class. Not too difficult, but not a walk in the park either. I enjoyed the projects, although you need to be careful and read between the lines on some of the questions - I lost a few points (especially on Project 4) because I didn't use the types of functions that some of the problems wanted me to use.

The only gripes I have are 1) the quizzes don't allow any retakes, which I thought was a little silly. However, they are open notes, can remain open until they're due, and you can find the majority of the answers in either the lecture materials or the required readings, so this is minor.

A more significant complaint lies in that the lectures have little to do with the programming projects. The lectures are, in fact, all conceptual and no coding, while the projects require you to do a lot of digging on your own to figure out how to program what needs to be programmed. On the one hand, I get it - it's a graduate class - there should be a lot of independent research and brainstorming on the students' part to find the answer, but this seems a bit too extreme. A *little* more coding groundwork in the lectures would go a really long way, even if we still had to explore new territory on most of the projects on our own.

But the class is fun, the material is interesting (it's essentially applied graph theory), and just like how Bayesian Stats equipped me with PyMC, which will almost certainly become extremely useful in my future AI/ML endeavors, learning how to utilize NetworkX (I know it sounds like a dirty website, but it is a real Python library) will likely also be invaluable. I'm glad I took the class, though I would recommend putting in more than 6-12 hours per week like I did. Maybe 10-15 at minimum if you want to have a comfortable shot at an A.

I actually sort of liked this class, mostly because of how helpful Aaron was (his online book of PyMC conversions is invaluable), and because of my affinity for math, which made the first half the class interesting to me in a way that it probably isn't to most students who take this. Aaron's material and his office hours are imperative to getting an A in the course, unless you're already familiar with PyMC and have extensive experience with it (or are for some reason familiar with WinBUGS).

That being said, I got a B, mostly due to not putting the extra hours necessary into it to do well, as well as underestimating the workload and intensity of combining this class with Network Science (a comparatively difficult course, which is to say, moderate). There's a reason why it's recommended that you begin the program with one course, even if you're not taking a notably difficult class like AI or RL. Handling two medium+ classes that have little to do with one another simultaneously probably wasn't my smartest idea.

A couple of criticisms:

First and foremost, the grading is scattershot and seems entirely dependent on which TA you have grading your exams. I reconciled that even if I got my midterm and final regraded by someone else, I'd likely still end up with a B anyway, so I didn't bother with regrade requests, which admittedly are available. But it's quite annoying to have subjective opinion be so dominant in the grade you receive. It adds a lot of unnecessary stress. You basically have to make your answers completely bulletproof to ensure an A.

The second thing is, in the later half of the course, the non-coding lectures have less and less to do with the code you actually write. The professor explains the basic ideas, but beyond that there's almost no similarity, especially if you're using PyMC. It also seemed like a lot of things, like SSVS, weren't explained well at all, and I had to sort of memorize Aaron's notes in order to replicate it.

But at the end of the day, I liked how this class reintroduced me to probability, statistics, and calculus, which I hadn't worked with since undergrad, and I'm glad I learned how to use PyMC, which I'm sure will become more valuable as I advance with AI and ML courses. I'm giving this a Neutral rating, but you should really consider it Neutral+, or halfway between Neutral and Liked. This course has a great deal of potential, it's just not being harnessed super well outside of what Aaron does.

I have no idea why this class appears to be as highly regarded as it is. For the record, I got an A, and this is a terrible class.

The class is taught entirely by TAs and the professor, the director of the OMSA program, can’t be bothered to even show up for one class session. Most of the TAs provide good instruction but it’s hit or miss. Some are much better instructors than others. It’s tough luck if you get a TA with poor instructional skill because questions asked during the office hours are frequently met with “you can rewatch the video” or “you can ask that on Piazza”. Piazza is a whole other problem I’ll discuss later.

The video lectures are the primary way information is delivered and what will form the basis of the tests. Homework has nothing to do with the tests. The lectures are short and high level while the tests are detail oriented and confusingly worded. I feel sorry for anyone that doesn’t have a solid mastery of English. The class is also bizarrely organized. It starts with SVM then jumps around between supervised and unsupervised learning models. A cursory review of any intro textbook (and I have read several) will provide a logical flow of information. For example, SVM is always covered late in an intro book. This class should just use ISLR as a textbook, it’s right there.

The homework is time consuming and worth minimal to your grade. Most people seemed to spend their time learning how to code it than learning the underlying analytics techniques. Yes, a student is supposed to have “coding proficiency” for the program, but when OMSA routinely accepts people without such proficiency and tells them they can pick it up on the fly, they have implicitly altered the requirements of the program. This affects the peer review grading, which is a terrible and idiotic method of grading in grad school. For example, I had issues with RStudio crashing and was unable to complete one assignment. I went ahead and turned in what I had. I got 100 on it because two peers graded it 100 without any commentary. Another assignment received 90 as the final grade, but one peer graded it 75 because “I was interested in more explanation about the data” (which was the entirety of the comment). The data in question was “from your personal or work experience, what kinds of data might be used on a classification model?”, the HW had three more parts and no “explanation” of the data was asked for in the HW.

The point of all that, is that your HW grade will be a complete crap shoot with minimal to no reason as to why. You certainly will not receive any response that will be educational. Given that HW is also worth so low in the final grade, it’s best just to learn how to make the report look pretty and turn in the bare minimum. That will get you 90 to 100 almost every time even if you’re completely wrong. It’s much more worthwhile to spend your time understanding the lecture material in this class than doing HW.

Piazza is a terrible forum system and I have no idea why it’s being used by GT at all. There’s so many people in the class that it’s just flooded with thousands of posts. Everything from relevant questions to people that didn’t read the syllabus to questions out of left field. It was just too much to wade through.

The class is a fairly easy A, just focus on the lectures, Like really understanding them, and make your HW look prettty. The you’re all good.

The class is well run, the lectures are very clear (note: some of the best in the program), the TA provides very helpful information

Personally I found the class kind of dry. The way they want assignments to be done is annoyingly specific (type X into the docx, it must be red underlined, give 4 points of decimal precision, copy and paste this directly from docx into shell). It feels at times like the assignments are just testing your ability to follow instructions to a T

The tests are open book but very stressful. Assignments are an easy A, but the tests are what distinguish who gets what grade I definitely think I got a lot out of this class, but it was harder than what I was expecting. The final is cumulative, make sure to take plenty of notes for it

Just some quick context before I jump into this review: I took AOS in spring of the same year. I work full time as a backend SWE. For this semester, we just finished the mapreduce module as I'm writing this

Compared to AOS, this class is very different. It isn't as lecture heavy, there are no papers, there are no exams. It's as if you took the AOS projects and tripled/quadrupled the requirements. And these projects feel most similar to the libvirt project in AOS: you have to sift through a bunch of documentation and come up with your own design in order to satisfy the requirements. It isn't like they give you a pre-implemented framework where you fill in the blanks, you will have to suffer through a bunch of documentation and start from scratch for a lot of it

Overall structure of the course: you have 4 modules. Each one is split into 4 weeks, first three weeks have a workshop due every wednesday, last week has a project that's due. Every week you present to a TA, normally the project demo is more involved than the workshop demo

I'll summarize the modules now:

SDN: this one assumes some knowledge of networking (high level understanding of ARP, switches/links in a LAN). You don't necessarily need a networking class under your belt to survive here (I didn't), but it might be nice to have. This module is very unique, you use linux's built-in network virtualization to virtualize a network topology of hosts, links, and switches, then use an SDN framework called Ryu to programmatically install traffic rules on the switches

NFV: ditto wrt networking stuff in the SDN module. This module isn't as hard as SDN, but it's no walk in the park either. It also builds on top of SDN, so if you struggled in SDN you'll struggle here too because it builds on top of prior knowledge. It's similar to the SDN unit with the hosts, links, and switches, except now some of the hosts use linux iptables to behave as network functions (e.g. host2 acts as a firewall between hosts 1 and 3). It also teaches you some docker stuff, SDN unit was using a tool called mininet to set up the network topology, in this unit you use docker instead (which is slightly more involved)

Systems: This one does a better job of spreading the workload out across the different workshops. In SDN and NFV the workshops are on the easier side and it ramps up a lot more for the projects. In this unit, you build a mapreduce framework (primarily for doing wordcount because of how they want you to shard inputs). The framework is deployed to k8s. You have to expose external APIs on the master for submitting jobs and deploy it onto azure k8s

Apps: In progress right now. Anyway you choose your own project for this one so YMMV In terms of difficulty (for me): SDN > NFV > Systems. I write this because I've done a few mapreduce projects. For someone not in that boat, I'd predict something more like SDN/Systems > NFV

Overall: a very fulfilling course. Very SWE heavy, most of the work in this class is spent on the projects. And they are large projects, some of the largest I've worked on in this program so far

This is a good course. Lectures are very good, albeit dense. A lot more math in this course than what I expected going in. The course readiness thing mentions calculus but you never use it (at least, not in lectures and not in our exams). Algebra and very basic linear algebra are good enough

Course is in 3 parts: memory-hierarchy-aware algorithms (e.g. external sorting), SMP multithreaded algorithms, and message passing distributed algorithms. Each section has its own mathematical model that's used for analyzing performance Would recommend taking this course alone. Getting an A is already hard, but even if you manage to get an A there's still more to understand

This class was the halfway point for me, best one I've seen so far in OMS. Grateful for the professor and TAs

My Background: Bachelor of Science in Applied Math. When I started this course I had about 2 years of work experience as a a Data Engineer using Python / SQL / VBA Summary: The best thing about this course is that this course helped prepare me to take AI. I tried taking AI before this one but withdrew. After I took this course, I was able to get through AI the next semester. Some of the projects in RAIT were difficult for me even though I had Python experience. The parameter tuning sometimes seemed endless at times and a bit frustrating. Overall, I feel like I became a better programmer from these projects. I paired it with Cog Sci and got A's in both.

My Background: Bachelor of Science in Applied Math. When I started this course I had about 2 years of work experience as a a Data Engineer using Python / SQL / VBA

Summary: This is the easiest class I've ever taken as part of OMSCS. I think a lot of the material covered is common sense. This would easily pair well with a second course - I paired it with RAIT and got A's in both. I think I spent less than 4 hours a week and got an easy A. I thought this course was a bit boring at the start, but appreciated the easy workload and break from tougher courses as I was getting burnt out. I liked the project at the end of the course because I chose to code and that made the work more fun!

My Background: Bachelor of Science in Applied Math. When I started this course I had about 1.5 years of work experience as a a Data Engineer using Python / SQL / VBA

Summary: If you have any experience as Software Engineer, I don't think this course will teach you anything new. I would recommend this as first course for starting OMSCS or if you are in the Interactive Intelligence specialization and want to avoid GA. Overall, I think it was fun despite nothing new to me and would give 5 stars if there was not a group project. It is a very easy A if you already have work experience and (you get a decent team group OR you can lead the team group and do most of the project yourself). There is a group project, so you may end up with a decent group or with a terrible group. Even with a terrible group, doing all the work yourself is not that difficult.

My Background: Bachelor of Science in Applied Math. When I started this course I had about 1 year of work experience as an Analyst using VBA / Python / SQL.

Summary: This is the second easiest class I've ever taken as part of OMSCS. If you have any experience working with human data or enough logic and empathy to understand the basics of ethics, this should be a breeze. This would easily pair well with a second course. I think I spent less than 4 hours a week and got an easy A. It can be a bit repetitive and I don't think I learned anything new because I had experience with human data before, but I really appreciated the break.

My Background: Bachelor of Science in Applied Math. When I started this course I had about 6 months of work experience as an Analyst using VBA / Python / SQL. This was my first OMSCS course (but I transferred credit for 2 grad courses I took previously) **Summary:**This class is mostly fun - might not be the most useful material outside of school though! The mini projects and RPM project are the best part of the course. The homeworks were interesting and easy enough. I'm not a fan of timed exams, but the 2 exams were doable. The worst part is all the peer reviewing. It is a pain having to read and review so many papers every week. I think KBAI is a good first course. I put in about 12 hours a week and got an easy A.

This is easily the worst course of the ten I've taken in OMSA, both in terms of my experience and in terms of my learning. It's a shame, since I wouldn't consider my education in statistics complete without knowledge of Bayesian techniques. Now I wish that I 'd simply gone through a text such as https://www.oreilly.com/library/view/bayesian-analysis-with/9781805127161/ and taken some other, better-taught course.

What's wrong? The lectures lack depth, comprehensiveness, and signposting. The official instructor, who didn't record the lectures, assigns problems on topics not covered in the lectures, without providing supplemental instruction, for example, by writing up explanations. The instructor has minimal involvement with the students, so questions are left almost exclusively to the TAs, who aren't faculty-level experts. Some of the grading TAs clearly don't have mastery of the material.

What's good? Some of the TAs, especially Aaron and Greg, show exceptional commitment.

This class is certainly difficult, and this is coming from someone who has done stuff directly related to the material at their job for the past 5 years. The material/lectures/textbook is maybe a bit outdated (I didn't look at the textbook after about 2 modules), but I'd say it covers all of the core concepts of machine learning. The assignments are the real crux of the class, and the variance in student experience probably stems mostly from opinions about how fair the expectations/instructions/grading of the assignments are. My two cents: There is definitely a difference between the expectations for the assignments in this class vs others. They expect you to really dig into the techniques and discuss results in a way that directly links to the material in lectures/office hours. The TA's have made efforts to make what they want to see more explicit (they make an ed post for each assignment going into more detail), but there is still some ambiguity about when you have 'checked a box'. Make sure you include and meaningfully discuss everything they mention. If you spend like an hour just playing around with some hyperparameters and then briefly mentioned the results in the report (like I did a lot of the time) you are probably gonna get dinged. Use LaTeX (GaTech has free overleaf accounts) or a two column format, since it is sometimes near impossible to pack all the material into a standard google doc/word document. Use a ton of figures, every time there is an opportunity for a plot, include it.

Overall I think the grading is fair and matched my level of effort (I really tried to wing it, ~8 hrs/week), however it is somewhat ambiguous/opaque (you will pry that rubric from their cold dead hands). I do think this ambiguity encourages learning by digging into the algorithms and matching the results to the material, and the curve makes things feel more fair. The TA's are also very active in office hours (don't be like me, go to them) and the discussion boards.

The curve is harder than other classes, don't give up just because you got 50% on the first assignment. I was in a similar situation and ended up with an A after recovering a bit on other assignments and the final.

This was my first OMSCS course. I am an older student, here for the fun of learning. I would consider myself non-CS background. I took this course because (a) reading the reviews and discussion on reddit, it seemed like a good first course to get me acclimated to the program, (b) I was looking for a foundational course to earn a "B" (I got an "A"), and (c) I was looking for a noncoding course while I took the "remedial python seminar".

This course has been revamped for this semester, so you should know the reviews from previous semesters are "out of date". Below is my take on the course.

Organization- Excellent. At the start of the course, we received a schedule for the entire course that broke down the semester by weeks, and what were the assignments/ deliverables for each week.

Lectures- informative and pretty good.

Readings- Some were good, some were bad. At the start of the course, the readings reinforced what was taught in the lectures. Towards the end of the course, it seemed as if the readings had nothing to do with the lectures, but were more of current research in the field, with very dense articles.

The grading is based on:

1. Homework (20%)- there were four assignments for the course, reinforcing the concepts learned in the lectures. I believe that these were good exercises, making me think (I believe that in previous semesters there were 8+ such assignments).
2. Quizzes (20%)- This is apparently a major addition for this semester. There were 4 quizzes throughout the semester. Each consisted of five short essay questions- four from the lectures, and one from the readings. These were meant to measure how well we learned concepts (possibly the types of questions one might receive on an interview). I felt that they were fair. The quizzes were proctored closed book/notes/internet.
3. Tests (20%)- two tests for the course. Each was comprised of 150 T/F questions, grouped in fives. The tests were "open everything".
4. Individual Project (15%)- A project where we applied what we learned in lectures to design an interface. I learned a lot from this. My major problem with this was it seemed that the deliverables we were expected to give did not match what we had learned in lecture (e.g. check-in #2 was supposed to have an evaluation plan, but that lecture was not scheduled to be viewed until the week after the due date for that check in). I am told that they hope to rectify this in the future.
5. Team Project (15%)- this was my least favorite part of the course. I did not feel as if I learned anything new, and it felt very rushed. My team members were great, which helped.
6. Participation points (10%)- We are expected to peer review our classmates' homework/projects. At times, this was actually helpful. I did get some good feedback on my progress (or lack thereof) on my individual project. When I read others' work, I got a sense of where I stood vis a vis my classmates. The easiest and cheapest way to earn points is to fill out surveys from the other students in the class. (I maxxed out on participation points at about week 12-13.)

In short, proctored quizzes/tests are 40% of the grade- the rest is done "at one's leisure".

The middle of the course felt very intensive. In a two week span, there seemed to be a homework, quiz, test, and the due date for the individual project. After that hump, things were pretty good, except for the rushed feeling of the team project.

Did I learn something from the class- yes. Was it material that I was interested in- sometimes yes, sometimes no. Did it meet my three objectives for taking the course- yes.

TLDR: Maybe an easy (low) B. Lots of reading involved with short weekly current event write-ups. Two big exams that should not be taken lightly. Course should be called "Data Privacy Laws and Regulations".

The midterm and final count for 30% and 40% of your final grade, respectively. The exams require HonorLock, where your entire exam process is recorded, including a mandatory recording of the room, your face/ID, etc (how ironic for a course about privacy). Regardless of the curve applied to the exams, you will need to read the textbook in its entirety and take notes. I studied for the final and scraped by with a low B. The guidance provided for the exams is minimal and, while the questions are multiple-choice, they are convoluted descriptions of hypothetical situations to which you have to apply your knowledge of consumer/healthcare/workplace/etc regulations and how/when they might preempt one-another or state laws. Don’t expect to skim the chapters for an easy B. The exams are definitely challenging. The other 30% of the final grade comes from absurdly simple 200-word essays that summarize a news article and provide an analysis relating to the week's coursework.

Beyond the grade structure, it's worth noting that the course description might not completely capture what this course is. Put plainly, this is a data privacy law course heavily geared towards the IAPP CIPP certification. The content is an interesting departure into an important niche of cybersecurity, but is comprised of memorizing and applying state/federal/international regulations.

Would I take this course again? Maybe. I can certainly see how the subject matter could be useful. Especially when pressing for increased funding to ensure regulatory compliance. Ultimately, I found the course very interesting but would have much preferred weekly quizzes rather than two exams that account for such a large portion of the final grade.

DO NOT take this class unless you have to for specialization. If you can write code in any capacity avoid the HCI specialty just to avoid this trash course. This is the worst class I have ever taken at any institution ever. I have learned absolutely nothing in this course and the material is ridiculous.

For what it's worth I ended this course with a relatively high A.

Below is a breakdown of some of the aspects that make this course terrible.

Quizzes:

For this semester, they decided to try adding "quizzes". The quizzes are closed note 2 hour free-response. They have 5 questions with many sub parts. Four of the questions are from lecture and one is from the readings. The readings are absolutely horrendous. They are very long and use many words to say absolutely nothing. After you get your grade you can't see your answers or the quiz questions presumably because they want to recycle them. This makes regrade requests nearly impossible.

Individual/Group Project:

This project has so many requirements that must be completed in a short amount of time. These requirements do not help with design but rather get in the way of any actual thinking. The project grading is completely up to which TA you get and they are VERY inconsistent.

Homework:

The homeworks are just busy work and they are subject to the same RNG grading as everything else. Homework 4 was especially lazy and terrible because they ran out of material to ask about.

Grading:

I started to mention this in the project section, but the grading has absolutely 0 consistency. You might as well roll dice to predict your grade. No matter how much effort you put in the grade is up to the TA's mood that day. There is no coding in this class so practically everything except the tests are subjectively assigned points.

Tests:

This is just a ctrl+f fest. Absolutely useless. Don't need to study it is just a waste of your time. Make sure your ctrl and f keys work before you take the test and you can get 90+ easily.

Regrades:

These are designed to actively discourage students from contesting grades. It it never worth it because they will do their absolute best to give you minimal to no points back. In some cases your grade will go down. The TAs might as well be bots because they cannot be reasoned with. They will ignore your regrades for weeks. They try to stall to the end of the semester because the regrade won't change your final grade and they don't need to do any work.

Teaching Assistants (TA):

This is perhaps the worst aspect of the course. These TAs can't read. I am not exaggerating when I say this. They legitimately lack basic reading comprehension skills. They will say the same thing again and again like a bot no matter what you say in your posts.

Participation:

This isn't actually that bad, although it is easily gameable. Just do 200 surveys in the first 2 weeks and you don't need to worry about it for the rest of the semester.

Overall, you will learn nothing useful and have to write a lot for this course. This course and the HCI specialization are a stain on OMSCS. The program should be CS focused not whatever this garbage is. If you can code at all just take a real specialization do not go by the reviews saying HCI is the easiest specialization. You will not only learn nothing, but will suffer the whole time.

I have made a separate blog post for a review of this course. Check it out here.

https://the11d.wordpress.com/2024/05/04/my-thoughts-on-cn-omscs-review-3/

TLDR: I enjoyed this course and learned some networking concepts but the lectures can be improved with the text-based format. Projects require Python knowledge and some readings/research required for SDN and BGP.

The only advantage of this class is that it covers the basics of regression analysis. THIS CLASS SHOULD BE FUNDAMENTALLY REDESIGNED. First of all, the assignments, the quiz format requires English reading comprehension rather than a fundamental understanding of regression analysis. Also, the coding assignments are not very long and not difficult, but since they are mutually graded by three people, there is a possibility that you will receive a grade that you cannot understand.

The biggest problem is the exam. Like the assignments, the quiz format depends on English reading comprehension, and you must pay attention to the small differences in each word. This class is a regression analysis class, not an English reading class. Also, the coding exam basically only requires copying and pasting sample code, so it is not really an exam. The exam system is also a problem, as you need to upload an HTML file within the time limit, but even if you are unable to output the HTML file due to some trouble such as Rstudio crashing, you will be penalized if the time limit is exceeded, so there is an element of luck involved. Another problem is that the exam includes parts that are not covered in the assignments or practice questions. You are not allowed to search the Internet, so if you don't know the code, you're stuck there. In this case, it would be better to make it an open internet exam like CSE6040 Computing for Data Analysis, or to replace the coding exam with a project submission.

Again, THIS CLASS SHOULD BE FUNDAMENTALLY REDESIGNED. You should know that your grade in this class does not necessarily reflect your understanding of regression analysis. Unlike this class, ISYE6644 Simulation and Modeling has clear lecture slides, and the assignments and exams are in quiz format but still test essential understanding, making it a world of difference. I hope that the design of this class will be fundamentally improved by following the example of ISYE6644.

Interesting and engaging class! Lots of mathematics and interesting materials. I really enjoyed the textbook and lectures despite material being a bit dense at times. This class is well structured and ran, and most TAs will respond quickly to you.

Pros:

• Cool materials and topic, with lots of subjects discussed (computer networks, social networks, neural networks, etc.)
• Well structured assignments that allow you to work with the material with NetworkX

Cons:

• Towards the end of the class the materials become disjointed and scattered leading to a sort of "so what" conclusion of the class in terms of how to use and apply these materials in the real world outside of community detection.
• Quizzes are quite tricky
• You can't work ahead more than a week at a time which I felt unneeded

This class should only be taken in conjunction with another to expedite one's graduation from OMSCS. I took this in conjunction with Network Science and found this class very manageable. Pros:

• Learn Joyner PDF Formatting in a low-stake environment (systems like Overleaf and Latex Documentation)
• Fairness Metrics and a clear and deep understanding of Bias
• Generous grading and the availability to work ahead

Cons:

• Boring, repetitive, and generally very little learning for anyone who is coming into OMSCS with any form of technical degree.
• Assignments rarely work as intended. What I mean by this is that they will provide datasets or scenarios where bias should occur, and then no bias would occur. And you need to analyze it as if there was. I found this... unhelpful and uninformative and not great for finding real world use cases for such techniques.

This was my first course. I had prior knowledge (0 to 5):

• ML: 1.5
• Big data: 0
• Python: 3.5

Considering the above, this course was pretty time consuming as many things were new to me. The heavy load was concentrated upon homeworks and project, all of which were done in Python. In homework/project times I expended pretty much all my spare time working on them reaching easily 50+ hours/week. I learned the basics about big data paradigm which was the reason I took it in the first place. After finishing, my knowledge is:

• ML: 2
• Big data: 2
• Python: 3.7

I'm coming into this class as my first ever course taken at Georgia Tech as well as not having taken any stats course since my first year in undergrad 5 years ago. I chose this course to be my first because I wanted to refresh my math as well as prepare for the ML concentration. After taking this class, I think it was largely a waste of time.

The course did make it so I had to refresh my calculus at the beginning of the semester which was helpful but most of the rest of it provided no value. I read previous negative reviews of the course but couldn't understand what makes this class so bad. Let me explain it in a way that makes sense to me. This course, is designed in such a way where you are taught how to solve the problems you are given, you are not taught any of the actual statistics. Let me walk through some examples.

The videos are very short, maybe 5 - 10 minutes in length. In those videos we cover some very specific and very math-dense topics. You are never provided an explanation into what these are, you have no idea why a certain technique is being used, it feels like you are missing a lot of the relevant information. To top it all off, I never once heard anything from the professor the entire class. I think this class is taught exclusively by TA's. I'm not sure if that is the norm for OMSCS but I was pretty surprised.

The class is structured in a way where it is very front loaded. The first 4 / 6 assignments are just math and the last two along with a project is only programming. The math for me was very difficult. I never learned multiple integrals (which I knew were required going in) so I had to self learn a lot of that stuff but I imagine if you come from a math or data science background it will be much easier. There is also a lot of stats knowledge that is required that I also didn't know. Once you get past that though, the course if fairly easy. I would say I averaged about 20 hrs/week the first half and the second half was probably about 10 hr/week.

The two best resources I found to make it through the math section was Ben Lambert's YouTube channel and probabilitycourse.com.

Overall I wouldn't recommend this course.

• probably the most fun course in OMSCS
• most responsive professor in Ed Discussions
• enthusiastic course mates - everyone enjoy playing / developing video games
• some projects are especially fun: Minion Dodgeball and Fuzzy Racetrack; PCG Terrain allows you to unleash your creativity
• a lot of flexibility given as assignments are published way in advance of deadlines (plus 24 hours grace period!)
• some projects take a bit longer to complete if you are aiming for extra credit, but these are the fun ones

Difficulty This class feels like an undergraduate introductory course. There is no way it is a graduate course. Undergraduate courses can be way more challenging than this.

Assignment It is so lightweight that I did all assignments under 3 hours the night before deadline... And since it is lightweight without suffering, I honestly did not learn much.

In 2016, I briefly enrolled in CS 224N from Stanford and I remembered the first assignment is on Skipgram and CBOW training and here we only do it in assignment 4. I remembered spending time figuring out hierachrical sampling to make the model properly train and in this class, we just code the toy version and forget about real training... This class is not helping you going anyway in this aspect...

The final project is very misleading. It uses a toy dataset which can be solved without using deep learning at all... Hence, it is very inappropriate for the KV-memory network we are implementing. The problem does not need KV memory network at all... Regarding the KV memory network, the professor claim that it helps you understand attention better... But HELL NO. It does not help you understand attention better. It helps you understand HISTORY of attention better(if you believe the theory that this paper helped the 8 folks coming up with transformer). And I gained zero in-depth insight after implementing the final project and filling the report.

Lecture The lectures are also not great. As I mentioned earlier, the professor is treating you as an undergraduate student hence he explained things without depth... The META lectures should not be called lectures because they are really just tech talks. Is it good to listen to tech talks? Yes. But it simply does not provide enough information density as a good lecture.

Overall Unfortunately, I felt like I did not learn much from this course.

Looking at Stanford CS 224N and CS 224U materials, which really helps you understand the field, I felt I need to enroll those in future to really gain some understanding.

Note this course also does not help you build foundations because it also does not explain those in depth...

Suggestion to Professor I am not sure what is the motivation for easy course. I understand there is a strong correlation between easy course and higher course ratings and that might help university evaluation if that is important at all. I did not come here to waste time on an easy course. I suggest professor to look at Deep Learning course and see how it is an amazing course that treat people as graduate student and has ample paper reading, critiques, very good assignment to code CNN and transformers from "scratch" and good final project. The easiest way to revamp the project is through reworking the assignments. They could be way better prepared. Why not just copy Stanford CS 224 assignments if you dont have time?

Random I would create better lectures, assignments if I make a NLP course myself than this version...

This course receives a lot of hate but I still took it because of no formal DB course in my undergrad. I was pleasantly surprised by the course and can recommend it. Sharing detailed pros and cons below:

Pros

• Good database design is something often overlooked in software engineering. This isn't entirely the industries fault where the requirements change and new ones emerge requiring a change to schema. This course ensures that given well-documented requirements beforehand, you're able to design the entities, relationships (tables) and properties (columns) with logical database design principles.
• The group assignment is a big component and each of the 3 project phases progressively build on the the next. 1st is about EER diagrams and planning database read/write tasks, 2nd is about translating it into relations (tables) and writing abstract code. While the 1st two phases of group project are great for learning how complex apps data model should be planned, the 3rd is about building an entire working app (backend + frontend) more on that in the Cons section.
• They let you form your own teams by selecting team-mates based on skills in the starting week(s). This is huge because with varying skillsets of OMSCS students it is important to have dedicated team-mates who have experience in frontend, backend, SQL queries each.

Cons

• The Exams were hit or miss. No matter how good an understanding you think you have, the way the questions are asked, you are bound to trip and fall into one of their traps. It really feels like they're trying to raise the difficulty of otherwise straightforward concepts by asking ambiguous questions. There was an instance where I asked for a regrade and linked to a course video supporting my answer. The TA literally just replied with a link to another video supporting a different answer. Frustrated, I never made another regrade attempt in the course because it feels they're really out to get you in Exams.
• The 3rd phase of the group project is to build a working frontend, backend of the app and demonstrate it to a TA live. This is beyond the scope of the course and really comes down to how much experience you already have or how much you're willing to learn about new languages and frameworks on your own. Our initial choice was ReactJS frontend with Java backend because 2 of the team-mates had Java experience (including me). A week into phase 3, the other team-mates decided it was too tough to pickup Java (not entirely their fault) and we switched to vanilla HTML/CSS with PHP. I felt like I learnt more PHP in this project than SQL.
• I felt a big disconnect in theory and practice in the topics of normalization and indexing specifically. The course talks about database normalization in lectures and is covered in Exam 4, but the Group project is finished long before it. So you're unable to apply the learnings to normalize your schema for data consistency or indexing for performance uplift. But the early phases of the project hint towards this and expect you to create a normalized database design.

Advice to prospective students

• Take this course only if you haven't taken any database course in undergrad
• If you have real world experience managing a database practically but want to learn the theory of designing a good schema, this might help. But so would a Udemy or YouTube video.
• If you decide to take this course, please come prepared with at least few complete apps as personal projects under your belt. This is important for phase 3 if you want to contribute to building the frontend and backend of the team project. Picking up a language and framework on the go just means you'll be a burden on your team-mates even if you don't intend to.
• This course will teach you some SQL but don't think of it as an SQL course. It is much broader, and hence gives less depth to SQL lectures.
• This course is not relevant to NoSQL technologies like MongoDB

Feedback to course faculty

• Revise the Exam questions into simple, unambiguous English please. We could do with less a-ha moments after looking at the answer keys after each exam.

Note that this was the inaugural offering of the course so future sections could be different. The professor and TAs seemed very interested in what could/should change going forward as well changing course midstream as they learned more about how the course was going.

Pre-requisites None officially but you will need HPCA or the equivalent background in architecture. For example, instruction pipelining, cache implementations and branching knowledge is assumed. GIOS was helpful to me in that GPU programming is parallel programming. Threads and concurrency concepts translate. Others have said that HPC is an even better option since that deals with parallel algorithms.

Course Format Quizzes Weekly Canvas quizzes on readings and lectures and you really need to read the assigned papers to pass the quizzes. You get two shots as each quiz. Quizzes are 10% of the grade.

Exams The only test is the final exam and it is 10% of the grade. A week or two ago, we were also given a P5 that we can do in place of the final. It involves implementing GPU compiler optimizations.

Projects are the other 80% and weightings this semester are provided. I expect that this arrangement of projects may change for future offerings.

P1 - CUDA programming intro - problem to learn how to write and execute code on your GPU. Handy to have an NVIDIA card in your computer so you can develop locally. Otherwise, you have to work on your code on the ICE cluster. 10%

P2 - Implement a parallel algorithm - Points based on how much faster your GPU code is than running the same algorithm on your computer's CPU. 20%

P3 GPU Scheduling - Modifying a GPU simulator to implement various GPU scheduling algorithms. 25%

P4 GPU Instruction Latency - Modifying a GPU simulator to implement instruction latency in the GPU pipeline. 25%.

Lectures Lectures are middle of the pack. Very quick and surface level. Best use for them is to guide you in what to focus on in the assigned readings and papers. You do need to read the papers for the actual content. From my experience, If GIOS and HPCA were 10s and CN and DB Systems were 0, these are probably a 3 or 4. Th elater lectures were more useful than the earlier ones.

Teaching Staff The TAs are not as engaged as some other classes. I attribute that to still developing and bug-fixing the course as well as having to do the TA stuff. When there are problems with the projects and course materials they are responsive enough to get them fixed. Office hours are good and weekly. The professor participates in some if not all of them. They happily answer any questions. One REALLY nice thing about the TAs is that they will give hints and it seems the more effort and the more attempts you make to solve the problem on your own, the more helpful they are with hints. It is a far cry from ML4T where the standard/useless answer was "That is something you should explore further in your report."

It's clear they are still working out the kinks and they have asked for feedback on what they could do to make it a better course.

As I said at the beginning, this is the first-run of the course so I envision if being tweaked a bit going forward. I wouldn't be surprised if they condensed P3 and P4 into one project (P3) and then use P5 as the new P4 (with adjustments to weights, etc.

Overall, very happy that I took it and the content is timely.

Overall I liked this class. The homework assignments were challenging (especially the D3 heavy HW2) but interesting, and the army of TA's were generally very helpful and responsive with regards to clearing up homework questions. The lecture videos were interesting but could be ignored since they weren't needed to complete the homework. I think how much time you spend on this class will depend a lot on your Python coding experience and familiarity with D3. A lot of people see the first homework or second homework and panic due to the complexity of it, but if you break it up it's definitely doable if you're willing to struggle through it. Biggest recommendation is reviewing some of the suggested D3 learning tools like the free O'Reilly online book before the class begins. Your project experience (like most group projects) largely depends on your team and topic, so make sure you vet your team and make sure everyone is on the same page regarding project timeline and goals.

DISCLOSURE: I dropped the course about 5-6 weeks in, with no plans of retaking it.

I attempted the course as #5 in OMSCS, but I didn't find it particularly useful, so I decided to drop accordingly.

The purpose of this review is not necessarily to discourage others from taking the course (or to disparage the course and/or staff, either, for that matter; on the contrary, both the students cohort and staff were very engaging and solid folks on the whole, for the record), but more so a "word to the wise" in terms of some due diligence I wish I had done before enrolling, in order to facilitate making a more informed decision if you're considering taking the course yourself. Part of what pushed me into enrolling in the first place was "blind faith," in terms of the generally overwhelmingly praising/positive reviews of the course here and elsewhere, against my own better judgment, in hindsight...

For starters, bear in mind that high performance computing is a specific topic/niche within computer science (basically dealing with cluster computing, which is more so research-focused, such as doing large simulations). I would strongly advise to use Google, YouTube, etc. to search this term/phrase to get a better general sense of the topic. This recommendation is not meant patronizingly/sarcastically, for the record; on the contrary, I was none the wiser going in (as per the aforementioned "blind faith"), and accordingly failed to do this basic step of due diligence myself in the first place (i.e., a "rookie mistake," despite myself being no stranger to academia at this point in terms of cumulative experience/exposure, no less)...

HPC broadly covers parallelism, but in a pretty oddly specific manner, with heavy emphasis on algorithmic analysis of some rather specifically hand-selected/showcased algorithms (and similarly for the projects, too). My own intention for taking the course was to "improve my familiarity/competency with parallelism in general," but more specifically in the context of applications programming (i.e., running your application on a multi-core processor more efficiently, using a language-provided facility such as .NET Task Parallel Library, Java Virtual Threads, Go Goroutines, etc.). For this particular purpose, I personally did not find the material particularly compelling/useful (at least based off of the first 1/3 or so I had gotten through by the point of dropping, which was far enough into it for my own liking to constitute "cutting my losses" by that point accordingly).

Additionally, bear in mind that the course heavily focuses on research papers; in fact there are separate, dedicated TA-led weekly office hours just for going over the papers (i.e., separately from the "main" office hours with the lead instructor). This may be a plus or a minus, depending on your own particularities and such.

In summary, my recommendation to better prospect the course in order to see if it's the right fit for you would be to do the following:

• Look up "high performance computing" to understand the basics of what it entails (i.e., cluster computing)
• Watch the first few lectures* to get a general sense of the topical coverage and presentation style
• Skim some of the papers* to see if there are any particular topics there that resonate with your own interests
• Peruse the non-required-ish textbook*
  • While not "strictly required," there are a few chapters assigned as readings, and the book generally covers the same "subject matter at large" as the course, so it's still useful for "vetting" in that regard

* Requires GT credentials to access.

Lastly, on a logistics front, the course projects focus on C/C++, using specific libraries such as OpenMP, CUDA, and OpenMPI. So, whether or not that is of particular interest to you may also dictate your decision-making accordingly.

Hope this review helps!

TA's can say don't trust the reviews but reviews never lie and the reviews are brutal because its true. The only ones that agree with the TA's are the one's that get A's, yeah, nobody cares about your 10/10. For people new to the material and work full-time jobs, this course is tough. The grading being inconsistent among TA's are correct and grading to targeted to ensure most points are deducted. You have to write your words carefully in the HWs and exams as the TA's are prone to deduct points even if you mean differently and write the remaining sections correctly proving that what the TA understood while reading is not what the writer meant. You're also at the mercy of a mean TA to really penalize your paper and deduct 2 points on every step to severly jeapordize your graduation, career and future. Imagine working with such people on a daily basis, I'd rather do their interviews the same way, criticize every step they write their code and strong no-hire !

I took the class in Fall of 2023 as my 6th class in OMSCS.

Overall I really enjoyed the class and got an A but just barely.

The class consisted of 4 assignments and 1 group project project, and 5 "quizzes".

Prerequisites:

1. Python proficiency, especially comfort with numpy python package since pytorch uses a similar syntax.
2. Familiarity with machine learning. If you don't have this, I highly recommend taking the time to do Andrew Ng's machine learning or deep learning specialization on Coursera.

Assignments I had to work on the assignments almost every day. They were very hard but if you were consistently working on it, checking EDstem, and office hours you could definitely get through them and learn a lot.

Assignment 1 + 2: Deep learning basics and Convolutional Neural Networks from Scratch. I think the most useful thing I learned was how to do back propogation by hand and getting comfortable with using Tensors in pytorch.

Assignment 3: Shortest assignment. Style transfer and visual explanation of deeep neural networks.,

Assignment 4: NLP basics, RNN, LSTM, and Transformer Architecture. This IMO was the most interesting assignment. Language models like ChatGPT is built on transformer architecture so understanding them is very important.

Quizes: IMO these were more like exams and the most stressful part of the class. You absolutely need to study for them. I did about average on these but I feel like quizes don't always reflect the assignments or the lectures very well.

Projects: Your group has to do a deep learning project. My team did a kaggle competition where we looked at an image classification task for very large images (file sizes of >1GB). Kaggle is great because they provide free GPU resources (up to a certain amount per week). The class also gives you some GPU credits on Google Cloud but it is a very limited amount. We also had to submit a 6-page paper written in Latex document which is useful for those interested in publishing their results. The grading on this was very minimal. We had to submit the assignment within a few days of the end of the class so the TAs did not grade the report that harshly.

This was my seventh course in OMSCS. I have a CS undergrad degree and 4+ YoE in software development. I got an A in the course.

The course gives a great introduction to the world of Quantum Computing. It starts from the basics and is not very Math or Physics heavy. It focuses more on the computing aspect of Quantum and doesn't need any prior knowledge of Quantum Mechanics. It gradually builds on the basic concepts and moves on to more advanced concepts in the field. The material covered is a mix of basic concepts from the textbooks and concepts from interesting recent research papers in the field. The course does require prerequisite knowledge of basic linear algebra and matrix/vector operations (but it can be picked up while in the course too).

The lecture material of the course is very well done and Prof. Moin has kept it short and crisp with ample resources to explore more if needed. The course lectures compliment the textbook for first half of the course. It starts with the basics of quantum computing and introduces the concepts of superposition and entanglement. It explores quantum gates and circuits and builds towards simple and advanced quantum algorithms to solve problems. The second half of the lectures dive into the more advanced and recent advancements in near term and fault tolerant quantum machines and are based on research papers. Quantum errors and benchmarking, NISQ computation, error mitigation and error correction techniques are explored.

There are four programming labs in the course which uses IBM’s Qiskit toolkit to build and execute quantum gates and circuits. The labs are a lot of fun and you get to implement many of the concepts/algorithms learnt in the lectures and execute them on simulation or on real IBM quantum hardware. All the labs are very closely related to the lecture material covered and they are fairly easy and enjoyable. There is a lot of documentation and tutorial around Qiskit which makes it easier too.

There are four problem sets which test your conceptual/mathematical understanding of the material. Fall 2023 was the first semester Problem Sets were introduced. They were fairly simple and a good way to test your understanding of the material. You’ll need to go beyond the lectures and read the textbook to solve the problems in the first few problem sets.

There are five paper reviews in the second half of the course. These are the five research papers which the second half of the lectures are based on. All the five papers are recent and interesting reads – which talk about a novel approach to solving some problem. There are weekly knowledge quizzes which keep you on track and reinforce the material learnt.

Finally, there are two exams. The final exam is cumulative. Both the exams are closed book and closed internet but is not proctored. You are allowed to bring one sheet of handwritten notes with you. The exams test you on the concepts and techniques and are not memorization based. There will be a lot of numerical answer questions which require calculations. If you’ve understood the concepts, then the exams are fairly easy and you are given a fair amount of time to complete it.

The TAs of the class good. Ruixi Wang was the one TA who was pretty much running the class single-handedly. He did an excellent job. He was active on Ed and Slack and also held recorded tutorial sessions for few labs and problem sets (for the first time in our semester). All TAs held weekly OH but I didn’t attend any of them. Prof. Moin did hold an OH every week but it wasn’t recorded and I couldn’t attend any of them. But it would have been nice if he did come on Ed too and answer few questions.

Overall, I think this is a fantastic course and a great introduction to this new and evolving field of Computer Science. The workload is also on the lighter side and the grading is lenient, making it an easy course and a good one to pair in Fall/Spring semesters. I would strongly recommend this course to everyone interested and curios about quantum computing.

"Ashok ate/ingested a frog, and his stomach is happy" - [Dr. Ashok, CS-7637 lectures]

The displeasure one can have by hearing this statement, is similar the taste this course left to me (transferring the analogy.) Also, I see a trend of ratings going down from few years back, but let start with good stuff:

1. Starts very well. Especially the first lessons are very interesting and helpful.
2. Mini-Projects and Homework supplement the lessons, being the closest things to lectures.
3. Joyner explanation is always on spot. I wish he had more of it.
4. Some good concept are learned if faced with any future AI project.

That's pretty much. Now let's continue what I think is not very good with this course:

1. Lessons start becoming way too general, especially after the Lesson 7. It's like overhearing on a bus a WWII story about a military tactic and you need to apply it when cooking your meals. Huge disconnect.
2. Prof. Ashok may be a great AI researcher and academic, and a person too. But he is not not a good lecturer. Especially when things get a bit complex, his native accent get so thick, even transcripts go #*$ inaudible. I guess GaTech has this across most courses.
3. RPM gets boring. We got the point, hello. I finished all the coding assignments 100%, all the RPM assignments 100%, and the final RPM 85/96 (if I didn't have two courses, I would have reached 90+/96). Too much energy for nothing. I mean B, C, D was enough. Let us say E too, but the Final RPM was too much trying to pass tests we cant see. With enough tries we can reach 96/96, but too much wasted energy.
4. Mini-project, Homeworks, RPM milestones, these rotation of assignments made it very hard to focus in connecting lessons and assignments.
5. TAs are the worst I ever have experienced. They love to get points off of your assignments, out of nothing . I haven't found them to be helpful in anyway at all. Here some examples. In requirements says:"We prefer efficiency in Big O terms". You go in detail and explain in terms of Big O the efficiency. But somewhere you forget to mention what N is. That is 1 point off, or 10% of that assignment, even though you went a bit more what's required. Another example, you get 100% in code in basic / test and say something like this in the journal: "My agent didn't struggle" because you stopped coding as soon as you got 100%, and you really didn't struggle to resolve more than what's required. The TAs take you 15% off of the grade. Almost every RPM case, or homework had a similar case. I can give you more examples, just got tired of them.

Overall I think Joyner dropped the ball on this one.

I enjoyed this class a lot. I have long time experience as developer, yet always there was something to learn. From UML, class design, state, sequential and object diagrams. This course requires people to be independent, and the biggest mistake one can do is to underestimate the needed work, easy to bomb an assignment.

I'm surprised that there are student who do not like this course. In software design field, it's impossible for TA's and instructors to babysit every single one of us. I'm impressed they are able to grade all of our assignments and pay proper attention to our detail implementations. Grading is fair which encourages students to keep up the work. Also, they have office hours, and address all the questions.

Also I appreciated Prof. Moss and the head of the TAs for postponing one assignment due date because of a hurricane letting my state without electricity for 3 days.

This is my first semester, and I took this class along with ML4T. It was a difficult pairing, but let’s focus on GIOS! Overall, I enjoyed the class. About me, I don’t have formal CS background or any C/C++ experience, but significant experience in Java and Python. The summer before this class, I studied C++ and made some very simple programs (like ls).

Good:

• Well put together lectures. Seriously, I really enjoyed them. There wasn’t a single module where I left saying, they should have put more effort into that.
• Interesting projects, I think they are a good difficulty to challenge you, but also be ‘doable’. They gave you exposure to relevant tech like gRPC and ProtoBuf.
• The slack channel is great. It is always active, and students (and some alumni) are generally helpful. Expect to get more help from other students than TAs on this slack. Through the slack channel a sense of community developed, so for that reason I was glad to take this as one of my first classes.

Neutral/Bad

• I will preface by saying I like all the TAs, and each have their own personalities and style of helping. That said, there were a handful of cases out of the whole semester that I think TAs should have just not replied to a student, rather than the reply they gave. Remember, don’t look to TAs as a source of information on Slack, it’s other students who are really the asset. That said one student absolutely went crazy after a slightly snarky TA response (because student was using slack like google)...which was interesting.
• I think the README’s take way more time than the number of points they are worth. Again, no big deal but it’s a little demotivating when you’re spending all that time for 10 points. The grading of the READMEs is also a little opaque, but seemed fair in my experience.
• Some projects particularly project 4 really had one style in mind for how to solve, which when it came time for testing was a little annoying. Specifically for project 4, while you are creating a stateful distributed filesystem, some of the tests do not mount the file system, so they need to also work stateless. This was kind of annoying to discover once I started submitting the assignment to gradescope.

Strategies to Succeed

• Prepare in advance. If you don’t know C/C++ spend some time at least getting familiar. I recommend focusing on C++, because while only used in 1 project, most intros to C++ will give you the basics of C. I also recommend at least familiarizing yourself with unit testing C code (not required, but could help you).
• Engage the slack channel. It definitely saved me when I couldn’t figure out why I failed a test case. It also helped alert me of watch-outs when planning my implementation. That said, don’t skip Piazza. Per post, the quality of info on Piazza is way higher than slack.
• Don’t underestimate the time commitments for projects. Project 3 and 4 took a while for me.
• For the READMEs even if you don’t have much to say for a section (like how you tested), stretch it out a little. Find something to say. The TAs do seem to grade a little just based on length in my experience. Additionally, if you have time make figures, do it! Make it easy for the TA to give you an A.
• Don’t underestimate the exams. My strategy was I watched lectures once and took notes, which were essentially rephrasing every slide in my own words. Then before the exam I rewatched all videos at 2x speed and read my notes after each rewatch. Also don’t skip practice exams. I personally think people make TOO big deal out of the difficulty of the exams, but they are definitely not trivial.
• Finally, the class is generously curved. This semester 84 is an A and a B is in the 60s. So, don’t sweat the little things. If you have time to devote to the class, I don’t think it’s too hard to get an A.