If you take compiler construction, You should take this professor. The diagram rating is completely wrong. He is not hard.

Class:

The class is project-based grading. Projects grade is 55% of the total grade. So if you can do the project, you can pass the class. Not only that, if you can do the project, you can do the midterm and the final, because they base on the projects.

Project:

the class requisite is that you took cs 131, but you can get in cs 132 even if you don't. The only thing you need to know from cs 131 is how to program in Java. The project is Java project, not C/C++ project. Get to know Java before enter the class. Also, the compiler breaks down to completely independent projects. Also, the thing you need to remember from CS 181 is PDA (not your typical hand-held PDA) but Pushdown automata; and how actually to code a PDA for first project. For other projects, you need to know visitor pattern and tree data structure. He goes over that briefly in class.

4 things you need to know before taking the class is to get A in the class.
+ Java (coding and how to invoke Java build in terminal)
+ PDA
+ Visitor Pattern
+ Tree data structure

Professor:
He is very nice, you can reach him through email. He is very responsive through email. You has plenty of time for project, BUT don't wait till last moment.

Prof. Palsberg is a very clear lecturer and the theory is presented very well
in lecture. However, the lectures, being all theory, is a little dry. But it
is good that he clarifies the content; I would've been lost if I had to read
the theory from a textbook. The best part about this course is undoubtedly the
homework assignments. Implementing a compiler almost completely from scratch is
so rewarding. I like the fact that the class isn't exam-focused; the midterm (60
multiple choice questions) was the easiest midterm I've ever taken at UCLA.
Also, this class has the most active piazza out of any class I've ever taken at
UCLA---the average response time is only 13 mins.

Biggest weakness of this class is that it's too short. I would've loved an extra
quarter where we can practice implementing generics, lambdas, and learning about
more advanced and interesting programming language features.

Professor Palsberg is very passionate about teaching and improving this course. The fact that the course has been offered continuously for decades by the same instructor means that nearly all the kinks have been worked out of class, and it is as such no surprise how polished the entire course feels.

I concur with the previous review that says the grade distribution looks skewed. In actuality, the course is more work-heavy than difficult, and grading is done fairly. For instance, even though more than 90% of the students got above a 90% on our midterm, the professor does not curve down the grades.

Another update to the previous review is that CS 181 is no longer a course prerequisite, so anything related to PDAs you can now ignore.

A great experience, Palsberg is a great professor, however, the class is project heavy which means you'll learn a lot from the projects!

This is a required class for computer science majors and it's pretty much a filler course. If I were given a choice, I would not take it because the guest lectures are really boring.

Great professor! Super clear, nice and helpful. Highly recommended. The workload of the class is a bit heavy but you definitely learn a lot about quantum computing. The first half of the course is relatively theoretical with many linear algebra-like problems. The midterm is based on that and you might need to practice similar problems beforehand to get a good grade. The second half of the course are mainly practical projects and you do get to implement your own quantum computing circuits and run them on REAL quantum computers. My suggestion for this class is that always START YOUR PROJECTS EARLY, or it will be hard to finish them on time.

The course covers some of the most elementary and fundamental concepts in quantum programming, which I personally found quite notation-heavy and generally inaccessible to an outsider when I first explored it on my own. The class does much to break down the layers of notation and start at first principles, which I greatly appreciate.

On the other hand, I wish there were more discussions about how can we learn more about quantum computing on our own. I found that there is still a gap between what’s covered in the course and the literature, which often makes heavy use of terms from physics. I think a component dedicated to reading recent literature would be quite useful, especially for a graduate-level course like this one.

Additionally, I think it would be a very real boon to the CS instruction at UCLA if the course is offered as cross-listed for both undergraduate and graduate students. The course material is, and from what I can tell is designed to be, quite accessible to undergraduates. But the enrollment process was a bit nerve-inducing for myself, an undergrad.

This class is very different than most UCLA CS classes, focused almost entirely on the projects, each of which walk you through the process of converting a Java program to Risc V (assembly). Honestly, it's pretty amazing that we were able to do such a project in just 10 weeks.

The weightage of the class is hence reflected, with : Homework 1: 5%. Homework 2: 15%. Homework 3: 15%. Homework 4: 15%. Homework 5: 10%. Quizzes: 10%. Midterm: 10%. Final: 20%.

In terms of exams, the midterm exam is very easy (you learn all the material in like 45 min over 1 lecture, and there is a website to practice on); basically free 100%. The final exam is harder, and our final on CCLE had many ambiguous questions, but some of the questions he already had the answers in his quizzes every week that he gives (more on this later). I got a 90% and I feel like the average was lower -- so I definitely wouldn't say the final is easy, but it isn't weighted very much.

In terms of lectures, the first 5 weeks of lectures (lectures 1.1 - 5.2) are all related to the projects; hence, by week 6, you can finish all the projects/homeworks (I'll use these synonymously), even the one due Sunday after Week 10 ends. The lectures are engaging and generally helpful for plotting an initial approach to the projects. However, only a few are completely essential (for example, the register allocation one, or lecture 5.2); the discussions are much more helpful when tackling the projects (more on this later). This delay between homeworks and projects also meant (at least for me) that I never watched lecture until it was actually relevant to the project. So during week 10, I watched lec 5.2 for the first time, since that's the first time it was relevant.

The first 5 weeks of lectures have no quizzes, but for the next 5 weeks, most of the lectures have quizzes, since they are not relevant to the projects. tbh i didn't watch any of these lectures since I was too busy working on the projects, and the quizzes are unlimited attempts, so I just brute forced all the quizzes until i got a 100%. i guess if you're interested in how compilers deal with generics / lambda expressions and other stuff, you can watch them, but i was too overwhelemed to do that.

Now, in terms of the projects. These projects, in my opinion, are the *hardest* projects in UCLA CS for me, but this is mostly because I'm a procrastinator. Homework 1 was fairly easy, just watch the lectures and ask on Piazza for help. Then, you are given 3 weeks for Homework 2, 2 and half weeks for HW 3, 2 weeks for HW 4, and 1 week (later extended to 8 days) for HW 5. However, I basically started all the projects a max of 5 days before the due date, which made them extremely difficult.

For the projects, I found the professor's lectures to be an okay starting guide, but the TA discussions (particularly Akshay) were really where I learned the most. The projects are extremely long and the implementation is very left up to the student. This means that design decisions you make starting the project, really affect your code a few days later when trying to solve a related problem -- this also means that I'm sure everyone's code looks vastly different. This also means that github is impossible in this class, so don't go into this class expecting that you can cheat when you are running late (some people do this in CS 131); you'll instantly be caught, since there's no way you consistently made the exact same design patterns over ~1000 lines of code. In my opinion, this is a really good thing, since no cheating, and project averages were fair; however, keep this in mind since there is no late policy as well!

Homework 2 is a difficult homework, on par with CS 131 HW 2. Took me like 4 days straight (16 hrs + / day) of working on it to finish, but I think I just work slow. Homework 3 is insanely difficult, in my opinion much harder than CS 131 HW 2; took me ~1 week of straight grinding , and I only got 85%. Homework 4 is not easy, but way way easier than HW2 and HW3. HW5 is not trivial but compared to the other hws it basically is.

However, this class isn't filled with geniuses (which it seems to be when people are working on HW 5 like 6 weeks before it is due); the averages were ~85-90 for most of the hard projects. This leads to grading, where I'm not sure where Palsberg sets the curve, but I think it's fairly generous, like ~92/93.

These scores led to an A for me: HW1 100%, HW2 95%, HW3 85%, HW4 100%, HW5 100%, quizzes 100%, midterm 100%, final 90%. The real issue to not getting an A in this class would be HW2 and HW3; if you miss the deadline, you'll get an automatic 0, so start early for them!!

All in all, this class is really good if you want to improve your Java skills (that's the reason I took it); you write close to 4000 lines of code in Java. I also feel like this class focuses a lot on certain algorithms / data structures needed for compilation, which I found actually pretty interesting; CS33 was my least fav class at UCLA, but I actually really enjoyed CS 132 since a lot of the nitty gritty work is abstracted out. So if you don't like CS33, you could still like this class! So, I would recommend this class if you want to learn about compilation, build one yourself, and improve your Java; however, keep in mind the workload is very difficult, on par with CS131, and basically any other CS GE is an "easier A". Palsberg is definitely an amazing lecturer and the Piazza / TAs are very active, so there are plenty of resources to succeed in this class; if you don't, the only person to blame is yourself.

CS 132 is the BEST class at UCLA! Much of my comments are repeated in other reviews of the class so I'll just reiterate what I think is the most important. Prof. Palsberg is a really good lecturer who provides clear examples that tie well with the homework and exams. The TA's for this quarter Shuyang and William were amazing and extremely helpful. All of the discussions were extremely helpful as they provided in depth guidance for how to tackle the homeworks. The compilers project is my favorite project I have ever done at UCLA! There is great support with the TAs providing tons of in-depth hints for how to complete the homeworks and direct explanations for the main ideas in lecture (Prof. Palsberg finishes the content needed to tackle the homework by week 6 so there is a lot of time to digest the lecture content, work on the homework, and ask for help). The homeworks takes a REALLY long time (I think I spent 3 days just debugging homework 3). In terms of difficulty, HW 1 & 5 are agreed to be the easiest and then HW 2-4 are considered more challenging (HW 3 definitely is the most challenging by amount of code needing to write and HW 4 is the most challenging conceptually. HW 2 you are introduced to the software design pattern of the visitor for the first time on top of type checking rules which may be challenging as the first serious homework). I think many students consider looking up the answers to homeworks in some other classes on GitHub but what is really phenomenal about this class is that its not really possible to do that but also you don't really need to. The project is design so that you need to make a lot of design decisions and its not really possible to make the same identical design decisions across 5000+ lines of code for the entire class. Also, the TAs + Prof. Palsberg are extremely helpful at providing hints and assistance for the homeworks and also teach the strategies needed to tackle the homework very clearly. Some of the homeworks (particularly HW 4) just require some creativity in order to figure out some of the test cases but the ideas are introduced in lecture / discussion. The exams were pretty easy. Midterm had a median of 100%. Provides a lot of good practice problems so its very reasonable. Quizzes were multiple choice, online, and you had unlimited submissions so almost everyone got a 100% on these. The final ended up being a bit tricky but also multiple choice. The average on the final ended up being 82% so still really reasonable for a computer science class. Really wish another compilers class would be offered by Prof. Palsberg. I would take it in a heartbeat.

workload-wise I think it's more than 111 and less than 131. do not underestimate the homeworks. they are very involved, though I wouldn't say the concepts themselves are difficult. discussion and office hours are helpful.

tests are very easy if you know how to do the homework. the professor is nice. overall it's a good class if you have some interest in compilers.