This class was pretty tough this semester, but not impossible. I skipped most lectures so I could watch the recordings on 2x speed and pause it when I got confused, and ended with an A, but everyone's learning style is different -- no matter what do you, you won't get an A unless you're willing to work your ass off. Overall I really enjoyed the content but I know this class's grading policies are controversial.

Get every single easy (homework) point possible because the assessments kick ass. This is harder than it sounds. I often thought I would be getting easy points on a homework and I made stupid mistakes that caused me to lose them. I would recommend:
- Starting on PA1 and PA5 ASAP (like as SOON as you have gone over content in lecture). The other PA's aren't too bad.
- Going to TA OH starting at PS3, up until PS9 to verbally check your answers with them. This isn't a recommendation, it's a requirement if you want an A in this class.

I also made a study guide for all the assessments: https://docs.google.com/document/d/1IlR2pv8ozPaOcjEiCICM21mBfEtCjC9vl0hneZ7DKy4/edit?usp=sharing

Good luck, it's tough but stay positive!

Genuinely the worst class ever made. Everything about this course is antagonistic to students, actively tries to screw you over, and the absolute insanity is that this is a REQUIRED COURSE for the major. Bloomfield/Pettit have done nothing but make students suffer for no apparent reason but difficulty for the sake of difficulty. This class makes CSO2 look like a joke. If you are able to take this without either, please do so immediately. This course is awful at being timely on grading, questions never get answered, the professor actively ignores criticism, and has zero sympathy for students, and the resources given to you to learn the class are passable at best. Overall, if you want your semester to be a living hell, take this course. You'll quickly reconsider having majored in Computer Science at all.

You learn a lot in this course, but, at least for my class, it was structured for more harsh grading. (I was a part of Petit, but attended a mix of both Bloomfield and Pettit lectures throughout the sem). Here's one example. A single small mistake on the programming assignment docked off 40% of my grade on the assignment. You might say that this programming assignment might be small in the bigger picture, but it's not. Programming assignments as a whole are worth 25% of your grade, and there are only 5 programming assignments.

Before listing out some of the poor structural parts below, I'd like to mention that I'm not simply coping because I was screwed. In fact, I was curved from an A- to an A in the course, which I am extremely thankful for. However, that doesn't take away some of the big issues I saw in this course.
- Quiz grading and solutions had numerous errors. Even though quizzes took so long to grade (an untimely manner), I would have to argue for a ton of points back. If I hadn't spoken up a single time in this course, I believe I would've ended with a B+
- Like mentioned earlier, programming assignments were very unstructured. Firstly, there were hidden test cases. This would be fine if we could see our performance on them. However, our scores on them weren't shown. Instead of being able to spend time to refine our solutions and figure out where it went wrong, we were stuck guessing and almost gambling with our programming solutions
- I went to office hours every. single. week. If I didn't, I don't think I would've gotten as high scores as I did on the practice sheets (not programming assignments). The general lack of organization was pretty unforgiving. There were several times the questions were incredibly unclear, and the TAs had to elaborate. And a few times I believe last-minute clarifications were made on Piazza. If you missed these, there was a good chance you'd have a good amount of points docked.
- Similar to the practice sheets, I also distinctly remember a time when the programming assignments had a last minute clarification on Piazza, and I remodeled my entire solution.

I certainly hope in the next semesters that the organization of this course improves. And despite my criticisms, I genuinely believe there is a lot to learn in this class. Also, the only reason I earned such a high grade was from doing well on the quizzes and on the retakes that were available at the end + the curve.
#tcf2025 dev

CS 3100 was probably one of the poorest course experiences for me, and I thought CS 2100 had its issues.

First of all positives:
Pettit was a fine lecturer and he alongside Bloomfield were helpful during their office hours. The course material was honestly fairly interesting, and it is very applicable for CS job interviews as the strategies you learn here are widely used for interview questions. I would like to give a huge amount of credit to the TA's for making this an amazing course experience, as they were immensely helpful for tackling the homework assignments, so I would highly recommend going to them.

Now for my issues:
The grades are broken down into the following: 25% problem sets, 25% programming assignments, 50% quizzes (exams).
The problem sets were honestly fine. They could be tricky at times, but they were very helpful for understanding the lecture content and preparing for the quizzes.
The programming assignments on the other hand, were VERY bad. There were 5 total, so each were 5% of the final grade, and were filled with a lot of inconsistencies and confusions with the autograders. For example, one of the PA's had a solution that nearly everybody went for, that ended up giving nearly everyone under a 5/10 because it was not completely accurate despite the actual solution being much less intuitive. The professors showed no willingness to do anything about this.
The exams were weird and seemed to have many grading issues, so regrade requests had to be made frequently. Additionally, several people got a huge chunk of their grade gone in one of the quizzes due to a type that was not communicated properly in one of the sections.

And the thing that I disliked the most about this class was the changes from the semester before to make the class more difficult:
- New rule that final grade can only be 10% above quiz average cuz quizzes are more representative of our knowledge
- Final exam retakes gave originally up to 20% back, but changed to 10% for this semester
- Autograder for PA's with many test cases given originally, but now autograder only shows a single test case with the rest being hidden
- Extra credit for attending lecture was removed
- Bonus points for submitting homework assignments early was removed

Overall, if you do not need this class and the course structure is still like this, then I would not recommend taking this class. But I really hope the professors do make the necessary changes to eliminate all the issues that students expressed unhappiness with and gave feedback for.

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.