The course is okay but I really want to slap some of the student reviewers that leave peer feedback. They write like they only have the write answers that now I am extremely critical when I leave feedback. Screw you too.

This class was great, I go over every detail (in 5 mins or less) in this YouTube video! https://youtu.be/lFupZlo2pnw Enjoy!

I was majoring in EE, and took Matlab, C, c++ during my undergrad, and took CS 1371 and Python BootCamp on Udemy prior to CSE 6040 and thought I prepare pretty well for the course but I was wrong. This class requires lots of prior experience and strong mental health. The first notebook aka homework and 3 out of 6 "prerequisite" problems were relatively easy and gave you a false sense of your knowledge. Notebook 2 crank it from 0 to 100 really fast. The videos aren't helpful for your notebooks and tests. You need to know how to google things; that's the one skill I learn from this class.

To prepare for the first test, just focus on the 6 most recent tests as the old ones don't help you too much. I made the mistake of spending wayyy too much time on the older tests. The 1st test is definitely DIFFICULT sooo study 2 weeks beforehand. I did so badly on the first test.

As for the 2nd test, I learned to study the 6 most recent tests. My grade did improve but still not good enough

The final was as hard as the 2nd test I think. Barely passes the class with a C...maybe i was not as bright as other students in the class

Read my full review in a separate post. Thanks https://the11d.wordpress.com/2023/08/15/my-thoughts-on-iis-omscs-review-2/

This was a relatively easy A for me, while still being a valuable course for which most of the material was novel to me. The pacing is a bit odd, at least in summer, and highly front-loaded. I got the most value out of the first half of the course, when we had to learn how to use the LLVM API to implement compile time checks. I have no interest in taking a class solely on compilers, but I liked getting some high-level understanding of how LLVM works. I also found it helpful to force me to stop using my C programming skills as a crutch whenever I have to modify some C++ code, and actually start learning C++ as its own thing. It would not be possible to write the LLVM API in C with its current object-oriented design.

The course shifts to more of a survey course on dynamic analysis techniques in the second half. The workload dropped substantially at this point for me. But these were all pretty interesting, especially Klee.

I thought this was a very well done class on a topic I knew nothing about going in, so that alone made this an interesting class. This is still a pretty new class, and this is reflected in the lectures. They're clear and well done. Some of the better lecture videos I've seen in the program. Some of the required papers to read in the class are only a few years old, which makes the course seem very up to date. Also, it was encouraging to read a paper and get ideas on how to address some of the issues or on where someone might be able to pick up where the paper leaves off. For me, I would get ideas, then it would turn out the very next paper is on the idea I just had! Structure: There were 2 exams, a mid-term and a final. There were weekly quizzes on the lecture material, 4 labs to complete, and papers to read, with an associated review we needed to write on each paper. The exams were thorough and fair. If you've been watching the lectures, taking notes, doing the weekly quizzes, and review the practice questions, nothing on the exam will be a surprise. Projects were the most interesting part of the course, and where everything came together for me. Qiskit documentation is often sparse or incomplete, so finding help when you get stuck can be difficult. Fortunately the TAs are very knowledgeable and thorough. I took the paper reviews seriously, and got full points on all of them, but I sometimes wonder if they were just looking for you to turn in something and not really reading what you wrote. You have unlimited attempts at weekly quizzes, so no pressure there.

Pros: As I said above, the lectures are good and interesting. Take notes! They're full of details that will come up on exams. I liked the material and am excited about the direction of quantum computing.

Cons: I took this class in the Summer, which is supposedly compressed. They said nothing was dropped for the summer semester, but I felt like the class was too easy. For being a quantum computing class, math wasn't stressed very much. They easily could have added more material on complex variables and focused more on working matrix problems...even if only in python or matlab, but no. They also could have added an extra lab on an implementing a small-scale Shor's or Grover's algorithm. They explained large number factoring fairly well, but there was no work done on an implementation to really drive home how the algorithm works. I got an A, but almost got a B, primarily because the class was so easy, I just let things slide and didn't take it seriously enough. If this class were more difficult and required more consistent attention, I would have gotten more out of it and done better. I almost think the class was a waste of time for these reasons, but when I think back to when I knew nothing at all about QC, I realize I actually got quite a bit out of the class.

If you're looking for an easy, low-stress, interesting class for an elective over a summer or to pair with a harder class, this might be a good one.

The reviews here are spot on in my experience. I'm 7 courses in for OMSCS. I learned the most in this course out of any so far. This is also the most time-consuming and difficult course I've ever taken. It's second only to CSE-6220 HPC for my favorite course overall.

I threw myself into the deep end with this course, having almost no background knowledge on the subject matter, and struggled to get a C. That's on me, but I'm glad I did it. The juice is worth the squeeze. Some topics require a period of intense study to make any meaningful progress on, and I think this is one of them, at least for me. Things began to really click with Lab 5 for me. The course does a great job of using earlier labs as stepping stones to the next topics.

It always bothered me that I didn't have an understanding of how ELF binaries actually worked. Now I have (some) understanding of that. This course really helped me solidify my understanding of some of the higher-level concepts from HPCA and GIOS.

I think if this topic interests you, your life situation is compatible with the workload, you know what you're getting yourself into, and you can live with a C or a W, you should definitely register. This is grad school, it's supposed to be hard, right?

Three tips that would've made things easier for me:

1. use a Docker devcontainer instead of a VirtualBox VM from day 1 for all tasks where GUI tools are not necessary.
2. rack up points early on. the concepts start to make more sense later on, but the challenges don't get any easier.
3. take Malware Analysis first

This is the only course in OMSCS that I didn't learn much, considering that this is one of the core modules you have to take, this is unacceptable. You are basically formatting your work to be as similar as possible to the expected answer, if not you'll be marked down multiple times, especially if you make the mistake at the start, plus a lot of other huge issues with the course itself.

Graders are horribly inconsistent, some will give you full marks, some will give you a rolling deduction of 8/20 for a wording mistake. Office Hours are bad, they don't teach you how to solve the problems (they basically read out solutions) but instead how you should format it so you can have a chance of getting your assignment marked correctly.

This course heavily relies on your study group and student feedback, which is basically just the blind leading the blind. I've had multiple times where some person in takes an entire group down the wrong rabbit hole and then everyone gets marked down for the wrong assumptions after the homeworks are returned. The TAs will encourage you to join a study group, but I joined 4 study groups, 2 of which did not even speak for the entire semester. Graders will also only reinstate some points based on student or TA feedback, if your post doesn't get any comments, tough luck, the grader won't give your points back and will insist they are correct. Good luck asking for a re-regrade, because they only reply you towards the end of the regrade week, which means there isn't even time to ask.

I spent a lot more time arguing why I should get points back than learning algorithms, which is bewildering because this is Introduction to Graduate Algorithms, not Introduction to Gradescope Regrades.

The exams are equally horrible, if you don't get an Eureka moment to solve the problem, you're basically fxcked and you will get 10/20 AT THE MOST even if you have the correct idea of what to do but the wrong implementation. If you can't solve both, then you're getting 20/40 at MOST, which you better pray you get full marks on the multiple-choice questions because 40/60 is only 66.666% and you need to get 70% for a B.

The entire course is designed for you to retake to get an A, which is absurd.

The projects follow what other reviews have said so I won't go over them. This class still feels like a beta test which is kind of frustrating. On the web exploit project the server was down for several days because nobody realized the server that was hosting it got repurposed. On a similar note the final AI project was totally un-usable and the server required frequent reboots so it was difficult for students to make progress since we were essentially working around the times TA's were available to clean things up.

If you've taken IIS or Network Security you should know what to expect with a Wenke Lee class. The instructor is totally absent and all of the readings in the course were published in part by him. All of the lectures are the same micro-lecture format as the aforementioned classes and some of the videos were directly from IIS or Net Sec so don't expect to learn anything new from the lectures.

The final exam is pretty straight forward multiple choice based on quizzes/lectures/projects. I didn't study for it and got ~70% which was fine because of the extra credit could make up the difference.

Considering the issues, the grading was fair. 5% extra credit for leaving reviews for the projects. I don't think this will be the standard but they dropped our lowest project score because of all of the issues we had with the AI project. The TA's have mentioned there will be a curve but the syllabus says grades are a straight A=90, B=80, C=<70. I don't have a ton of programming experience but after everything I ended up with a ~95%.

All in all, its a good alternative to 6265 if you don't have 35 hours a week to put into the course but it won't be as fulfilling.

I took OS in undergrad (albeit during COVID, so I kind of stopped participating in the second half of it), so I have an understanding of the ways an operating systems class could be run. In my undergrad, a majority of our projects were adding features to Xv6. Outside of Xv6, there were a variety of other assignments like making a unix-like shell, reading from FAT32 filesystem, rpc work - which like any good OS course, was a lot of work.

GIOS discusses these topics in lectures very well (honestly better than my in-person undergrad lectures), but had 3 assignments. They focused on multithreading, IPC, and RPC. As such, I think I remember the most about these topics, but feel like I’d be quick to forget things like scheduling, how memory is structured, COW, if not for my undergrad course. If I took this alone, maybe more knowledge would have stuck, but I did well just by watching the lectures, completing the projects, and skimming the readings. The professor is nice and the TAs are good. There is a fairly generous curve (based on fiddling with canvas, ~81.6 for an A).

This class still stands as a really good and interesting one that does a solid job of introducing you to operating systems. I was able to learn about memory/RPC and distributed systems, concepts which I had ignored when COVID hit. For students from a non-CS background will definitely have the additional component of “learn c” that will make the class much harder - but in my opinion, GIOS on the level of a junior/senior level undergrad class; a must take for people with 0 knowledge of operating systems, but probably a skip to AOS for someone who has had marginal exposure to these topics.

The general perception of this class is fairly accurate, but I think what is not mentioned is how much farther you can take the content if you want to. I didn’t do the readings and got an A. Exams are MC, straightforward, and weighted relatively lightly. I rate difficulty as easy when in reality the difficulty could be harder if you set yourself to a higher standard. The first week or two feels like an introduction to python/pandas/numpy, but after that the class is 50/50 between trading and introductory ML. the TAs (who predominantly run the class) are responsive in forums, provide clarity in office hours, and encourage discussion and deeper analysis whenever possible.

As someone who does not want to pursue ML, I took this class because I thought it would be a nice introduction to it (in addition to being interested in investing).

The content was really interesting. My biggest gripes were that I do not like writing reports (which is what I spent the most time on) and (and the reason for the lower overall rating) it took a while to get feedback on assignments (this improved after the middle of the semester, but we still waited on ~50% of our total grade until then). Follow up regrade requests also took a while to address.

I was interested in this subject, and the class did not disappoint. Really interesting content that makes you realize how applicable theory can actually be for something software engineers use on a daily basis. While previous reviews from years ago seem to indicate TAs gave ambiguous answers and the assignments are vague with requirements, that was not the case this semester (and is probably no longer the case); TAs were absolutely fantastic and the grading for the project was very fair - you could have a very good idea of your score with the autograder.

While many may understand the general phases of a compiler, there was a lot more to them than I expected; things like NFA/DFA conversions and minimizations, liveness analysis, (super)local value numbering/other optimizations, and NP-complete graph coloring problem for register allocation are examples of things I had never heard of.

This class does not delve too much into compiler optimizations because there is so much content to cover to just to explain what a compiler does at a high level. In the summer, the content is reduced even further (less requirements for the project). Unfortunately, the continuation of this class that dives into advanced optimizations is only offered in person, but I hope to see it for OMSCS in the future.

General advice:

• Read the textbook if you want to maximize learning (and get the 2nd edition if they're still requesting that, since there is some content that has been removed/rearranged in the 3rd).

• The homework and exam questions were honestly more difficult than the project. Building a compiler is a long process, but after you know what to do and as long as you manage your time it's fairly straightforward (and I think the LOC in other reviews are somewhat of an exaggeration; the amount of code I wrote didn't total to be over 5000 lines, and that includes very inefficient modularity). Free response questions are human error prone and most of the points I lost were from careless mistakes.

Ways this class could be improved:

• I feel like making the final exam 35% of the grade put a lot of stress on me; potentially giving more weight to the homework (which are similar to the exam) could alleviate some of that pressure.

• Perhaps the timing is made a little off in the summer just because of the shortened term, but there were cases where I had to watch/read ahead of schedule to finish homework at a comfortable pace. If the homework is opened earlier (or there was at least corresponding sections explicitly stated that we should read/watch before completing it) I think it would've improved the experience.

Probably the most interesting/fun class I've taken so far, but I think you kind of have to be interested in the topic to begin with. This class made me more interested in this topic.

You can't avoid it, so the main question is how to approach it. Anyone who truly met the prerequisites for the program should be able to ace the course, so it could be taken at any time. The biggest part of the grade - and the largest time-sink - is the project. The grading on it seems fairly lenient, as long as the voluminous and inconsistent instructions are met, The few homework assignments are easy, although each might take a few hours to complete. As far as the lectures go, I watched many of them on 1.25x or 1.5x, which reduced my restlessness due to their rudimentary level. Some of the homework depends on the extra readings or, irritatingly, on the code from the TA sessions, but students could wait until they see the questions before delving into those sources.

It's not a horrible course (although the marketing section and the instructions are), and I especially appreciated the review of regression, which I found to be quite clear. But, if the assignments were harder, I would've studied more and thus retained more in the long term.

I had a decent handle on regression heading into this class. I also worked with regression in R in 6501 and 6203. I was stunned - this class will test your ability to memorize arcane knowledge (how many degrees of freedom for this linear model, what is the underlying distribution for the pooled variance estimator). It will NOT tell you anything about building a model, making decisions/tradeoffs, and communicating those decisions. It will NOT tell you anything about regression except memorizing random facts.

I didn't learn a thing. Just copy the slides and shrink them down to a cheat sheet (you get a cheat sheet for exams) and memorize everything. Read exam questions carefully, they are poorly written.

Overall, be prepared to waste your money, time, and not learn anything.

Since this was the first semester the course was offered, all of this could change! Excellent course design. Very well thought out assignments and exams. The lectures by Prof. Riedl were incredibly clear and well presented.

Prof. Riedl was very deliberate about designing the course to not cause undue stress. The exams were open book, notes, internet and we had a few days to complete them. The questions are carefully written to make the exam another learning opportunity, and succeeded in that goal. Super impressed.

Six assignments that made up most of the grade were fun. The first 5 were relatively easy, but definitely took some work and collaboration with classmates to get past hurdles. The grading was very fair and you should already know your grade when you submit. The last one was significantly harder. Make sure you allocate enough time for it. All assignments were coding except for a written report as part of the last one.

There was quite a bit of complaining about the Meta lectures in the second half of the course, but most of them were pretty good. Just one guest lecturer (2 modules) was pretty hard to follow. The second half of the course seemed more disorganized than the first half, but I suspect that will improve in future semesters.

I took CS7643 and would like to share my thoughts on the class. While the professor was friendly, I must admit that the course did not meet my expectations, and I would consider it the worst courses I've taken in OMSCS, i.e. 1 out of 7. Please not it is not one of the worst.

1. DP is a challenging subject to teach, given the abundance of quality lectures available. After completing the course, I felt that it was only sufficient for earning credits purpose. For those genuinely seeking in-depth learning, I believe resources like Andrew Ng's courses might be a better fit, based on my limited experience.
2. Unfortunately, I found the TAs to be lacking in their support, and many questions remained unresolved. As a result, I eventually gave up on seeking assistance. The responses received often felt inadequate, with explanations like "this is a graduate-level course."
3. I found the lecture setup to be quite unusual and tedious. Unlike other OMSCS courses, the lectures were continuous 20-minute sessions without breaks or quiz questions to facilitate understanding. Additionally, the lecture slides were challenging to comprehend, and much of the content appeared to be copied from other sources, leaving me wishing I could have done the same.
4. Despite taking other OMSCS courses and acquiring knowledge from them, I feel that CS7643 did not contribute significantly to my learning. Some OMSCS central reviews suggest that earning an A might be achievable with just 60% credit from the quiz, which seems to indicate that success in the quiz is just a coin tossing game. This resonates with my own experience.
5. I found the quiz and grade release process to be immediate. I do appreciate the quick release of grade. Though quiz quick release could potentially facilitate cheating. The professor's kind gesture in this regard might have made the quiz less meaningful as a genuine assessment. The setup could potentially allow students to coordinate and secure an 80% credit by pooling their efforts, rendering the quiz less rigorous.

In an attempt to remain positive, I must acknowledge that the professor is a nice person. However, I can't help but express my disappointment with CS7643. Normally, I participate in CIOS surveys only when I find a course to be truly helpful. The absence of my survey submission would typically indicate an average experience. However, with CS7643, my disappointment is significant enough to share my thoughts for the benefit of future students. In conclusion, while the professor's kindness is noteworthy, I believe the course has significant room for improvement. As an OMSCS student, it is essential to consider personal preferences and learning styles when choosing courses, and I hope my feedback can contribute to a more informed decision-making process for others.

Coming from a non-business background, this class was definitely a grind and it required a lot of time going through the lectures, taking notes, and doing the practice assessments. I thought the material was interesting and well laid out in the lectures (for the most part), there's just a lot to memorize in a short period, especially with this being a summer semester. For the accounting and finance modules I was probably averaging 15 hrs./week of course work, then that dropped down to around 10 hrs./week for the supply chain and marketing modules, with the course work mainly being studying notes and practicing self-assessments. All the exam questions are very similar to the practice self-assessments questions, so as long as you're comfortable with all the practice self-assessments questions, you should be OK. It also helped a lot to get through the lectures early so that for exam week I could just study and practice assessments.

I can see why people don't like this class since it's very much a business crash course with not much analytics involved, but I found it useful to have a better understanding of business and could apply what I was learning to stocks, business decisions, what I read in WSJ, etc.

This was my third class in OMSCS and I really didn’t mind it. As mentioned before, since we did summer, we didn’t do the BGP Hijacking lab, so I can't speak to that one.

Lectures Honestly, the only bad thing about this class was the amount of reading. There are very few lecture videos, and the reading can get quite lengthy, especially with the optional readings and all the recommended articles and papers that they want you to read. I read a couple that interested me, but skipped them for the most part. In general, I spent about 1-3 hours a week just reading and doing the weekly quizzes.

Projects Python is very helpful to know in advance to do the projects. I have a decent amount of experience using Python, and so that saved a lot of time. In general, you should be able to get 100% on all the projects. The first 2 projects are very basic (Spanning Tree Protocol and Distance Vector Routing). I think I spent 2-4 hours on each of them. SDN Firewall (4-6 hours total)- most of this was reading and understanding what they want you to do. The actual implementation wasn’t very difficult. The student test cases were awesome, and definitely saved a bunch of time with manual testing. BGP Measurements (6-7 hours)- Again, mostly spend time reading and understanding the project requirements and API documentation. The implementation was slightly more difficult, but not unreasonable or hard. I ran into a couple of roadblocks when trying to follow the documentation, but the Ed Discussion helped a ton for those, so I quickly found the answers I needed and moved on.

Exams Exam 1- I spent 2-3 hours studying for this one, mainly using the course and weekly quizzes. I ended up getting an 88%. Exam 2- I spent 1 hour studying for this one, just basically skimming the quizzes (I only needed a 50% for an A). I ended up getting a 76%. Overall, the exams were challenging, with the hardest thing being the pages and pages of notes that you need to comb over to study. However, they weren’t unfair or anything like that. And, if you do well on the projects then you can skip a lot of that study time and just do a quick refresh to get an easy 70% or so on them.

Conclusion Overall, I thought that the class was good but not great. I didn’t know a ton about computer networking coming into the class, and so it was a really good class that went over the basics and I learned a lot.

Introduction

Background

As of course start, I had around 2.5 years of experience working as a professional software engineer, specifically doing web applications (full-stack .NET + JavaScript). My previous degree was in Engineering (non-CE/non-EE) from early 2010s.

This was my third course in OMSCS, within the computing systems specialization. I previously completed GIOS (CS 6200, Fall 2021) and IIS (CS 6035, Fall 2022), and also attempted HPCA (CS 6290, Spring 2023) in the semester immediately preceding taking this course (CN), but had to drop HPCA due to an unexpected/abrupt layoff and consequent get-a-new-job-ASAP scramble (which fortunately I did manage to do, around 2 months prior to starting CN).

Caveats

For full transparency's sake, a couple of caveats/disclosures:

• I begrudgingly took this course over the summer to make up for dropping HPCA (CS 6290) in preceding Spring (2023), and do not plan to do any more summer semesters during my remaining residence in OMSCS after this one; despite the course being on the lighter side, it reinforced my disdain for summer school nevertheless
  • I prefer having a longer break in between Spring and Fall to recoup and recharge, rather than just being "free" for only 3-4 weeks at a time, and this was especially true here with summer-semester CN coinciding with starting a new job that required a lot of ramp-up due to the job being in a new industry from previously, which also compounded my stress/aggravation from the course, as well as derailing other previously anticipated summer plans prior to the layoff and at that point anticipating a "fully clear" summer.
• I did not have much formal networking experience going into the course
  • Conversely, among those who did, they seemed to demonstrate more overall engagement with the material, as evidenced by their Ed posts/comments, prompt/in-one-sitting completion of projects, etc.

As a big pet peeve (for me personally, but presumably others as well), in the summer semester, three of the four projects were due over U.S. holiday weekends (Memorial Day, Juneteenth, and July 4th, with the projects themselves all due on the respective US-based time zones Monday mornings of these holiday weekends), which was an additionally contributing factor to my aforementioned disdain for the course (and summer school more generally). While not strictly the course's fault per se (i.e., based on how a compressed summer schedule aligned with these holidays), it was nevertheless still very much so "not a plus," to put it mildly (i.e., all three of those projects/deadlines ended up being rather stressful in terms of managing against other family obligations, etc.).

With those caveats out of the way, I attempted to stay reasonably objective with this review (and correspondingly attempting to stick more to "facts" than "opinions"), but it still seemed appropriate to disclose being somewhat "negatively biased" going into the course/review nevertheless, in order for readers (i.e., future CN prospects) to exercise appropriate discretion/discernment while reading this review.

High-Level Review

Overall, I did not find this course to be that remarkable, and probably the relatively worst one I have taken to date (certainly within the scope of the aforementioned fully- and partially-completed-to-date OMSCS coursework). The lecture content feels mostly like a patchwork of Wikipedia articles on scatterbrained topics, with only a few emergent high-level themes/takeaways at best (and otherwise forgettable post-review/post-cram). Content-wise/topics-wise, I do think the course would have been much better-served by simply following along more directly with Kurose & Ross or an equivalent textbook on networking, in order to facilitate a more coherent topical structure/organization.

Course Logistics and Time Expenditures

The course is not curved, and follows a strict 10-point scale (i.e., 90.000-100.000% overall for an A, 80-89.999% overall for a B, etc.). The relative weighting of the deliverables is as follows:

• 60% projects (10% + 15% + 15% + 20% across the 4 projects, further discussed below in the next section)
• 15% midterm exam
• 15% final exam (non-cumulative, covering only post-midterm lessons)
• 10% open-notes/open-resources lesson quizzes (12 total)
• (optional) 3% extra credit project

N.B. In the summer, one of the projects is dropped due to time constraints (BGP Hijacking), so I cannot comment authoritatively on it in this review. Furthermore, there is an optional (ungraded) introduction/orientation to mininet (Simulating Networks), as well as an optional extra credit project (Internet-Wide Events) worth up to an additional 3% overall (which is relatively generous, enough to cover a borderline grade on a partially flubbed project or exam, or otherwise equivalent to roughly 2.5 lesson quizzes).

• I did not attempt the extra credit project, as I was sitting pretty solidly at an A (~95% overall) in the course going into the final exam (by that point, I had achieved 100% on all projects, mid 80s% on the midterm, and around 90% overall on quizzes going into the final exam), and basically it was "my A to lose" (my critical score to keep an A overall in the course [i.e., >= 90.000%] was around low 50s% on the final exam, which I subsequently exceeded with low 80% upon completing the final exam, thereby securing the A in the course).

I did not keep strict tabs on time expenditures across deliverables, but my best in-hindsight back-estimates are as follows:

• 1.5 hours per lesson (reading the text followed by completing the 30-min-limit quiz) * 12 lessons total = 18 hours
• 18 hours per project (mid-range average across the four projects) * 4 projects = 72 hours
• 15 hours of prep per exam (lessons review and study guides completion) * 2 exams = 30 hours

Given an 11-week summer semester, this averages out to 10.9 hours/week [= (18 + 72 + 30) / 11]. The cadence was typically 1-2 lessons/quizzes per week, aside from the midterm & final exam weeks (during which neither lessons/quizzes nor projects were assigned/due).

• The busiest points in the course were around the projects' due dates, along with the exam weeks (i.e., cramming a ton of very oddly-specific information from the preceding 5-6 weeks' worth of lessons).
• Otherwise, the "in-between" weeks (i.e., during which only a lesson quiz was due, and a released project was in-progress but not-yet-due) by comparison were not as intense, possibly with little-to-no required time allocation for that particular week (i.e., if completed project and quiz ahead of schedule by that point).

Course Deliverables

Quizzes

In general, quizzes were released weekly, so it was not possible to work ahead on those (i.e., as one quiz was due, the next week's lesson quiz would be released and was subsequently due by the following week deadline, etc.), though the all of the lessons' text/content themselves were generally open for all lessons as soon as the syllabus quiz was completed at the start of the course and henceforth from that point.

There are 12 total text-based lessons (with corresponding videos for some of the slides/pages, with the videos mostly just rehashing the text information, and consequently I largely ignored the videos in favor of simply reading the text), with each lesson having a corresponding open-notes quiz in Canvas. The quizzes can mostly be completed by referencing the lessons' text, though sometimes the quizzes questions' wording was a bit ambiguous/tricky. The quizzes are also time-limited to 30 minutes.

Projects

Similarly to the quizzes, the projects were not released in advance, but rather on a fixed-interval basis (i.e., as on project was due/submitted, the next project was then released).

Regarding the projects work, while this course is generally regarded as being on the "easier" side (which, compared to the likes of GIOS and HPCA, I did personally find this to be true, too), an advanced-beginner/early-intermediate level of proficiency in Python will be useful (if not outright necessary) to get through the projects, which difficulty-wise are on par with LeetCode harder-easy to easier-medium tier. The "happy path" is generally straightforward, but there are edge cases which require more refined techniques (e.g., using the debugger and/or print statements) to pin down and solve.

I did not keep tabs on total time expenditures on a per-project basis, but across the board, I can back-estimate an average of around 15-20 hours per project spread over the correspondingly allotted 2-3 week completion periods, which typically translated to a few evening sessions (including the occasional weekend in the mix, as necessary), working through a given project part/task at a time (i.e., per attempted-project-work session).

The four projects in the summer were as follows (in order of appearance):

• Spanning Tree Protocol
• Distance Vector Routing
• SDN Firewall
• BGP Measurements

A VM was provided for the course, though only strictly required for SDN Firewall. Otherwise, the first two projects could be done on your local machine (the staff provided a conda environment to configure the Python version, but otherwise used standard library features exclusively), and the fourth (in principle) could also be done locally, but that required unsupported setup of third-party dependencies to do this (I did not bother with this, and in all cases where VM was required, I simply set that up and sshd into it from my host machine and used remoted-in VS Code on the host to do the projects work).

The projects were mostly a slog/uninspiring overall (i.e., if stripping away the ostensibly relevant "networking" subject matter, it was otherwise effectively just implementing algorithms in Python), but generally "doable" once you figured out the intended instructions (the first two projects included video tutorials which were helpful for determining the general "gist" of the respective projects and how to formulate the "happy-path" solutions), at which point it was just a matter of covering edge cases beyond that.

I thought the SDN Firewall project in particular was incredibly tedious (no offense intended here towards the head TA for that project), as the project description had a lot of extra/superfluous information that felt like a distraction overall, making it feel like more of an exercise in interpretation of instructions rather than actually getting the project work itself done.

• The Wireshark content seemed like it was shoehorned into the project for its own sake, but in reality, I think a lot of that could have been leaned out by simply doubling-down on the more recent test-harness-based setup at this point, in my opinion. If they want to keep the Wireshark exposure in the course for "general relevance" to networking, I think they should just move it into (yet another) appendix for the project, or just move it over to the Simulating Networks intro/tutorial (optional) project altogether instead.

All projects generally provided local testing suites, which were particularly useful for SDN Firewall, since that one was not graded via Gradescope, but rather only submitted as a .zip directly to Canvas for subsequent manual grading. Otherwise, for the remaining projects (for which Gradescope was available), Gradescope submissions were generally unlimited up to the deadline (i.e., generally, WYSIWYG with respect to the resulting graded project score in Canvas post-final-GS submission).

Course Exams

The most challenging part of the course is the exams, mostly by virtue of having to rely on rote memorization and "luck of the draw" (i.e., not blanking on the particular question(s) that appear). The exams are essentially a longer quiz (2 hours total test window), but without open notes/resources available. The exams also required browser-based proctoring via Honorlock to enforce during the test-taking session.

The staff provided study guide questions for the exams, and I strongly encourage going through those in tandem with exam prep (along with reviewing the lessons quizzes); that was the key to doing reasonably well on the exams for me personally (particularly with myself not being a "good memorizer," by any stretch of the imagination). The exams made me feel somewhat like I was back in biology courses from undergrad all over again (i.e., cramming slides and hoping for the best).

With all that said, from a points-maximization standpoint in the course overall, it is definitely advisable to max out points as much as possible on all of the other deliverables outside of the exams (i.e., lesson quizzes and projects), in order to cover potential shortfalls on the exams. I scored around the median on both exams, well enough to secure the A overall in the course, by virtue of getting 100/100 on all projects and near 90% across the lesson quizzes.

Closing Thoughts

CN is probably not the worst course you could take in OMS, but it is still otherwise unremarkable on the whole (for me, it fell flat / missed the mark overall). In fairness, I cannot say in good faith that I gained nothing useful out of the course, and it did help with elucidating high-level themes around the OSI model and a few specific protocols therein. But given that I took this course specifically in order to better-inform my day job (software engineering involving REST APIs & web apps), it was still pretty disappointing to come out of the course with not-an-appreciably-better understanding of the subject matter relative to going into the course. I probably would have been better off self-studying Kurose & Ross or equivalent (and/or going through equivalent CCNA certification prep materials), and consequently I will still have to do something along those lines in the near future in order to gain a better understanding of the underlying computer networking concepts.

Overall difficulty-wise, I would put CN at easy-leaning-medium. I decided to go with "easy" over "medium" in the difficulty rating for this review (relative to GIOS being an unambiguously "hard" but not "very hard" for me), with the caveat that CN does require some reasonable proficiency in Python, and that the cramming for the exams is pretty tedious and time-consuming (at least if you're looking to do reasonably well, i.e., near or above class median, or roughly low-to-mid 80%).

If you are diligent, CN should be reasonably amenable to pairing with another easy-to-medium difficulty course (provided you have the necessary Python skills for the CN projects), though that will probably make for a fairly busy semester, particularly around exams and projects deadlines (and also depending on how these deliverables' deadlines align with the other course's deliverables' deadlines). On a relative-to-other-courses basis (per my own personal/subjective experience with them), I would assess CN's pairability as:

• "pairable" similarly to IIS
  • i.e., relatively similar difficulty and time-intensity, perhaps with a slightly larger overall time commitment in CN due to quizzes and exams in addition to projects
• "not pairable" dissimilarly from GIOS
  • i.e., if you feel you could not pair GIOS with something else due to GIOS's high difficulty & time-intensity, CN is still otherwise comparably less difficult and less time-consuming than GIOS, and thus possibly pairable with another lighter-than-GIOS course

Simple course with low quality, but it is easy to get A.

This was the hardest thing I've ever done, and in the end I did not do well (I earned a D). I was struggling through assignments when I probably should have been working on the project. My programming skills were not up to par to get full scores on the project (I opted to do the project without a partner, huge mistake). And the exam was a beast. If I had studied just a little better, I could have gotten a C in the class with just a couple more points. That hurts. I usually do poorly on exams and therefore, try to keep my project scores high when possible.

I loved the material though, which is good because I'll probably have to retake it to replace the score (luckily we get once chance at that). However, it was so much work that I might just keep the D and hope I get a high enough GPA to graduate.

I used all my vacation time from work to attempt to complete this course, which was probably 3 or 4 weeks worth of time off of work to spend 16 hours a day on the project. In fact, I didn't sleep on a couple of weekends, just did homework/project for the entire weekend - Friday through Sunday with no sleep (It did make Monday very tough at work).

Another mistake I made was using C++. I don't know Java so I thought I would be better off, but the documentation for C++ is lacking. I might have had a harder time with Java since I haven't used it for years.

Pros

Excellent material, and lots of practice using it.

Cons

More work than any single class should be. I was stressed the entire semester, struggled to understand the material (though the assignments helped) and was devastated to earn a D. There should be some prerequisites or a programming test to make sure that you have enough experience.

However, if I earned two or three more points on the test and landed with a C, I would say it was a great, tough, but great experience. I loved the material.

The full review can be found on this link.

This is my favorite class I've taken so far. The subject was very interesting, the lectures were good, the readings illustrative, the homeworks really have you applying what you've learned, the TA's are helpful, grading is from the TA's and they give good feedback, etc. The only two negatives I encountered were:

1. The homework questions can be weird sometimes. I remember there was one question that was like, "Plot this graph. What is the p-value of the pearson coefficient?" and like, what pearson coefficient? In relation to what?? The TA's are quick to clear up any confusion in Ed though, so it's not really a solid negative.

2. Grades can be pretty late. Understandable since the TA's grade it themselves, and I'd rather late grades than peer grades, but it does make it harder to apply what you learned in hw2 to hw3, because you don't know how you did in hw2 by the time hw3 is due.

Besides those 2 (honestly minor compared to the high quality of everything else) points, overall I loved this class and I highly recommend it if you're interested in networks.

This was my 2nd course overall. I found that this one wasn't that great. It seemed mostly a waste of time.

The lectures weren't interesting. I found that after the first couple of weeks, I just stopped watching them. They don't relate to the homework or projects at all. It seems to be mostly examples of cyber-physical systems and designs. I would have preferred lectures that talked about the topics in depth, instead of just talking about examples.

The homework assignments were pretty basic. For someone coming from a mechanical engineering background, I am already familiar with matlab, and so the homework assignments at the beginning were pretty easy. They became more difficult at the end, but most of the time is just spent learning about the environment and background, not actually doing much work.

The projects were somewhat interesting. The first one was a bit of a learning curve to learn about the robotarium system, which is pretty cool. And then the second one was a more advanced version of project 1. I thought it was actually a lot of fun.

Project 3 is a different beast. It wasn't that challenging once you learn a little bit of AADL, but learning it was just annoying, because you know that most likely you won't have to use it ever again. I thought you could have learned the material without learning AADL. Overall, it just felt out of place.

Overall, I thought that the course was pretty easy. The projects take some time, but otherwise you don't really have to worry too much about spending time on the homework or course lectures. I would say that this is an easier class that you could pair with something more difficult. To me, this class just wasn't interesting enough to recommend. I don't really feel like I got anything out of it, but maybe your experience will be different.

Course isn't difficult by any means, most of the homework is in R and doesn't require anything too complex. The self-assessments all come directly from the lectures, with the exam questions coming directly from lectures and homework. For the group project, it's important to find people you feel like you can work with and who will share the load, but the grading on it is pretty lenient so as long as a decent effort is made, should get a decent grade on it. Some of the lecture sections were interesting (stocks, inventory management, advertisement ratings) others were very dull and just read off the slides. My biggest complaint was just the course didn't feel as tight and composed as other introductory courses such as ISYE 6501, quite a few errors on the homework solutions, informational exam posts not posted till day of exam, etc.

Overall I really enjoyed this class and thought it did a good job getting me more comfortable with python, and the different python packages associated with analytics as well as how to implement them. The difficulty of this class will depend a lot on prior experience with python and coding in general, if you have no prior coding experience and didn't take CS1301 or another python introduction class, you'll most likely struggle heavily. Otherwise, even though I didn't have much python experience besides CS1301, I was able to understand how to approach problems and just used google search to determine the best python syntax. For the homework, office hours, slack, and piazza are very helpful if you get stuck, and for the exams, studying prior exams is the best way to prepare.

Poorly designed class. TAs and Professor are there for most of it but one major flaw with the class is that the lectures do NOT line up with the assignments. The general ideas of the lectures are apparent in the assignments but the detailed minutiae that the assignments expect is not covered. There is a course textbook but even in there, some of the material is not readily available and you are at the mercy of TA’s releasing information on Ed Discussions. The lectures are connected to the quizzes and cover so much unnecessary information. Quizzes are primarily T/F and have two tries which, if left this way, quizzes will be an easy grade. The last two projects are team based. The requirements are vague and in our case, the assigned TA to help us define our group specific requirements was often not there. The final group project is coding based on a previous solo assignment in Java. It is reasonable but tedious.

Overall, I did not enjoy this course very much. The lectures are irrelevant and the projects are tedious. As for content that is actually learned, UML diagramming is really the only concept that is pushed. Other than that, if you have not used Java before, this course may be helpful if you wanted to learn. 

I do not recommend this course. The course has lectures, quizzes, small coding assignments that require handful of line changes at most, and two large essays. The lectures are fine and informative. The quizzes are directly from the lectures and do not require honor lock so you can follow along while completing it. The coding assignments generally take less than 15 minutes for each one as most of them are “make one unique change to the code adding some new functionality”. You are allowed to make any change to it essentially.

There are two essays, one being a solo assignment and the other being a team project. As many of the other reviews state, your grade on any give assignment is completely dependent on the TA that grades you. Some hand out 100s without verifying the quality while some mark off points without specifying where. After the first essay grades were released, the TAs declared no form of regrade request but provided them on an individual basis for students that complained. Both essays are purely tedious the first having a 5-10 page requirement and the team essay have a requirement of 10-30 pages. The assignment requirements are succinct and vague, leading me to believe this is the equivalent of a creative writing course. I spoke with multiple other students who voiced similar concerns that there was not enough to write about since the requirements were so short so they were forced to include unnecessary details to hit the page requirement.

At the end of the course, they give a pretty significant curve to the extent that I believe very few students received a ‘C’ if any at all. I was given an arbitrarily lower grade on my first essay and with no regrade requests, I thought my chance at an ‘A’ was over but the curve pushed me up to one. Perhaps this is the experience that the teaching staff are trying to give to make it seem like a legitimate course - vague requirements, arbitrarily lowered grades, then a curve at the end to reassure students. Absolutely silly course that is simply busywork. Do not take it if you don’t have to. 

https://www.reddit.com/r/OMSCS/comments/11frnuo/cs_6603_ai_ethics_society_the_worst_course_ever/ Please read the above reddit post. Loosely, it summarizes my thoughts. The grading is the MOST lenient of any course I have taken in this program and I am 8 courses in. Sometimes I will leave portions of assignments half-finished on purpose if I do not believe I need that portion for my grade. I would often still get marks for it.

The lectures are fine and I enjoyed them quite a bit. The assignments on the other hand are pure tedium - I’ve had less than 200 lines of code be used for a 15+ page reports due to the copy and pasting of the code or plugging in of different values. The assignment instructions are vague, have grammatical errors, and required constant TA adjustment during the semester. The Taste try to be as helpful as possible and are great otherwise but I believe the amount of busywork could be cut down in this course with a higher emphasis on quality, not quantity.

I believe the professor for this course has changed since I took it so take this with a grain of salt. This course was exam heavy with weekly homework assignments.

The type of questions were quite different with the exam testing concepts and math skills whereas the homework had more practical questions along with programming applications. Overall it is a very useful course that helps introduce concepts that are used in later classes. I certainly think it is more useful than the Simulation class which has limited applicability to discrete event systems

My background: Chemical engineering undergrad, self-taught/bootcamp, working as a software developer ~3 years experience.

Bluntly: This course was useless and pedantic. The lectures are a waste of time and the head TA is unhelpful. The quizzes are a joke and are free points; high scores can be achieved by not doing the reading or watching the lectures. The majority of the points are in the projects, which have long and hard to read descriptions (poorly written requirements, unclear expectations). The grading is spotty, and group members reported points docked in different areas in their personal assignments where others had not had points docked for similar design decisions. The projects do take a fair amount of work, especially the final project which had me up till 230AM on two occasions as its deadline neared. You learn in the projects in the same way you would learn in making a personal project (as you are writing and designing software), but in my opinion for a course to be considered worthwhile, it needs to go beyond the very baseline of learning. SAD was sad, the only reason the difficulty is not listed as the easiest is because of how cramped the project timelines are.

Expected grade: A (~94% going into final project, grades are not posted)

Would not recommend.

About me: professional full stack developer with 7 YOE., married with a young child. Bachelor's was not in CS. Took DC as my 8th course. Prior relevant courses included GIOS, AOS, and SDCC.

Time Commitment: The course starts off fairly light. The first 2 projects can be knocked out in a weekend. You can easily get by with <10 hours per week until you get to project 3. Around project 4, I was averaging 20-25 hours a week and for project 5 it was closer to 30-35. This was to get all tests to pass for every project. Each project has a few tests that are very difficult to pass. This doesn't mean the tests are unfair. Distributed systems are hard.

Spring 2021 is an outlier The class was radically changed based on the feedback from this first class. The professor and teaching staff are fairly open about how brutal that semester was. There is now more time to work on projects 4 & 5.

Search Tests are your friend This was one the best features of DSLabs. Search tests provide valuable information about what's incorrect about your implementation.

Start projects early Despite the reputation, many students wait too long to start the projects. Those that started late almost always ended up with the low scores.

Don't take this as your first class An alarming number of students were taking this or their first class or had no prior "hard" classes. I recommend taking at least GIOS or AOS prior to taking this class. It doesn't hurt to be over prepared like I was.

TA's were helpful, but don't expect hand holding I found the TAs to be responsive. Slack was fairly active with great discussion, but most students didn't really take advantage of this. There is light "hand holding" in this class. The TA's may suggest a high level strategy, but won't go beyond that.

Overall, this is a good class, but there are some bumps I do hope will be ironed out after it gets another semester or two. In terms of content, this class is a wonderful introduction to Quantum Computing. You learn the background of what exactly a qubit is and why it offers advantages in computing, work on assignments using a popular quantum computing simulation library, build out algorithms which take advantage of the qubit, study ways that errors are mitigated in quantum computing, and read up on important papers in the field. You should end this course with a great breadth of knowledge. Some of the assignments had weird wording or outright mistakes in them, but everything important was quickly corrected.

The difficulty will vary depending on your mathematical background. None of the math is too complicated, but the course's attempt at shoving an entire semester of linear algebra into one week is certainly one of its weaker aspects. For me, as somebody who has not taken a number of the college-level mathematics courses that many CompSci students have, this was a struggle. I was always able to get it in the programming assignments where I had infinite time, but some of the problems on the exams got me a bit thanks to the time limit. Overall, I would definitely say that the overall difficulty is on the harder side of OMSCS classes I have taken, but never unfairly so.

That does bring me to my biggest gripe, though. Ahead of the midterm, there was essentially no information released regarding what it would look like. This was especially unfortunate considering the natural substitute was questions from the textbook (which one TA even said could be a good idea), which ended up not really resembling the format of the exam at all. Not that doing them hurt you or anything, but it would have been helpful to know whether the exam was more math-y, required more recall from the lectures, required us to do the same computations as the programming assignments or different ones, required us to memorize each algorithm's steps or just know how to carry them out when spelled out for you, etc. In my opinion, as the second semester this course was being offered, releasing just a handful of sample questions from last semester would have gone a long way. With that said, I do stress that the midterm itself was ultimately a fair exam.

The TA's in this class were pretty good. They were very responsive on both Ed and Slack, and generally helpful when they could be. It was a bit of an interesting experience being able to scroll up and see what pretty much all of these TA's were saying last semester when they were students versus what they were saying now that they were in charge; definitely some whiplash seeing a TA make a sarcastic remark about students speculating about how a dropout rate could affect a curve, and then seeing that same TA as a student speculating about how the dropout rate affects the CIOS completion rate for extra credit.

I'd recommend the course overall; there are some key points that could be improved, but everything was ultimately fair and I learned a lot, in addition to simply being an interesting topic.

My review doesn't have much to add - I'll double down on the person in Fall 2022 who reviewed each project. My experience was very similar. The C project took a lot of time but I enjoyed it a lot, I can see how folks get into CTF contests. It was interesting to learn about some of these topics, I don't plan to become a cybersecurity professional but I do feel it's good to have a decent understanding of each of the items covered. Agree my least favorite was the ML on CLaMP and that was the only one I didn't get an A, but I didn't try that hard for it.

I got an A in the course and didn't spend much time. If you want a low effort class and want to get familiar with various cybersecurity topics I enjoyed the course.

This was my second course after IIS and I enjoyed this course. As someone with no ML background entering the program with the hope of getting a solid ML foundation it was a nice introduction to ML concepts. I have not yet taken the ML courses with tougher reviews (ML / DL / AI etc), but I suspect this was a nice introduction to those concepts. I feel I have a pretty good understanding of decision trees and linear regression, and surface level understanding of supervised learning in general. It was also cool to learn about RL and Q learning.

I will be getting an A and while I was never stressed about my grade, the course was far more time consuming than I anticipated based on the reviews. Coming out of this course I feel I:

1. Gained a solid foundational understanding of some key ML concepts. I suspect it is not tremendously deep knowledge but I could sound intelligent in a conversation.
2. Learned about stock indicators which was interesting but I don't feel will ever give me much value. I definitely plan to keep investing in index funds after this course.
3. Went from medium to expert python ability.

I thought the course was interesting overall, the con I would say is I feel like the ratio of time I put in to the amount I learned is a bit off kilter. I suppose maybe an additional benefit was getting back into the groove of writing reports, it's not my favorite but I feel probably mentally ready to take ML which I know is very report based.

I would recommend this course to anyone who is in another specialization but wants to dabble in some ML knowledge without going for the more difficult ML courses, or anyone pursuing the ML specialty with no ML background. I also thought it was easy to get an A if you put the time in, but I would not recommend it as a "light load" course.

As an aside I thought the teaching staff was exceptional and clearly passionate on the topics and course delivery.

I liked this class a lot. There was a lot of research and a lot of freedom. It was interesting to see everyone's projects and how everything came together. The research component was something I loved. I'd recommend the class. The hardness of the class really depends on how complicated of a project you take on. There *is* a lot of initial writing up front.

The TA you get will make or break your experience.

Bullshit class with subjectivity up the wazoo. TA's on a power trip. The assignments weren't terrible, but the grading rubric for the RPM reports was atrocious and the TA's were out for blood. Too much writing in this damn class. If it were less about the writing and more time coding that'd make for a better course. Why is it useful to sit and restate the shit I did for everyone else to see? What is this, grade school? I do that at work as do most of us working professionals taking the degree.

If you enjoy in knowing the theory behind it with absolutely zero coding, this would be the course. Its a lot of writing. You need to write a 8 pager about a topic literally every alternate week. And the week in between, there's a smaller writeup - check other reviews for the formats.

This is my first course in OMSCS, a perfect intro to the course. Me being from a non-CS background, I enjoyed the course very much. Many topics are new to me and I learned a lot. I'm 15 years in my career, and coding is not my day job, so I'm not particular about a coding class. It gives opportunity to learn the topic, and since you are to write a 8 pager, you are bound to read a lot of articles and in the process learn the topic really well. Actual workload just to know the stuff to finish off the paper would take around 10-15 hrs, but I took the opportunity to go through a lot of material, youtube videos (from other universities like stanford, harward, IIT) and it was very interesting to me.

Again, a lot of writing that you'll be tired if you're not interesting in reading/writing. If you're looking to implement somehting via this course, this is not for you. If you're thinking of gaining knowledge on systems design (for a typical interview), this is not the course for you. This is more like an intro to various diff technologies, so if you are curious to know the underlying working of the tech, then this is for you.

I do not like this course, Assignment 6 was the absolute worst with, most weightage, lack of material being given to understand and complete the assignment. Saying office hours are there to ask questions is not an acceptable excuse for not giving proper material to understand new concepts. I also have the problem with the grading and the TA especially, this Sinh person.

The course is easy if you know JAVA but it is made intentionally difficult and convoluted to reduce grades, etc.

I just finished the final exam. It is open book/note/lecture/everything, but I realized how little I learned in this class.

Pros:

Everything is released right away. All assignments are online, so you can get started whenever you want (barring those assignments change for the next semester).

Professor is active in the forums but that should be the norm, not a pro.

Lots of graded assignments to cushion the blow if you do poorly on something.

Cons:

Lectures are just high level and hand wavy. Examples that are abstract to the point of being absurd. "Suppose a robot wants to buy a cup of coffee". This content has nothing to do with the mini-projects or RPM. MPs can almost be solved with a search algorithm (BFS), other MPs you can just hack something together.

You can get 70% performance on RPM with affine model, DPR/IPR hacks and a look up table. No reason to go beyond that since you'll lose only a couple points on your final grade.

80% is the average success rate for students on RPM performance, rarely anyone gets 100%. So your grade is penalized by virtue of tackling the problem. 80% performance should be 100% of that part of the grade.

Some of the homework questions were tangential and not with-in the scope of the class. But it is easy busy work to pad your grade, so maybe a pro.

Cognitive Science is just pseudo-philosophy. Unfortunately, this class is just that with a sprinkling of AI and not the other way around. KBAI feels like the underwater basket weaving of AI. Maybe interesting to think about (if that is your thing) but completely useless in the real world.

My $0.02:

This class failed since it didn't teach me anything. That is what I learned on the final exam. Just topics that you watch a video for, take some notes and you'll probably forget a week or two after the semester is done. I wish this class showed some actual application to the real world. How does KBAI tie into Chat GPT? Does Boston Dynamics implement KBAI into their robots? Those kinds of things.

I recommend checking out the course page and see if this is something of interest before you register. It is an easy class to get a B and fulfill the Interactive Intelligence specialization requirement, but kind of a waste of time when you could be learning something useful or that would apply to your future career.

I finished AI feeling like I had gained a bunch of new skills. KBAI has left me feeling like I should have taken ML instead.

Wow. What a class. Took this alongside GIOS for my first semester in OMSCS and the quality of the courses couldn't be more different. This class has been a massive source of frustration and a waste of time, and I have not gained any meaningful knowledge out of it.

My main griefs with the courses:

1. Two weeks per project, no information released beforehand.

• For some reason the TAs don't want to release information about projects ahead of time, even if students want to prepare (rightfully so) and gain background knowledge on the subject matter if they're missing it. This leads to possibly learning entire new skills and technologies all while trying to solve the projects. We all know cramming does not lead to any meaningful knowledge retention, and by the time the next project has released I've already forgetting everything I did. (TAs even threw out quotes like "this is basic ML this should be easy" when students were asked to fit and score models despite this being a cybersecurity course)

2. Extremely questionable quality of most of the projects.

• This has been the most disappointing for me. This is a top institution that is supposed to have rigorous courses, yet I have been served content of similar quality at online community colleges such as Oakton. This is not a compliment.
• Many projects had "resources" that consisted of a schizophrenic list of web page links (think medium blog posts) that were vaguely related to the subject but very rarely of any direct help. It truly feels like the TAs who make these projects rely on what they already know (usually being subject matter experts or people passionate about the subject), and then as an afterthought look for "acceptable" resources.

3. Threats of plagiarism and difficulty by obscurity

• TAs throughout the course loved reminding students that all code should be their own, one project even going so far as to forcing you to write your own code and only reference pseudo-code (even for basic algorithms like square-root or next prime number). It's obvious why this is the case, when most of the projects were solved by using boilerplate code with very little room for personal code style.
• While most of the TAs were very active, they were NOT very helpful. Since the projects are so surface level, the slightest bit of help could lead a student to an answer and this is apparently not wanted so all answers were given in the form of obscure riddles. A frequent occurrence in these projects was being mislead by vague instructions and being sent down a rabbit hole.

I have to rant about KBAI to someone or I will lose my mind

I had to write a paper about what a sandwich is. How to play UNO using if-then statements. What free will is. What a joke is.

This class is a joke. Every homework is just busy work. Here's a great line from the prompt for home work 3:

As we all know, our appreciation for literature is only increased when we painstakingly tear it apart and analyze it like a chemical compound, so let’s do that here—and save pondering how to design an AI agent that can understand the sarcasm of that sentence for another day.

No! Professor, are you serious? No! I am in a Comp Sci program. I am a professional with a life. This isn't funny. This is you looking your student in the face and saying "im making you do unrelated busy work instead of what you came here for, and I'm going to laugh at you about it." This is every homework.

I hate this class. It makes the whole OMSCS program feel like a bad joke of an online school. I literally lost points today because a TA didn't like how I defined what a hotdog is. Are you kidding me? In a masters level grad program about computer science?

The first thing I ever programmed on my own was an if-then stupid little program to play blackjack. Turns out that was actually masters level work because Joyner was happy to assign an UNO if-then stupid little program as homework (and then call it an "AI agent" lol). This class is a literal insult to the intelligence of its students.

But at least we get cool AI based homeworks right?

NO. NO, YOU REALLY DONT.

For every assignment, you can just brute force your way to a perfect score, and what's more, that's usually the best way to do it. The lectures are full of stuff about AI that only gets applied when students drop buzzwords from lectures to try to satisfy TAs who want to see us "apply what we learned". In other words, replacing the word "class" with "frame" and "variable" with "slot". Boom, you can do AI now.

The TAs for this class have no business deciding if I defined free will sufficiently at a masters level. I have no business trying to do so at a masters level. I'm not here for philosophy, I super don't care what Joyner or his TAs feel about free will. Like, at all. And if they care what I think then they're even more bonkers than I thought. What even is this class?

I don't know. I'm never taking another Joyner class again.

Background I am a fresh graduate coming into GIOS with little to no C or C++ experience. It was my first semester and I paired it up with IIS.

Review GIOS consist of 3 projects (named Projects 1, 3 and 4 for some reason). Project 1 was on client/server interaction with multithreading support, Project 3 built upon the content of project 1 with IPC mechanisms (shared memory, message queues). Project 4 was on gRPC.

In order of difficulty, I felt that project 4 was the easiest, followed by project 3, and the hardest is project 2. My advice is to read up and discuss on Slack and Piazza and to start the projects early. Working on the README alongside implementing the code helped to be clear.

The remainder of the module consists of a midterm and a final for the first half and the second half of the content. The final was non-cumulative. I found the tests to be fair although I was quite confused and tricked by the "select the wrong line of code" type of questions.

GIOS is a great module to start of OMSCS with, and I learnt a lot. It gave me a taste of how rigorous a module can be despite it being taught asynchronously.

Grade I ended the semester with a ~85% and got an A. I did not do as well for my midterms and finals (quite below average for my midterms and slightly above average for my finals). Being consistent with the projects helped to secure the A.

Background I am a fresh graduate coming into IIS with no C experience (some Python, Java, JS which was helpful for some projects). It was my first semester and I paired it up with GIOS.

Review It was the first semester when IIS transitioned to purely projects based, with 7 projects across different security topics. The first project had extra credit and it was the only project which I found to be challenging. The other projects were not straightforward, but were relatively easier and still felt rewarding when completed.

IIS is a great survey module, and the responsive TAs helped with any queries on Slack and Ed. The content was interesting and informative about how some of the vulnerabilities work.

Grade I ended the semester with a 99% and got an A. The extra credit helped, as I dropped some marks on the quizzes and submissions that were manually graded. Most of the submissions were sent to an auto-grader which lets you know your score and you can keep retrying if your answer is wrong.

Completely useless if you are looking to learn anything. It's a fine class if you want an easy A you can coast through. The TAs are unresponsive at best and dismissive at worst. Unfortunately, it is in your best interest to argue for every point you can since the rubric is so wishy washy. The TAs grade differently than the rubric and every TA grades differently. Your grade in this class is partially determined by which TAs you get for assignments. The quizzes are a waste of time and most of your grade will be based on assignments that barely test your knowledge of design patterns. The bulk of the points come from Assignment 3 which is Java and barely has anything to do with design patterns, all other assignments relate to this one so make sure your solution is good. The course is also pitifully outdated (you will never create a UML sequence diagram again in your life). I didn't read a single lecture and (with a BS in CS) got a high A with minimal effort. Also, from personal experience - you can brute force the quizzes for the entire class in an afternoon or two.

Great class, not too easy not too hard. This was my first OMSCS course and I was really impressed with the quality of the lecture videos. The TAs are also actually responsive as well which is nice. The open note exams aren't too bad but it depends on how good you are at control+f finding things in a ton of PDFs. Be prepared to write - a lot.

Pretty enjoyable course that offers a good introduction to analytics modeling and has engaging lectures and homework.

Since the exams are the biggest part of the grade, and the exams all come from lectures, taking your time viewing the lectures and taking good notes is probably my biggest recommendation to getting a good grade. I'd always take notes during the lectures and pause or replay more difficult sections of the lectures. Most likely those sections that seem the most difficult will be on the test. I was somewhat disappointed how little homework counted toward the grade since the homework can take awhile depending on your comfort with R, however all the homework tie back to the lectures so they do reinforce the concepts learned in the lectures.

Not a huge fan of the peer grading of the homework but all in all, graders were pretty lenient and felt on average it was pretty fair. If you ever find yourself struggling with the homework, Piazza and office hours are a must. The office hours before the homework is due will get you at least 50% of the way through the homework and cover all the important functions related to the homework.

I thought this was a great class and it doesn't deserve the criticism it often gets.

Lectures

I would rate the lectures as good but not amazing. I personally liked the back and forth between the Prof Isbell and Prof Littman. They try and introduce the concepts from the ground up and provide the intuition behind different algorithms. However sometimes this is a little hard to follow and feels quite non-linear. I did find the Mitchell textbook fairly useful though so would recommend that to get a more straightforward introduction of the topics.

Assignments

The coursework is 4 written assignments describing the outcomes of some experiments you ran (typically applying some algorithms to some data). They are open ended which I personally liked, and really force you to use your brain and think about what you are doing, and why you get the results you do. The assignments directly follow from the lectures, so you are made to really understand the material, which also translates nicely to the exams.

The assignments are a lot of work and probably why this class is considered one of the toughest in the program. They take a lot of time because you have to run lots of experiments. I did pretty well in them (96, 85, 94, 90). The key is pretty much exactly what the assignment descriptions say - look closely at your results and try and explain why they are happening. The 'why' is the crucial part. In many ways I see this as a class in data science. It is about creating hypotheses, running experiments and analysing results. I think lots of OMSCS students come from engineering backgrounds are used to building things (as opposed to analysing) and having their code auto-graded. This class is nothing like that and one reason I think some people tend to struggle.

Another common complaint is about the 'hidden rubric'. I partially agree with this. The open-endedness of the assignments does generate a lot of Qs, which leads to a lot of discussion and clarifications from the Head TA on Ed about approaches. This can be useful to monitor, however doing so takes a lot of time. If you're working full time and don't have hours to dedicate to scanning the OH threads on Ed, this may get frustrating.

However all that is actually required is i) read the assignment description and ii) watch the 15 mins overview at the beginning of the OH where all the requirements are outlined (take detailed notes!). If you only do these two things only, you should be okay and can probably block out the rest of the noise. For the most part I don't think the rubric is hidden and this is evidenced by students who do consistently well across all assignments. The key is to read the assignment description and listen to the OH carefully and do exactly what is described.

Something I really liked is that the assignments are marked by TAs. In other 'analysis' type classes this is often done through peer review which often ends up being a bit meaningless. You get detailed feedback and can use this to improve over time.

Exams

While the assignments test your empirical skills, the exams test your understanding of the theory. I did a lot worse on these (52, 53.5) though these were still around average for the class. I think the key thing here is to make sure you understand the lectures and the answers to all the quizzes. I sometimes see people recommend that you brush up on maths (stats, linear algebra etc) before this class but the maths is fairly minimal. Sure there are some equations, but neither the exams or the assignments require you to remember or really understand these.

Summary

Overall in terms of learning this is easily the best course I've taken in OMSCS so far, and the course design I think is excellent. I would absolutely recommend it to anyone who wants to work in ML.

Having said that, it is also a lot of work and quite stressful. If you're a computing systems person who just wants a peek into ML it's probably more stress than necessary and I would recommend ML4T or IAM instead.

If you do take the class my advice would be to start the assignments early and engage on Ed / Slack. If you do this and follow the instructions from the professor and Head TA you should be fine (the curve is real after all!).

This is a great class and you don't need to program in it, check out the full details in this 4 minute video: https://youtu.be/meYrgsUo48w

This is a philosophy meet neuro-biology meet cognitive science history class. I enjoyed learning about the debates between the empiricist and symbolists. How David Marr's tri-level hypothesis in his 1982 seminal book Vision paved the ground work for Computer Vision. I had no idea that neural network came from connectionism school back in the 70s. Additionally, Alan Newell and Simon Herbert's work on means-end analysis and physical symbol systems hypothesis were crucial for the early research work in AI. What should be the new Turning test be?

Overall, this is a fun class where you get to read old and new papers, how old school AI was, how brain works (mirror neuron anyone?), and exploration of theories by the well known Cognitive Scientists.

The workload is super chilled. I usually spent Sundays doing the homework during the weeks they were due. The weekly quiizzes are open book, multiple tries so easy to get full marks. The assignments are graded very leniently. The final project is open ended research exploration. Just an overall fun and easy class where you get to learn a lot of interesting things. The teaching staff is great and Irene does an awesome job running the ship as always!

Like most OMSCS classes, the instructor on record was completely MIA. Professor Goel did not teach this semester which is unfortunate because I really enjoyed taking KBAI with him.