CS 3100

tl;dr stay on top of assignments and collaborate often

This should definitely be the hardest class you take in a given semester, but it's not too heavy to the point where you can't take this class with any of the easier CS electives. Bloomfield is an adequate professor, but the content is just a lot. Readings aren't necessary, but they can help if you need them.

If you can help it, take this class with friends. It's not a high priority like it is for CS 3140, but collaboration is encouraged and sometimes outright necessary for some of the problem sets and programming assignments. I used Java for most of the programming assignments, but I recommend using Python instead since it saves a lot of headaches. Try to finish them as soon as possible.

My main complaint with this class is that most of the grades do not come back until weeks later (as of writing there are still missing grades for assignments from over three weeks ago), but overall, you could do a lot worse for a required CS class.

#tCFF24

This course was disorganized from start to finish. There are two separate professors listed, but its taught as a joint class. Bloomfield is a swindling hardass that has made the course set up in such a way that you aren't supposed to succeed. Grading on quizzes is very arbitary. One small mistake can cost you 10% of the points on a quiz. Additionally, the programming assigments are designed terribly. The test cases are not revealed to you beforehand, leaving you to guess at what the edge test cases are like. Even if you write your own code to generate test cases and check with a friend (like I did), that is no guarantee that your code will pass whatever auto-grader tests that the devil incarnate Bloomfield has cooked up. On one programming assignment, a SINGLE test case was worth half the grade! Additionally, there are no extra credit opportunities (aside from the retake opportunities that will let you get back a measly 10 points back per quiz. Wow, the lord truly has graced us with his generosity).
Bloomfield's lectures are trash, he just reads from the power point and the guy is an evil version of Mr. Bean. He doesn't care about actual code quality, he just cares about your ability to pass autograder tests. This auto-grader method was created entirely to avoid having human intervention during the grading process and have a human, god forbid, actually look at code!

Not to mention, the grading for this class was unacceptably slow. It took over a month to return a problem set (a ONE WEEK turnaround time was promised). And, the grading was inconsistent with the syllabus policy outlined too! The entire problem set was graded for accuracy when the syllabus only said part of it would be graded for accuracy.

Oh, and the charity that bloomfield runs about teaching middle-school aged girls to code? Its totally disingenous. The school you go and volunteer at is an all-girls private middle school. It just happens to be the case that his daughter goes to school.

In conclusion, Aaron Bloomfield is the epitome of the adage that "those who can't do, teach" If Bloomfield is teaching this course, don't take it. Actually, this entire course is garbage, but especially when Bloomfield is teaching it. Its a really terrible course, and even though I got a fairly decent grade for this class (A-), it's persuaded me not to continuing majoring in CS at UVA. CS at UVA is just a money grab, and if you have the skills for it, you're probably better off going into electrical engineering or computer engineering or something else.

This class is a mess from start to finish, no matter which professor you take it with. Teaching assistants are unhelpful, grading is inconsistent, and averages are rarely released, making it impossible to gauge class performance. Programming assignments (PAs) are poorly designed, with hidden test cases that force students to guess edge cases. There is no partial credit. One bad grade on these assignments, worth 25% each, can severely hurt your overall grade. The policy capping final grade scores based on quiz averages is unfair and discouraging, penalizing students even if they perform well on assignments. Quizzes and lectures lack clarity, and professors and TAs often respond rudely to questions. Grading delays are unacceptable, with problem sets taking over a month to return, despite promises of faster turnaround times. This course fails to provide a supportive/effective learning environment.

I started wearing started wearing noise cancellation and jaywalking because this course made me wanna kms

This has by far been my favorite class that I have ever taken within the CS department. This class is a difficult class, and it requires you to spend a lot of time gaining mastery of the course and studying to get a good score. Each unit has two problem sets that usually take me eight to ten hours to figure out, get checked, and then write up, and each unit also has a programming assignment that takes on average 8-10 hours. I will be honest, this class is a lot of work, but Professor Bloomfield makes the class very interesting and is an amazing lecturer. I would 100% recommend taking this class with Bloomfield as he is very knowledgeable and is able to answer any content question that you have. The programming assignments can be difficult at times, but they are not impossible, and the class is not meant to make you fail or to be very difficult. The content itself is just very difficult and it just takes a lot of time to get used to the material and the way the tests are set up. The tests make sure that you actually can take what is learned and apply it, and I would recommend you do better in the first two units. The five units are Graphs, Divide and Conquer, Greedy, Dynamic Programming, and Reductions. Dynamic programming is the worst of it, but it is a very great class overall. Take it with Bloomfield and I recommend going to his office hours. Love the class.

This class was *not that bad*. It definitely gets a bad rep, but it was very doable. Biggest advice is go to class. Almost nobody did, and while he did post the lectures, it absolutely helped with my comprehension. The PA's were deceptively easy. I was able to complete most of them, with the exception of the first, within 2 hours - sometimes less. The PS's were harder, but they were great practice for the Quizzes and were one of the best resources to aid in comprehension. My biggest complaint is just the organization of the class. Professor Bloomfield often told us he was writing the homeworks the day/a few days before we were to do them, and it led to a lot of the PS's being uploaded at random times. Additionally, the syllabus for the class is very vague (no set A/A- cutoff, no PA due dates laid out in advance), Piazza questions were sometimes answered days/weeks after they were posted, and grading took over a month in some cases. Because of these issues, I think it led a lot of people to feel worse about the class than they might have otherwise felt. Overall, just stay on top of the work and study a lot for quizzes and you'll be good.

Fear not! Everyone makes this course sound terrible, but I'm here to tell you that it isn't and to recommend that you take it with Professor Bloomfield!

This course is challenging for sure. There's no way around that. But though difficult, it is the most rewarding course I have taken here thus far. Out of all of your CS courses, it is also arguably the most important. Going in, I was anxious largely because of everything that I had heard about it. The idea of making my own algorithms terrified me. But if you go to lecture and do the problem sets, you really can do it! By the end, what I had once thought I would never be able to do turned out to be something I really excelled at and enjoyed.

The main work in the course is split between problem sets, programming assignments (of which there are only 5) and quizzes. The Problem Sets are by far the most important. I recommend doing them on your own as much as you can before getting help in office hours. The programming assignments are easier in that you usually do not need to come up with an algorithm but instead need to implement one that has already been designed. Together, the PS and PA assignments allow you to practice both important skills: algorithm design and actual implementation. If you want to get a jump on prepping for quizzes and the PS assignments, I recommend sites like leetcode and hacker earth. I personally found hands-on practice like this more valuable than the CLRS textbook (which is very much optional), but the book is also good. Either way, finding other resources online (or in the textbook) to reinforce the material and practice independently helps a bunch.

As for the instructor, Professor Bloomfield really does make this course that much better. He is very engaging and knowledgeable and without a doubt my favorite professor here. Additionally, I felt that the grading in this course was very fair. Autograder cases on the PAs are hidden, but whenever there was an issue with the final autograder, Professor Bloomfield worked to fix it. And with the extra points available on the final to earn back previous quiz points, this course is more than fair. I do recommend thorough testing of your PA submission on your own though, which is good practice for industry anyway.

All in all, this course was really valuable and not as bad as it seems. Prepare to work hard, and probably have your other courses be a little lighter if you can, but it is very doable. And with a great professor like Professor Bloomfield who was both inspiring and knowledgeable, you will surely succeed.