CS 131 with Carey! I personally didn't take CS 32 with Carey, so I was pretty hyped about this. And honestly, I think it lived up to the hype. The class did remind me CS 32, in terms of the type of content covered and the programming in the class.

As a disclaimer, a lot of these criticisms are probably because this was the pilot quarter for the course. Carey will probably improve most of these criticisms in future offerings.

The class material isn't difficult, there's just a lot of it. I thought most of it was interesting and cool, you really get a pretty good grasp about how different languages do things differently. His slides are very in-depth and good for self studying. But by the week 6 midterm, there was honestly so much content to review it was a bit of a struggle. If you study early and come prepared with notes (open note/book exams), you will be fine.

We have 3 projects in the class, each building off the one before it. The projects were basically implementing an interpreter for a made up language using Python. They did take quite a long time (15-20 hrs), but definitely doable and good just for practicing your programming/code design skills. In future courses, I think he might shorten them a bit or provide more starter code, since a lot of students seemed to take a while on them.

Overall very satisfied with the class, glad this course got reworked with Carey!

If you have to take CS131, definitely take it with Carey. This was the first quarter he taught it, so some imperfections were expected. Overall, Carey and the TAs (pre-strike) were all very passionate and helpful. They actively listened to our feedback and put in a lot of effort to improve the class.

Class website: https://ucla-cs-131.github.io/fall-22/

The homework (graded on completion) was initially very long, but they listened to feedback and made some questions optional. The projects were a bit more time-consuming than initially expected (maybe 20+ hours), but the autograder was insanely helpful to instantly see your score on Gradescope, and there was a subset of the test cases publically available. The exams (open book) were fair but challenging, and really tested your deep understanding of the concepts. The course material wasn't particularly difficult, but there was a significant amount.

Advice: (seriously) don't procrastinate on the projects! Try to keep up with the course content because it's really easy to fall behind. Attend lectures (he's entertaining and gives out snacks) - it may feel easy to ditch because he posts his slides, but he will explain things more clearly than if you skimmed through the slides yourself.

Had a great time with him. Lectures are very clear but move quickly as there is a lot of material to cover. The exams are close to what we cover in lectures but more difficult. But it's still good, at least the professor covers a lot and won't let you see the questions and have no idea what to do like Eggert's exam.

Very well organized class. F22 had three projects (which build on each-other) where you had to build an interpreter for a new language. Pretty heavy workload for these, but grading was transparent (through a Gradescope autograder). Carey's a good lecturer, as usual. Exams were pretty tough IMO, and the class ended with about 30% A's, 30% B's, and 30% C-F's. Best strategies would be to have the concepts down perfectly and get a lot of practice programming in the languages that you study that quarter (for us it was Haskell, Python, and Lisp.)