CS 3100

The material covered in this course is extremely interesting, going over interesting concepts involving graph theory and traversal (Dijkstra's Algorithm, Breath First Search, Depth First Search), Divide and Conquer algorithms (ex: Merge sort), Greedy algorithms, dynamic programming, and network flow (Ford Fulkerson, Edmonds-Karp). On top of that, Professor Pettit is a good lecturer, being able to describe the concepts pretty well.

However, despite how interesting the material was and even though this class isn't the hardest CS class I've taken at UVA so far (CSO2), this class has been the most miserable experience I've had in a CS class.

Grading is abysmally slow in this class, making it so that assignments and quizzes are returned in an extremely untimely manner. On top of that, grading was extremely inconsistent in this class, causing a lot of unnecessary headaches and stress, with students having to constantly submit regrade requests to get credit for the work they did. The class is divided into Quizzes, Programming Assignments, and Problem Sets, and out of the 5 Programming Assignments assigned, 2-3 of them had major issues with their autograders, resulting in headaches when it came to getting proper credit for the work you did.

On top of that, the way the programming assignments were handled was incredibly frustrating, with hidden test cases deducting points disproportionately, with one out of the five test cases for a programming assignment being worth half the points for it. If the instructors wanted to use hidden test cases, a better way to handle them would be to show how many test cases you passed on submission without giving too many details so that students can fix their assignments and get a better idea of what they did wrong before the due date.

Quizzes are also somewhat difficult, and even though the course offers retakes for them, they only let you gain back 10% for each quiz instead of the previous semesters which let you gain back 20% per quiz. Be prepared to also send out regrade requests for quizzes, as sometimes you will lose points for something you gained credit for.

Overall this class was extremely frustrating and unnecessarily stressful. I hope that the instructors take the feedback the students provided this semester to structure the class in a better way, as the course content itself was pretty interesting, but the way it was handled was unorganized.

Everything that I could say about this course has already been harped on in previous Fall 2024 reviews. Poor, if any, communication from professors and bogus autograders that impacted a majority of students' final grades by 3+% on three of the five PAs were the two downfalls of this semester. I, along with many others, experienced unnecessary stress due to these factors and it made it difficult to really appreciate the content being taught.

Similar to other reviews, I didn't think the lectures were too bad. Pettit and Bloomfield both record lectures which is helpful for reviewing for quizzes, and I think Pettit in particular was a good professor to go to OH for.

I won't drag on and on about this class, but I hope for the sake of my friends, others taking it next semester, and even you reading this that this class is vastly improved over the next few semesters. I created a tCF account just to write this review as a warning for future students and to cope with the fact that Christmas is in five days and I still don't know my final grade in this class.

Good luck to you and good riddance to CS 3100.

While this course has received numerous negative reviews, I wanted to defend the professors in certain regards.

Professor Pettit, though not particularly inspiring, is approachable, knowledgeable, and genuinely kind. Professor Bloomfield delivers engaging lectures, despite occasionally coming across as cold. The course content is well-structured, and I generally found the lectures useful; I would recommend ALWAYS doing the readings associated with each lecture. The Problem Sets (PSs) and Programming Assignments (PAs) are challenging but thoughtfully designed, significantly enhancing students' grasp of the concepts. While there were legitimate concerns regarding PA3, this issue is likely to be addressed in future semesters. The assessments are comparatively manageable relative to similar-level courses, and with a modicum of studying and consistently going to lecture you'll do relatively well. The policy of returning up to 10 points on quizzes at the semester's end is particularly beneficial. Overall rating: 8/10 - a worthwhile course that I recommend.

I love you Pettit <3

All I can say is ugh. I’ve never left a review for any class before, so the fact that I made an account just to write this says a lot. In most CS classes at UVA, you can usually do really well in one area—like homework or tests—and okay in the other and still be fine. There’s usually some kind of leeway. But this class feels like the total opposite. You have to do extremely well in both to get an A. If you mess up on either the PAs or PSs, your grade takes a huge hit with no real way to recover.

For example, you could have a 100% test average and an 80% homework average and still end with a 90%. And considering the breakdown—PAs are 25%, PSs are 25%, and tests are 50%—messing up on anything is terrifying. Plus, the PAs and PSs are tough and loaded with hidden test cases. You can pass the initial autograder but still end up with a 1/10 after the hidden cases are applied.

It also doesn’t help that in past years, students could earn back up to 20 points on retakes with extra credit, but now it’s only 10 points.

Apart from these aspects, the class is very helpful for interview prep.

I would love to give this class a good review because it was genuinely interesting. I learned a lot of CS topics that were relevant. I found Pettit's lectures to be great for understanding the material! He explained things well and simplified concepts so that students can follow along. Although his lectures were a little dry and heavy, watching them back was extremely helpful.

HOWEVER, I can't give this class a good review because of the assignments.

Starting with the PAs:
The Programming Assignments (PA) were basically pass/fail. If you didn't get the test cases, you failed. There was very little leeway even if your code needed one small fix to pass the test cases. And these test cases were hidden on gradescope until the assignment was graded. These test cases also focused on very specific edge cases that are difficult to predict. I believe the intention behind this decision was to teach students the importance of testing and the testing process. However, if we got the formatting of the output wrong, our grade would be impacted greatly.
The PAs themselves were flawed. The last PA in particular was supposed to be a greedy algorithm approach to a given problem, but the greedy approach didn't work within the context of the problem. When students brought this up on Piazza nearly a week before the assignment deadline, none of the professors responded, so students were confused on how to approach this problem (and a lot of them failed the assignment).
I do agree with the decision to hide some test cases from students in order to promote the testing process. However, I disagree with hiding nearly all of them because it's hard to anticipate if our code is working without a more clear idea of what the test cases may look like.

Next is the PSs:
Honestly, I don't have too much to complain about for this. Some of the PS questions could not be solved with material that we learned in class. That would be my only complaint.

Finally the Quizzes:
Sometimes, the answer key for quizzes were very wrong. I lost close to 15/100 points on a quiz 1 due to an answer key mistake. If I didn't go to office hours to explain my answer, I would not have gotten these points back (and since my approach was quite common, I know many people were wrongfully marked incorrect).
A lot of people may complain about the policy that your final course grade can not be more than 10% above your quiz average. However, I understand the reasoning behind this choice since quizzes are more resistant to cheating. I have no issues with this because I was not personally affected (my quiz average was on the higher end), but I understand that some people are bad at test-taking so this policy might affect them negatively.

Overall, it would have been a really interest class if it wasn't for the assignments. I enjoyed the topics and content covered, and did well overall on the quizzes. However, the assignments were difficult, flawed, and confusing.

I'm sure that the policies will be better ironed out in the next semester. However, speaking from my experience in this one, I would not recommend taking this course.

This course is NOTHING like DSA1. While I cannot speak to the quality of this course in previous semesters, I will say that it has been extremely poor this semester. Lectures are about what you expect, I have no complaints there, as they are standard lectures. Both Petit and Bloomfield stop to check for questions and read generally what is on the slides. Since the course is taught by both of these professors, a review for one is a review for both as my gripes with this class come from the structure, not with the lectures themselves, which is the only area where the professors diverge. As I understand it, some changes have been made to this course to protect against cheating. One of them is that your final grade cannot be more than 10% above your quiz average. There are, however, opportunities to earn back quiz points, so this change is pretty reasonable. However, the programming assignments, which make up 25% of your grade now have hidden test cases. Many of these test cases are either buggy, extremely difficult to test locally, or both. With only 5 programming assignments, being handed a 5/10 or a 3.67/10 can cripple your final grade. The kicker is, average piazza wait time is 2-3 hours, and you are FAR more likely to get a response from another student in the class instead of an instructor. We have all seen the reddit post ranting about CS students in academia, and I am in means saying that we are entitled to an A on any one assignment or quiz. We do, however, deserve clear communication from the instructors of this course, and they have botched it this semester. Unless they change things again, you are completely on your own in this class. It does not matter what professor you have for this class, and you can't get around taking it. Good luck.

This class was really interesting but a lot of work so I would try to make it your hardest course. I really liked the material but it seemed like Pettit would be reading off the slides for the first time, but all of the lectures are recorded so that is helpful. However, Pettit is very understanding and helpful in Office Hours and it may have just been that he had other priorities this semester.

There is a lot of work for this class. First, we had weekly Problem Sets worth 25% which were really tedious and time consuming. I would definitely recommend working with friends and going to TA office hours for these. We barely got anything back until around halfway through the semester so we had no idea thoroughly these were graded, but they were pretty picky until they switched to just check for completion to grade faster. 20% of the grade came from biweekly Programming Assignments, which were a lot more enjoyable than the PS's but still took a decent amount of time. I would suggest doing these in Python but you can also do them in Java. There are 5 quizzes that make up 50% of your grade (10% each) that are divided into 2 "exams" of 2 quizzes each, then a final. These can be really hit or miss and are based on all of the content for the slides so I would suggest making sure you really understand and can apply those. Readings aren't necessary at all.

Overall this was an interesting but time-consuming class. Make this your most difficult class and try to stay on top of everything!
#tCFS24

The first thing I'll say is that I personally wouldn't recommend taking this class with Pettit. For half of the semester, I went to his lectures and found them very unhelpful. Each class felt like I was watching him see the slides for the first time (which he might have, since they were made by Hott) -- he hesitated a lot and avoided elaborating on complex concepts such as time complexity calculation or why an algorithm worked a certain way. After doing terrible on Quizzes 1 and 2, I started going to Hott's lectures in the morning and he was MUCH better. He was engaging, paced his lectures well, and knew the content for each class through and through. He explained concepts like the max flow theorem etc. very thoroughly and with great examples, and I did a lot better on the last 3 quizzes because of that.

Aside from the instructors, this is a very difficult class. The final grade is composed of:
- 50% from 5 quizzes: Quizzes 1 and 2 are taken together, and same for 3 and 4. Quiz 5 is taken during the final exam time slot, during which you can also take the time to "retake" shorter versions of any of the previous quizzes to gain up to 20 points back on your scores for them.
- 20% from 5 programming assignments: Not that bad, you get a lot of time to do them so I would suggest starting early. You can code in either Java or Python, and are provided with general shell codes for each as a starting point.
- 25% from 10 problem sets: These are extremely difficult and time-consuming, I would highly recommend going to office hours to get help/advice from the TAs (especially on when proofs are required). After a certain point, the teachers decided to grade them based on completion this semester but I don't know if this will be true for future students. The graders are very picky and you will lose a lot of points if you do something off.
- 5% from attendance and course review etc., probably mentioned near the end of the course

Overall, it is a very difficult class but I found the concepts super interesting and fun to put into practice. The assignments are a chore but they teach you how current concepts work pretty thoroughly. Good luck!

P.S. There are course readings in the CLRS textbook, and I did take notes on them. I think they're okay but not necessary, just take notes on them as a supplement if you don't understand something.

#tCFS24

- COURSE -
This is definitely a tough course, but I do think its difficulty is overhyped to an extent. The first time I tried to take this class, I had to withdraw and retake it the following semester due to how frustrating it could be. To succeed in this class, you'll probably need to brush up on your calculus a little bit, and be pretty proficient in OOP principles. You also might want to brush up on some of the more complex data structures you went over in DSA1, like heaps, mergesort, and quicksort. There are bi-weekly problem sets that aren't too bad in my opinion, and I recommend visiting office hours if you feel lost with the instructions. Towards the end of the semester, the professors stopped grading them in terms of correctness because it was taking so long, which definitely helped my grade, but also made the problem sets seem somewhat pointless. The programming assignments can be really tough depending on which one, but on the good side, the autograder usually will tell you what specific test case made your code fail. I found this to be really nice in comparison to some other CS courses' autograders. There are bonus points for submitting PS's and PA's early, but they only give you 2% extra; I'm not really sure how I feel about this. The process of getting an extension is borderline impossible unless you're in the hospital, in court, or a student athlete, which I feel is somewhat unfair. You also have to provide "considerable work" on the assignment, and if you submit even a minute after the deadline without an extension granted, you get a 0. The quizzes are worth 50% of your grade, and can be ridiculously challenging. It's extremely disheartening to be given a problem worth 30 points on one of these quizzes and not know the answer; 30 points on one of these quizzes is worth 3% of your final grade. You really want to study for these, I'd recommend studying the proofs on the slides very heavily. The collaboration policy is also extremely confusing and vague, I think they need to provide more examples of what is and isn't allowed to be collaborated on.

- INSTRUCTOR -
I liked Pettit. He's very chill and approachable, and a decent lecturer. I'll admit that the lectures do get pretty boring at points, but it's not too difficult to review the material outside of them. I'm not sure if Hott will be teaching this class next iteration, but it seemed like he was handling most of the course administration and decisions about the layout of the class. The TAs for this class tend to be pretty helpful, but I did have experiences with some that were really disappointing and unhelpful. There's a help desk email address you can forward questions to, but I'd recommend going in person instead. Emails can get lost and not responded to for weeks after an assignment was due.

Overall, this class is definitely difficult, but not impossible. I wouldn't recommend stacking it with other tough classes, though. The first time I tried to take this class, I paired it with CSO2 which ended up being way too much work, resulting in me withdrawing. I would highly discourage doing that unless you have absolutely no commitments outside of school and are willing to devote the majority of your waking hours to schoolwork.
#tCFS24

Pettit is not a good lecturer. I used to really like him when he taught 1110 but I realized, that is just because the material was easy. This material is dry and it is clear the slides weren't created by Pettit, it was by Hott. Pettit looked like he was looking at the slides for the first time too when he was lecturing and would just read off the board.

This class also does not deserve to be a 3 credit class. The time commitment for this class is insane. Oftentimes, we would have weeks where a problem set and a programming assignment was due the same week, 2 days apart. Before they changed the problem sets to be graded by completion because they couldn't keep up with grading, I used to spend nearly 12 hours a week on that damn problem set where they would be sooo nitpicky with grading criteria. I spent 3 hours a day, 4 times a week, at office hours to TAs who don't have the answer key. The TAs would give me wrong answers that would conflict each other ultimately leading me to get points off on the grading.

The learning curve is steep and not easy from DSA1 or CSO1 to this class. YouTube videos are your best friend at actually teaching you.

#tCFS24

I really enjoyed the content of this class and was genuinely interested in it. However, at times the problem sets could be very confusing and hard to get an understanding of. They offer a 2% extra credit opportunity for submitting problem sets and programming assignments 2 days early so that was helpful. Overall, I enjoyed the material and thought this was a very helpful class for my CS career.

#tCFS24

This class is definitely tough. The material is incredibly interesting and very fun to learn about, but the problem sets can be difficult and the quizzes are unreasonably hard. The bonus for submitting problem sets and programming assignments (2%) is so measly that it seems like insult to injury considering that the "late policy" can basically only be invoked you have a medical/family emergency. The 5 quizzes comprise 50% of your grade and the questions are overly difficult. You do get the option to earn back some points on quizzes, but only up to 10 out of the 100 each one is worth. If the exam structure of this class was different, it would be more enjoyable.