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.

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

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.

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.

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.

Projects are lots of work. Also, testcases are not comprehensive, so you may spend a lot of times discovering bugs, fixing them, and then realizing it did not affect your score at all. But with the autograder and easy tests, the class was pretty good. Just... don't schedule any other project-heavy classes alongside it.

CS132 is one of my favorite classes taken at UCLA. I originally was hesitant to take the class since the projects seemed daunting, but the deadlines are quite reasonable and the TAs help flesh out projects in great detail.

Just as a warning though, this class is not an easy A. The distribution is pretty good in this class because the bulk of the grade is from projects, which are automatically graded on the grading server with no penalties for multiple submissions. This is great since it lets you finish a project knowing that you have or are close enough to a perfect score, but also means you have to be willing to start early so you allot yourself enough time to debug. Debugging is what takes the most time, at least for me, and I would say is around 60%-70% of the total time. Hw1 and Hw5 were quite easy (maybe 3-5 hours), but Hw2-4 took upwards of 12 hours each. Definitely go to discussion, since TAs take higher level ideas from Palsberg and break them down into implementation that really help modulate what you need to do. Exams in this class are very fair, and just require working knowledge of what was taught in lectures.

Also, the review from 2010 is understandably outdated; you do not need any prior knowledge (in my opinion) to succeed in this class. Palsberg goes over everything you need to know when introducing a topic (PDAs, visitor pattern, etc.).

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.

Professor Palsberg is the GOAT. He's an excellent lecturer, to the point, and knows the subject material better than he knows the back of his hand. The workload is heavy for this class, but the actual subject material isn't bad at all. Furthermore, the midterm and final weren't difficult, and quizzes basically had unlimited attempts with the maximum score being taken.

The projects are long, but they're honestly interesting and you get unlimited submissions to the grading server, so you know exactly what grade you'd get (as opposed to other CS classes where you get railed by hidden tests after passing the public ones).

Bottom line, Palsberg is the goat and the class material was interesting. 10/10 would take again.

Prof Palsberg is an excellent professor for this class.

The projects are the main course of this class, during the quarter you will progressively be building a compiler for the language Palsberg has designed for the class. Palsberg seems to have put in a large amount of work in making these projects seem interesting and building a programming framework for them, but they will be difficult and time consuming, building a compiler isn't done over a weekend.

Do keep in mind deadlines for these projects are hard deadlines however, in sharp contrast to much of the rest of the CS department. If you are a minute late like I was, you get 0 on a project. The projects aren't horribly difficult but very very time consuming, this combined with this hard deadline is a recipe for disaster.

That said, his grading is nice, he uses an autograder for grading with immediate feedback and unlimited submissions, you can submit, see your score, and tweak your program, and submit again for no penalty.

Unlike other classes, Palsberg times his lectures even better than the rest of the CS department. While professors like Eggert have a habit of assigning complicated homeworks and not lecturing about them until the day before they are due, Palsberg basically finished all the lectures needed to do all 5 projects by week 6 of the quarter, spending the rest of the time discussing various other topics in compilers and optimization.

Prof Palsberg is generally a good lecturer, and adapted well for the 2020 covid season.

Exams are free from my understanding, this seems to be by Palsberg's design as he himself said they were meant as a grade boost due to hard projects. On top of a midterm and a final, there were multiple quizzes on ccle for latter topics in the class, which were multiple choice and had unlimited submission attempts, so you could just try and try again until you passed the quiz. The final had many questions literally copied from the exam and was open note, so if you printed the quizzes for the final as notes you got free points.