I really enjoyed this class! We spent 1/3 of the semester reviewing Java and 2/3 of the semester going over data structures and algorithms (trees, searches, LL, etc.). Professor Morrison gave up to 3 bonus points if you turned in homework assignments early, so I would definitely recommend taking advantage of that. Also, make sure to take advantage of TA and professor OH!

The course is definitely not as much of a mess as the older reviews suggest. Honestly, my biggest gripe with the course would be the lectures — Prof. Morrison's slide decks are way too big (they appeared to be multiple slide decks merged together) and she moves way too fast during class (don't expect to handwrite notes and keep up). Still, going to the lectures was more beneficial than skipping (especially since she does coding demos as well), especially since the class as a whole moves very quickly throughout the material.

The grading breakdown is, in my opinion, very fair:
Syllabus Quiz: 1%
Programming HW (you get a few bonus points for turning it in 2 days early): 36%
Labs: 13%
Quiz A (an at-home, timed programming assignment with resources): 12.5%
Quiz B (in lab, multiple choice, no resources): 37.5%

The hardest of these are the quiz Bs: they definitely require you to study the material well, and some questions are just flat-out ridiculous. There is no final; instead, you can retake 4 quizzes (e.g. 2 quiz Bs and 2 quiz As).

No comment on office hours (I never went to them), but Piazza is a helpful resource I used a lot.

My biggest tips for the course are to finish the homework early to get all of those bonus points (although you can get a late extension if your program is partially working, only use these as a last resort) especially if the quiz that week is going to test on the homework's topic. Also, come into the class with at least a basic amount of Java knowledge. But overall, this course is definitely manageable if you dedicate the right amount of time to it.

This course isn't recommended unless absolutely necessary due to its lackluster execution. Despite the interesting and useful content, the lectures were vague and hard to interpret. The professor's use of numerous examples and analogies made in-person lectures challenging to understand. Skipping lectures and watching them at my own pace proved more productive.

Assignments, while not terrible, required self-learning from slides and online resources. Homeworks offered an easy 100%, with extra credit for early submission. Labs, though not a great experience with dismissive teaching assistants, were a free 100% if completed promptly. Achieving perfect scores on assignments and labs is crucial, as quizzes, especially Part B, are challenging and demand knowledge of obscure details, resulting in average scores around 60%.

I took the class with absolutely no Java experience and it was an absolute nightmare for the first half of the semester. The class is extremely difficult initially if the only programming experience you have is CS 1110 or the equivalents, and I recommend studying with other students. It is possible to do well in the class even if you suck at the beginning of the semester, it just takes a lot of time and hard work. Morrison is an alright teacher, but she does not really teach the Java, and the tests have material that you will never have gone over in class or find in any of the lectures. It is a very interesting class, but definitely a butt kicker.

Great content that is foundational for all your future endeavors in computer science. To be honest, I had a background in Java so the class was somewhat a review, and so I literally skipped all the lectures but 2. However, I did watch the videos and read the slides for each quiz. Also, someone who does not have experience in Java may struggle to adapt, especially if they are coming straight from the Python class.
I did pretty well on the quizzes, but from my experience sometimes it can be luck because the questions are random for each student. Sometimes, the quiz would be pretty straightforward, but other times, I would have multiple tricky questions where I was stuck between two answers.
But outside of the quizzes, there's so much extra credit, and you should do it. It gives you so much leeway to bomb a few quizzes and still get an A. Also, you get two tries for each quiz. Plus, I think I heard that they added extra credit for doing some notes worksheet, but honestly that's overkill.

Experience with the class depends A LOT on how much prior knowledge you have of 1) Java and 2) data structures.

While the profs cover Java in the first month, the class still moves REALLY quickly through all the Java concepts. Next year, they're planning on additional Java-teaching courses, so hopefully they can bridge that gap.

Structure of the class is fair. There's 1 lab and 1 HW due per week, and a quiz every 2-3 weeks. The quiz component consists of a multi-choice test and a coding test. The final is just retaking the quizzes, so the quizzes themselves are relatively 'low stakes.'

I think Prof Morrison does her best with the content. I think learning code via lectures isn't very helpful (regardless of the prof), so I don't know if another prof could've done better with the material. Then again, I stopped attending lecture and just read the slides and did fine. #tCFS24

Professor Morrison sets up the class really well, there is ample room to boost your grade and the final is a chance to fix your quiz grades. She's a great lecturer too. The quiz Bs are unnecessarily difficult (trick questions, ambiguous code) but ideally everything else will bring your grade up.

Definitely recommend going to office hours, there's plenty of TAs who are super willing to help.

Tl;dr be proactive about questions and getting help and you'll easily get at least a B without trying too much

If you have prior coding experience (like an AP class or even a CS 111x section), the first third provides an opportunity to ease in since it's an expedited summary of the Java language. While some of the syntax is different, most of the concepts remain the same, so it will give you a good opportunity to figure out what you need to do to adapt to Morrison's improved but admittedly fast and somewhat surface-level teaching. Because of this, make it a habit to ask questions in lectures and attend office hours often. In labs, find a good TA or experienced student to ask questions. Complex data structures like AVL Trees, Priority Queues, and HashMaps can cause you to slip up near the end, but because the final was just an opportunity to retake 4 of the 10 quizzes, you definitely have opportunities to catch up. It's still an intro course relative to the rest of the CS department's offerings, but it's definitely easier than classes like CS 2130.

Everything that has been said about Professor Morrison, from her condescending attitude to how she races through lecture slides, are all true. I personally don’t resonate with her teaching style (if you can even call it that). She goes through the powerpoints at lightning speed, then does some in-class programming examples. I’ve basically had to teach myself the content, which is extremely annoying. Honestly, I would choose Morrison over Stone, but be prepared to do a lot of outside work for this class.

The course covers a lot of ground and moves quite quickly, especially at the beginning. If you're coming from 1110/don't have experience with a C-like object oriented language, I don't think it would hurt to get some basic experience with Java prior to taking the class, since they really blast through teaching the language in the first couple of weeks order to get to the more abstract concepts. I found the data structures and sorts genuinely interesting, and they're particularly applicable to technical interviews/any programming really.

As a lecturer/teacher, I found Morrison pretty effective. I eventually found that I learned best when I didn't attend class and instead watched the recordings so I could pause to digest and think through the concepts, since I think she tends to jump from A to B a little quickly at times, but her explanations were sound and my follow-up questions were always addressed with care. She was clearly aware of the complaints about the amount of slides and lack of live coding from last semester since she made a point of cutting down her presentation slides and spending lecture time doing demos (though she basically stopped the demos when we got to the more abstract concepts, but I think that's valid when the homeworks have you doing all the implementation of those concepts anyway).
As a person, when she's not one-on-one I would describe her as either sassy or snarky depending on how generous I'm feeling, but when interacting personally in office hours or after class she was really lovely - she was interested in me as a person and was genuinely excited to talk/nerd out about the content. She also was quite receptive to any feedback I had, and I think ran a fairly smooth ship this semester. She's still figuring some stuff out, and having a quiz the week of Thanksgiving was not great, but she went back to Gradescope at least and was able to adjust on the fly when she missed a week (due to illness).

Most undergrad TAs are uninterested and/or clueless, but a couple are good (shout out to Nathaniel the Piazza goat and Jacob). I only went to office hours a couple times and there was always 10+ people in the queue since there's only usually 2 TAs on one shift, so I wouldn't rely on TA office hours too heavily if you can help it. The graduate TAs were also up and down throughout the semester in terms of turnaround time for grading, but it wasn't too awful. I think the worst it got was 4 weeks to grade one of the homeworks.

The grading breakdown this semester was 36% for 12 homeworks, 13% for 9 labs, 12.5% for 5 quiz As (at home, mostly open note), 37.5% for 5 quiz Bs (in-person, closed book) and 1% for a syllabus quiz. No curve, but homeworks can be turned in 2 days early for 0.3% extra credit (which adds up to 3.6% over the semester), plus another 1% for course evals, so you can easily bump your grade from an A- to an A through that. Quiz Bs were the hardest to do well in, everything else was chill if I stayed on top of it all, but I found most questions on quiz Bs manageable if I studied the slides closely and practiced applying concepts (a few questions tested completely useless or tangential knowledge though).

This wasn't communicated clearly, but I got the impression that we were expected to be putting effort into learning on our own time (through tinkering with code and/or reviewing other resources) in order to really succeed. I think it's a valid approach to teaching, particularly for computer science/programming where the real world expects you to learn on the fly with varying quality of documentation as your only resource, but whether that works for you is your call - my advice would be to try embrace it regardless.