This class is just fine. Too much work for a graduate class and it seems like a lot of the work is busy work. I don't understand the purposes of the quiz and their due dates. There is not enough time and when the concepts are so difficult I feel like i'm being force fed with more work. The Jupyter notebooks for this class need to be completely rewritten. They are quite confusing and with the TA making changes while students are working on the assignment only makes things harder. The notebooks don't really flow very well and they aren't formatted properly making it confusing on what needs to be completed.

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.

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.

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.

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.

Palsberg is a nice person, I just don't really like this class. Homework is a complete pain in the ass.

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.

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.

If you do not take this course with Jens Palsberg, you are missing out. His lectures are super clear and Jens is happy to answer your questions if you ever are in an y confusion. The homework are fun and are of just the perfect length. The midterm is easy too. You also get to work on an actual quantum computer, which is pretty cool. Make sure you also know the expectations for the final project as I felt a lot of points were docked from mine because I did go into a lot of depth.

As for the content of the class, once you are done, you should have a decent idea of the the direction the quantum computing industry is taking and also be able to write quantum programming codes easily.