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.

I took this my first semester along with GIOS. The course content is generally interesting, and I would consider this a good survey course. While I got an A in the class, I personally wasn’t a big fan of how it was run. I have python experience but no numPy, pandas or data analysis background. If you do all the work, I think you will likely get an A, but the projects are non-trivial. The reports also take a while to write.

How to do well: • This is a rule following class, for the projects pay close attention to the details. Buy a ream of paper, print out the project requirements and read through them 2x with a highlighter. • When you write reports don’t worry about anything other than fulfilling requirements. Don’t make a ‘good’ report, make a report that checks all the boxes. • Look at student charts on Ed. I found some mistakes in how I formatted my charts through this (again rule following class). Also read through questions, I was able to figure out an edge case would have missed in final submission if not. • Exams are a wild card, questions reflect readings more than projects or lecture videos and too me were very nit-picky. I think the strategy to get an A with minimum effort is to do very well on the projects and YOLO the exams. • For the Q-Learner project, performance optimize like crazy, it will help for final project. • For MarketSim, also helps to have a reasonably fast implementation for final project.

Things I didn’t like: • I though the TAs on Ed generally did a poor job answering questions and did not give straightforward answers to simple questions (like what file should produce x chart). They answer questions like politicians. My guess is they don’t know what the auto-grader checks and don’t want to be on the hook if they give the wrong answer, so you get an intentionally vague answer. • I thought the projects were over-specified, turning what would be fun projects into slogs. 20+ page specifications were common, that sometimes even dictated the color of lines in a graph. Also, for some portions there were more possible points to lose than gain. • The quality of the videos in the second half of the class really declined. I understand there were technical difficulties 8 years ago, bus surely new content could be produced. • You have something due every week. Whether it be a quiz on reading or an assignment. • It was always such a struggle to fit reports into the minimum page requirements of the template. I found myself having to write the minimum possible and still fighting to meet requirements. The required word template for this class is pretty bad IMO. If you have LATEX experience, I might recommend perusing that route.

Closing Thoughts: I learned from this class while I’m interested in ML, it’s not something I’m interested in pursuing career-wise.

Somewhat mixed feeling about this class. I thought the course content was interesting and definitely helped give a deeper understanding of the statistics behind regression and when regression will or won't be applicable, compared to 6501 which gave a much more surface level of the regression concepts. The homework was relatively easy if you watched the lecture videos and had already used R in 6501, and helped reinforce concepts from the lectures.

While the closed book (multiple choice) portion of the exam could definitely be tricky, as long as you made a good cheat sheet and studied a decent amount, you should at least get an 80%. Generally the open book (R) portion of the exam was taken directly from the homework's, lectures, or practice exams so as long as you downloaded all the material beforehand, you could essentially copy and paste for most of the exams and get 90-100%.

My biggest complaint is that the class could use a makeover to make the concepts more accessible and understandable (similar to how 6501 was done). The statistics used in the class honestly wasn't too difficult, but a lot of the time it wasn't explained in the lecture videos so if you wanted to understand the lecture video statistics, you'd have to do your own research outside of class. It was also kind of odd in it's pacing, first module was close to 6 hrs./week, 2nd 12 hrs./week, 3rd 8 hrs./week.

• very interesting content; gave me a fresh perspective of the world
• the written lecture format breaks from the norm of video lectures in other OMSCS courses
• there are Python typehints in the last assignment template - TAs indicated they would incorporate typehints in other assignments to improve quality of life
• without a strong grasp of the prerequisites (i.e. math), the difficulty and workload would be much higher than the average
• no automated grading via Gradescope, and no local unit tests provided to help check if we are going in the right direction

• interesting content
• lecture videos are not boring
• responsive teaching staff
• enthusiastic course mates
• challenging projects
• lots of errors and issues with exams (both midterm and final)

Pros:

• Easy and light. You can pair this class with anything.

Cons:

• Lectures are locked and released week by week.
• Many fundamental\conceptual\formula mistakes in Reidl's parts of lecture and there is no list of errata after students have been reporting for two semesters. His explanation to many concepts stopped at the "intuition level" ("just throw in a linear layer and see what happens") and did not go deep into the math. Does not feel like a graduate level course.
• The Meta lectures are basically 5 or 6 seminars presented by different people from Meta. Each presenter had their own style and used different terminology, notation, etc, which make them hard to follow and understand. Those are supposed to be the part of the class where the cutting edge NLP aplication and research are discussed. But this part is terribly prepared.
• Homework are poorly designed simple PyTorch API practice. The instructions are full of mistakes (e.g. you are asked to calculate posterior when training a Bayes model), and the unit tests are buggy and weak, which forced you to do things in the WRONG way just to get credits.
• Homeworks are all in Jupyter notebook format. They used a plugin called "nbgrader" to automate the grading process, which tunred out error prone and 3 of the 6 homeworks grading were delayed because of this.
• There is very little interaction between students and teaching staff. No office hour with TAs or lecturer. There were SIX 1-hour "recitations" for each homework, where they "tried" to answer students questions live. TAs rarely respond to questions posted in Ed regarding homeworks or lecture materials.
• It is also amazing that Dr. Reidl could find time to defend his "Exam window is from Mon-Wed" policy publicly in Ed on a Saturday night but also left dozens of lecture-related questions unanswered for weeks on Ed at the same time.
• Exams are open-everything take-home short answer questions. But most questions feels disconnected from the lectures and aimless. There could be questions asking you about a certain Pytorch API detail, which were never mentioned in the lectures and this simply became a Google search skill test. There could be questions asking you to compare A and B and explain which is better without any context, but the "correct" answer only accepts one "context". Cannot discuss exams on Ed even after grade release, strange policy.

This is probably the most disappointing class among the 12 classes I have taken with OMSCS. It feels rushed and lacks content and depth. The homeworks need a total overhaul. The Meta lectures might be more useful if they were presented by Dr. Riedl himself in a more consistent way.

Introduction and Background

As of course start, I had around 3 years of experience working as a professional software engineer, specifically doing web applications (full-stack C#.NET + JavaScript). My previous degree was in Engineering (non-CE/non-EE) from early 2010s. I also did five CS prep courses online via Oakton Community College (2019), as well as a full-stack programming boot camp (2020) to switch careers at the time (my work experience prior to this was unrelated to software engineering).

This was my fourth course in OMSCS, within the computing systems specialization. I previously completed GIOS (CS 6200, Fall 2021), IIS (CS 6035, Fall 2022), and CN (CS 6250, Summer 2023).

Parenthetically, I attempted HPCA (CS 6290) previously, first briefly in my second semester in OMSCS (made the mistake of attempting together with AI, ended up dropping both), and more recently in the preceding Spring (2023), however, due to an unexpected layoff hitting at a bad point in the Spring semester at the time, I had to drop yet again in the latter. (Fortunately, I did manage to land a new job after the layoff, but it was very hectic at the time nevertheless.)

High-Level Review

Overall, I really enjoyed the course. I thought the content struck a very nice balance between breadth and depth with respect to an otherwise complicated subject. The course topics span from "micro" to "macro" levels, providing the "building blocks" along the way. This spans roughly three general themes/areas as follows (in respective order of appearance):

• out-of-order processors and their internals
• the memory hierarchy
• multi-core and multi-threaded execution

Course Logistics and Time Expenditure

The course is not curved, and generally 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 50% projects and 50% exams, broken down as follows:

• projects (5% + 10% + 15% + 20%)
• midterm (20%)
• final (30%)

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

• 5 hours per lecture (videos watching and taking notes) * 22 lessons total = 110 hours
• 5 hours for project 0
• 15 hours for project 1
• 25 hours apiece for projects 2 and 3 = 50 hours
• 30 hours of prep per exam * 2 exams = 60 hours

Given a 16-week Fall semester, this averages out to 15 hours/week [= (110 + 5 + 15 + 50 + 60)/16]. The cadence was typically 1-2 (or incidentally 3) lectures per week, along with projects and exams, with the latter generally due Sunday by midnight AOE (equivalent to Monday morning in US-based time zones). The class is somewhat "middle-loaded" in my opinion, in the sense that the 5 (or so) week stretch spanning Project 1 (second project), midterm, and Project 2 (third project) is rather hectic, but otherwise the "flanking" parts of that are relatively more "placid" (but not "snooze mode" by any means, to be clear).

Course Deliverables

Projects

The projects all involved C++, more specifically the SESC CPU simulator, which was co-written by Prof. Prvulovic while in grad school. The projects span a few of the most critical/prominent topics in the course, and approach them more from a "lab" standpoint, involving tweaking the existing SESC code base (more so than coding a lot "from scratch"), and analyzing results accordingly. These topic are as follows (respectively in order of appearance):

• Project 0 - general introduction/orientation to SESC app
• Project 1 - branch prediction
• Project 2 - caches
• Project 3 - cache coherence

The last two projects (2 and 3) allow to work with a partner. This was helpful in my case, as my partner and I worked pretty collaboratively, and I suspect that we were able to finish faster between the two of us than had we been working individually/separately. Of course, "your mileage may vary" with these things. (There was an Ed thread to coordinate partners, otherwise we did not know each other going into the course, but subsequently became fairly well acquainted 🙂).

As a somewhat controversial/hot take, I thought the projects were actually pretty decent. Some of the typical criticisms going back to old reviews include (among other things) the somewhat archaic handout/form (with red boxes where you must enter your responses), and the "treasure hunt" in Ed for relevant information. However, neither of these were really as "obnoxious" as people tend to make it out to be in my opinion, as most of the relevant information is there, and head TA Nolan (in particular) was very helpful with directing accordingly as well. If nothing else, I personally much prefer this over courses with project handouts that are very vague and ambiguous, to a point of blocking progress on the project itself. Most of the relevant information is available in the aforementioned, and scoring in the 90-100 range is very manageable accordingly (as evidenced by the course-wide median grades falling within this range).

As another aside, having seen a couple of previous iterations of the course, one thing I can clear up here as of Fall 2023 (but I believe rolled out previously as of Summer 2022 or so), at least relative to older reviews, is that the project setup is much better after one of the more recently joining TAs (Joe) streamlined it by adding a Dockerized version (along with 64-bit VM) of the app. I can personally attest that the older 32-bit VM was a huge pain to work with, but fortunately that is no longer a relevant factor anymore. Thanks a lot, Joe!

Exams

I would characterize the exams as "tough, but fair." They are open notes, but they test a fairly sophisticated understanding of the material, involving a lot of "hand calculations" rather than just simply "rote regurgitation" of material. The midterm was logistically more challenging since it only allowed 2 hours, whereas the final was cumulative (i.e., including midterm content), but allowed for 3 hours and had heavier emphasis on the latter content (i.e., post-midterm), which was also more fresh by that point.

The staff additionally provides practice exams and (ungraded) problem sets to further reinforce the course topics, which are useful both for preparatory as well as for pedagogical purposes. Additionally, there are in-lecture "quizzes" videos (ungraded) which help to reinforce the "main" lecture content, as well as to highlight insights therein (e.g., to quantitatively demonstrate the assertions from the previous lecture videos with respect to "why A is more optimal than B," etc.).

Closing Remarks

In my opinion, this course complements GIOS (CS 6200) very well, covering similar subject matter but from the hardware perspective. I personally think the combination of GIOS + HPCA is the "quintessential combo" within computing systems, i.e., for somebody from a different specialization looking to "dabble" in computing systems, these are the two I would recommend to get a "big picture" (but otherwise thorough) sense of the pertinent subject matter; otherwise, for those within the computing systems track, these provide a strong foundation to explore further into other peripheral topics. In terms of ordering among these two, they are relatively independent, though I think some initial exposure in GIOS is helpful to understand the topics in HPCA, so I'm slightly partial to doing GIOS first in hindsight (though doing HPCA first instead will not be a "showstopper" in either, by any means).

With respect to difficulty and "pairability," I think this course was slightly less challenging overall compared to GIOS as a relative reference/benchmark, and I pinned it accordingly as an unambiguous "medium" difficulty (relative to GIOS being a more "medium-going-on-hard" for me). The projects in GIOS were relatively more involved/complicated, however, the more unique challenge of HPCA is just the sheer volume of material; the total lecture video time for HPCA is around 23.5 hours, and fairly info-dense to boot. If I were to pair with HPCA, it would definitely be something lighter (e.g., IIS), however, I would not recommend pairing something like HPCA + GIOS, especially not on top of full-time work.

Lastly, special thanks to the staff for making it a great course experience overall. Prof. Prvulovic is an absolutely brilliant instructor. The quality of the lessons is top-notch in my anecdotal experience with OMSCS courses to date (on par with GIOS for "best" overall I've seen among the courses I've taken thus far), and in particular I really appreciate Prof. Prvulovic's ability to distill such a dense/complex topic into a very well balanced breadth-depth trade-off, in such a manner that "told the overall story" without "missing the forest for the trees." I was able to come out of the course with a very comprehensive view of the subject matter, and appreciate that there was enough attention to detail to make the points stick, but without otherwise getting overly caught in the weeds with minutiae. Also, head TA Nolan is still the GOAT, and absolutely the star of the show. If you look at reviews going back years at this point, you will see them singing Nolan's praises along the way, and this is very much so merited accordingly.

Additional Resources

Here are a few things I put together during my stint in HPCA, which may or may not be helpful if you decide to take the course:

• markdown version of my notes
• combined/document version of my notes
• Docker setup and debugger via VS Code

The notes are fairly comprehensive. I clipped out all of the figures (see here), if you prefer to simply use those for your own notes. I essentially turned each video into an outlined/notes form of a "transcript" (i.e., very few details left behind), with the general idea/principle being "one watch the video once" (i.e., let the notes be completely "standalone" subsequently thereafter). The figures are numbered by lesson prefix (e.g., 01-...), but otherwise the numbering is just sequential as appearing throughout the videos spanning a given lecture (i.e., -001, -002, etc.), but not otherwise correlated to the canonical "video numbers" (i.e., in Canvas/Ed). Additionally, suffix Q designates "quiz," while suffix A designates "answer" (i.e., for the preceding quiz), where applicable.

It is a required course for the degree program, so there is little point in reviewing it. However, it is very bad.

You are given practical constructive feedback only 2 times in the entire course: first after proposing your topic, and second after you receive the final grade. There is no opportunity to discuss or refine your proposal with feedback from the professor. The only way to speak to him is during his office hours, which are held during day time working hours. In other words, he is inaccessible to you if you are full-time employed. You're on your own for the purpose of the course.

If in the future you have the choice to take 2 more regular courses instead of this disaster of a practicum, you should do that instead. It's that bad.

Context: OMSA student, taking as elective for fun and easy workload.

Fun course, easy workload. Only spent about 5 weeks actively engaged with the course. Two of those were right at the start with Assignment #1 which requires research, infrastructure building and planning.

The lectures are 100% optional. Download the transcripts and word-search them for everything you need.

If you want to do well on the assignments, completely overshoot the amount of work they tell you that you have to do. WORKING TO SPEC WILL LOSE YOU POINTS. This is my biggest complaint with the course. The peer work held up in class as extraordinary/exemplary frequently overshot the very-clearly-defined scope boundaries (for Assignment #2) and/or content length limitations (for Assignment #3). And then if you didn't meet this artificial above-and-beyond standard, you were penalized.

This class is engineered so that most people will get a B. If you want to take it as an easy course, go in expecting a B, and then "B" okay with that.

I learned a lot in this course.

However, NLP covers about 30% of what a modern NLP course should cover. It covers word embeddings, RNNs, LSTMs, Attention, Transformers and Key Value Stores. And Prof Reidl does a very good job of explaining the concepts in the videos.

However, the homeworks are a bit too simple. They also aren't very practically oriented. It would be more useful if we had an assignment where we were ask to do summarization, another where we were asked to do Question answering, another where we do translation. But unfortunately the assignments are less oriented towards specific tasks are more oriented towards particular techniques without much consideration to actual application. That being said they are fun and not to hard to work with. The course could do more in terms of depth with an orientation towards practical use. The class could also have much more in depth homework more appropriate for graduate level work that go much deeper into topics then they do.

Some things that are missing from the course would be to cover LLM training techniques such as Transfer Learning, Refinement, and RLHF. As well as well known techniques such as InstructGPT. The course seems oblivious of this.

The lectures taught by Prof Reidl are very good. But the Meta lectures are very poor. They throw around a lot of terminology without explaining it. It would be better if the professor simply re-recorded those lectures and explained them well.

Overall the class is enjoyable and worthy, but is a missed opportunity to do a lot more at a time that these topics are quite hot. The supposed reason Universities employ researchers to teach is so that they share the cutting edge with us, however, this class seems content with skimming the surface. It's easy to pair this class with others.

The ML CS7641 course has been the worst class I have ever taken anymore. The lectures are genuinely interesting, and I've enjoyed gaining insights into topics previously unknown to me. However, the assignments, TAs, and the current teaching staff have made this course a nightmare for me. The assignments often feel like a guessing game with vague expectations, making it easy to lose points due to uncertainty. It's frustrating that some poorly written work can surprisingly earn good scores, which can be disheartening. Additionally, the inconsistency in grading when different TAs assess assignments adds to the problem and frustration. At times, there have been reports of hate post from students towards the TAs or teaching staff. Be honest, it is a frustrating as waste time copying code from sklearn and did not learn anything useful from the assignment. To be candid, it's been disheartening, especially when you feel like you're investing time copying code from existing libraries rather than truly learning. Occasionally, TAs have asked students to be more concise in their work. Perhaps it's a two-way street, and there could be a request for clearer subject instructions and grading metrics from the students. Just my 2 cents, I'd say this course is only useful for those seeking a specialization in machine learning.

Grade Received: A (97%)

Background: UW-Seattle CS, graduated 03/2022 (thus, math concepts are still fairly fresh). Took upper level ML, statistics, and discrete mathematics courses. Current SWE II.

This was my first class of OMSCS. 3 classes later, this remains the class I disliked the most and found the most challenging (even more than ML). The class requires understanding of Calc 3 level integrations as well as recognition of statistical distributions, which will need to be integrated. If you are unfamiliar with basic integration concepts such as the chain rule, be wary of this class. The lectures were incredibly confusing and I "book-learned" this class (I should note that I found the textbook quite well written). The "professor" was practically non-existent: I only saw a few Ed responses from him throughout the course and no other trace of him. The saving grace of this course was the head TA who lead fantastic office hours and would essentially, for better or worse, spell out the assignments for us.

The class becomes significantly easier after the midterm: less math and a lot more coding. The class is taught with an archaic piece of software last updated in the early 2000s called WIN-BUGS - I opted to use some of the Python libraries and one of the TAs wrote up an extensive guide. In hindsight, WIN-BUGS is actually easier to use, though less applicable to modern day issues, and I used this on the exam to much success.

Primary Advice: This class is more for people who already have a solid understanding of Calc3 concepts and statistical distributions (mixture of gaussians, gamma, etc). Considering there are many other courses to take that are more CS heavy, especially for the ML track, I don't recommend anyone take this course.

• interesting content
• lecture videos are not boring
• responsive teaching staff
• enthusiastic course mates
• fun, game-like projects

• interesting content
• lecture videos are not boring
• responsive teaching staff
• enthusiastic course mates

Super tough course, check out my candid review here! https://youtu.be/LEwjFYt4XIQ

Haha this class was a joke (really hard but may have changed) Check out my candid review here! https://youtu.be/LEwjFYt4XIQ

For the summer, 2 modules are dropped but the first 2 modules are the most difficult and worth the most. The course would be a lot better if the latter modules were worth more to even out the demands of the class. There is also slight overlap with MGT 6203. The class is effectively a mini-MBA, which can be helpful, especially if you are currently working full-time to help connect ideas to your own business.

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.