Super helpful slides & clear lectures. I would definitely take this professor again for other PIC series. The workload is very manageable. For each week, there are two or three small projects to work on. The description of projects is often within two pages (which is super easy compared to CS31). The last two homework are more difficult than the previous ones, but you can drop the lowest grade of all 8 homework, so you can simply skip one of them.
Chu cares a lot about her students. For EVERY class she would answer almost every question in chat box. Even when I fail to articulate my questions, she can know what I'm confused about. This makes me think that Chu is very clear about the material. I saw some comments about Chu's accent but her accent doesn't bother me.

Overall assessment (please read my full review if you have time though!):
PIC 10A is known to be a class that requires a lot of work and time, and I agree, it is. But Professor Chu made it manageable, and more than that, she made it interesting. I had no prior programming experience, and I thought with the amount of information this class covered in 10 weeks, I'd struggle just to semi-understand stuff. Professor Chu didn't make the class any less extensive, but her impeccable organization of material, her helpfulness, and her calm nature throughout the 10 weeks made me not only understand the material but actually enjoy programming. For a course like PIC 10A, I strongly recommend that you take Professor Chu: if you fully utilize her resources, and give due respect and diligence to her lectures and discussion sections, trust me, this class under Professor Chu will be extremely worth your while.

Grading Scheme:
Her grading scheme seemed very fair to me. The highest of the two is selected. Quick breakdown:
Class mostly in-person:
Scheme 1: 50% Homework, 13% Midterm, 36% Final, Participation 1%
Scheme 2: 50% Homework, 0% Midterm, 49% Final, Participation 1%
Class mostly online:
Scheme 1: 70% Homework, 9% Midterm, 20% Final, Participation 1%
Scheme 2: 70% Homework, 0% Midterm, 29% Final, Participation 1%

As you can see, homework is weighted very heavily in either grade scheme. There are a total of 8 Homeworks, one for each week from Weeks 2-9, and released the week before and due at the Friday at the end of the week. One Homework score gets dropped. Each homework is graded out of 100, and points are deducted for test cases your code does not compile for.
This quarter, we followed the online schemes, and so we had a 24 hour Midterm and Final (actually she pushed the deadline for both so it was really a 28 hour Midterm and Final). Both the midterm and final are formatted similarly, with a combination of correct-the-code, write-your-own-code-with-a-given-set-of-instructions, and explain-the-concepts-behind-the-code-questions. Both exams were open book, and you could use the textbook, compilers, lecture recordings and notes, and standard internet sources.
Although I never had an in-person exam, she did mention that her in-person exams are closed book and need to be written by hand (meaning syntax needs to be memorized too!), but that they would be easier than the online ones.
Lastly, participation credit is just filling out the evaluation surveys at the end of the quarter. Neither lectures nor discussions record attendance.

Personal Analysis:
The Homeworks (dare I say it) were honestly pretty fun! They were hard too later on, don't get me wrong. But we had a whole week to solve it, and on average writing the full code took me around 5 hours (sometimes more, sometimes less). The specifics for the homework are very clear, and you can always go to your TA or the Professor if you're confused about anything. Writing a clean code was not very hard, and so getting a 100 on the homework assignments was usually a given. Homework is weighted so heavily that you'd think it'd be a cause of stress, but most of the time it was a matter of applying what you had learned that week in an original manner, and that wasn't so bad.
But the exams were stiff. The Midterm was designed to take 1-2 hours and the Final to take 3 hours, but I spent like 10 hours on the midterm and 16 on the Final, and most of my friends in this class did too. The questions were not hard, but to test out your code for each case, and comment clearly, and every once in a while having to crack your brain to figure out that one annoying problem whose logic you just can't figure out takes up time. Overall, my summary comment on exams would be that they are doable but time-consuming, so plan for that if you have the online exams.

Lectures:
Professor Chu was absolutely incredible. I don't know how the other students felt in the class, but personally I never found her accent to be a problem, and got used to it within around 20 minutes of the very first lecture. Lectures are three times a week, for 50 minutes each. She always had a very clear idea of exactly what she needed to cover in class, and she usually delivered. You HAVE to pay attention, or at least go back and watch the recordings if you don't understand the lecture. There is a LOT of information that this course covers, and it can often seem like she's going too fast, especially if you've been slacking off on watching lectures and attending discussion sections. If you are one of those people who can't do the class-every-day thing, at some point or the other, you will find that you're lost. I had never done programming before this class, so believe me when I say, Professor Chu really starts right from the beginning and progresses upwards in a very organized fashion. Early lectures were extremely straightforward and if you have a basic grasp on logic, you'll really enjoy them. Around Week 5-7 (functions, vectors, classes), the logic seems to get more complicated, but I believe it's just because a lot more information is being taught--the logic itself remains as binary as it always is :). So just pay more attention, and put more effort in, and make sure you're confident with each concept before moving onto the next one. It really is like a Domino effect: you don't understand one concept, it's going to be hard to follow the later ones.
I think what many people take for granted here is that participation is not graded. This seems to make people think that attending her lectures at live time is unnecessary. Don't be fooled. This may be true for some lectures, but it's unpredictable to figure out which lectures will be needed for that week's homework (and the midterm and final) and I found it very helpful to ask questions in the middle of lecture and answer her exercise problems while she gives live feedback (she provides ample opportunities for both).
I only attended her Office Hours a few times, but she was always very quick about understanding my doubts, and made sure that I fully understood the concept. Her office hours were only for an hour a week, but with my TA's office hours there for homework questions, the time was enough for me to ask my conceptual doubts.

Discussion Sections:
Discussion sections were twice a week for 50 minutes each, and before you freak out when you realize that that means you have class EVERY SINGLE DAY, trust me, don't skimp on discussion when you need a break. They're twice a week for a reason: the material needs to be recapped that often.
I am so, so glad I had a brilliant TA for this class. Apart from being an overall great person, Rakshith organized his discussion sections to utilize his time super effectively. I don't know if this is standard across discussion sections, but for the first 20 minutes we'd go over lecture material and focus especially on hard-to-understand concepts, and for the next 30 minutes solve example problems which would clarify nuances in coding and help in homework. Discussion sections really, really, really helped me in my homework and exams: they can be pretty engaging, and I'm betting they'll really help you too.

Good luck to whoever's taking this class! Remember, programming is a useful skill to have in the future. Especially with Professor Chu, (as long as you put in the effort and organize your time well!) you will definitely not regret taking PIC 10A.

**COVID-19 Review**
--
Grading: The higher of the 2 schemes
Scheme 1: Homework 70%, Midterm 9%, Final 20%, Participation 1%
Scheme 2: Homework 70%, Midterm 0%, Final 29%, Participation 1%
--
This class is called "Introduction to Programming" but it feels rather fast for an introductory course. Some of the earliest reviews describe it as being ridiculously easy, but I think the class has definitely changed since then. There's so much content to be covered in only 10 weeks and it can become confusing rather quickly. While I was able to keep up at the beginning, I got lost sometime around the chapter on classes and continued to feel unconfident for the rest of the quarter. Personally, I had minimal programming experience before this class so that could probably play a factor and if you have more experience it may be easier for you, but it seems most of the other people with minimal programming experience prior to this class agreed with me. That said, I think Professor Chu did try to make the content as clear as possible. Her lectures were slow and tried to break down the concepts, and she answered questions the best she could over email and in office hours. However, this class was still challenging regardless. Don't slack off if you care about your grade
--
There are 8 weekly homework due on Wednesday evenings. The homework assignments are the biggest part of your grade, which is nice that you can stress less on the exams. That said, some of the homework assignments were rather challenging, moreso than the examples we went over in lecture, so be wary and do not procrastinate if you can help it. The first few were fine, but from the fourth one on, I had to spend several hours just to get my code to run. I think talking through these with peers is helpful, but sharing code is considered plagiarism so be aware of that. Also, I've heard she was pretty helpful with homework questions during office hours, but I had a lot of time conflicts with office hours so I couldn't go much. Definitely make sure you put a good amount of time and effort into your homework, especially because it's worth so much of your grade. It took up a lot of my time, but I knew they were worth a lot so I worked a lot on these assignments and talked it out with classmates and managed A's on all my homework assignments. Also the lowest 2 are dropped, so that's nice and provides some flexibility.
--
Exams were the worst part of this class IMO because they were very challenging, not very reflective of the lecture material. They consist of multiple choice and true false questions, and free response self-code questions. The questions were often in much more conceptual depth than anything we'd encountered previously, and they were rarely straightforward enough for even an open-book policy to help with taking the exam in any way. We were given a 24 hour period to complete the exams due to covid, but the midterm and final were supposedly designed to be completed in 1 and 3 hours respectively. This did not feel truthful at all to me, perhaps maybe for someone who was already an expert on the class material, it could have been true. The exams are probably the main reason I personally received a B in the class. With 24 hour exams, you should expect to spend the majority of your time that day on the exam if you are not an experienced programmer.
--
Participation was very easy, simply complete the course evaluation on myUCLA. All in all, I think Chu tried to structure the class in such a way that it was fair. I think she has a decent lecturing style and the grading scheme emphasizing homework tries to even the playing field nicely. That said, this course does not exactly feel beginner-friendly and you will have to work extremely hard for your grade in this class. If you have no prior experience, be prepared to fight for your grade.

I came into this class looking at the ratings from the last group who took her (spring 2020). I guess she up-ed her standards because this class was definately DIFFICULT. The homeworks were alright if you spent some time on them, but the midterm and the final was HARD. I had no programming experience before so this might be a different experience for those who are snazzy with the computer but both the midterm and the final took me over 8 hours to complete. The questions really make you think and I heard that the grades for both the midterm and the final were normally distributed--so don't trust the mostly "A" distribution on bruinwalk!! Overall, this class was rewarding and it really tells you whether you enjoy programming or not and the professor was very down-to-earth with her lectures. Just be careful on the mid term and finals because they will definately make you think! I slacked off a bit on the finals and only got a 75% or else I would have had an A in the class.

If you don't have any prior knowledge of coding DO NOT take this class with this teacher. Her accent makes it difficult to understand her at more than 1X speed but she speaks so slowly otherwise. Above all her homework starts off ok but throughout the quarter get extremely difficult. difficulty exceeding the knowledge of students in an INTRO to programming class. There are other teachers that are way better so do yourself a favor and pick someone else.

As far as coding classes go, I actually didn't think this one was too bad. Chu attacks the material in a methodically logical manner and the homeworks supplement the material but don't actually take very long (usually 30 minutes to an hour). Studying for this class was also not overbearing because the tests were fair. The only complaint I have is that the slides can sometimes be a little bit messy - its hard to tell what is an example and what is theory - but otherwise this was a perfectly reasonable class.

Tests were a little tough, but also I retook this class after already DRUDGING through the extreme standards of Lindstrom, so all of the assignments were easy asf. Prof was lax and tests were just normal hard cs tests

This class was crazy hard. At first, it fine and generally understandable, but then halfway through the course I just could not understand Prof. Chu. The class is incredibly fast-paced and cumulative, so if you don't understand one topic, you will most definitely struggle. Start your homework EARLY and make sure to have good TAs! These assignments took up at least 3 days for me and I had get so much help from my TA. As for the midterm and final, I did horribly. But, they were generously curved and graded very leniently, which was so nice. As a beginner, this class was terrible, but if you have some experience in coding like one of my friends did, it will be a breeze.

Professor Chu is very kind and cares for her students. She makes sure to answer all questions the students have and the homework is doable, though it gets extremely difficult near the end of the quarter. Students are given a week to finish the homework, so it's best to start a couple days before it is due. Though the professor is fine at explaining, the slides have minimal information or explanation on them so it's important to go to lecture. It's best to annotate the notes to get the best understanding. For me, personally, learning C++ was difficult and it was my first time. I did okay on the homeworks but the exams got me. The exams were difficult and all free-response and coding on paper. She curved the midterm (close to 30% more) but I believe she did not curve the final. The course was okay if you put in the work and Professor Chu is a kind person, but the exams were too hard even after studying for a week for the final.

This class was incredibly difficult for an intro class. As someone who had no prior programming experience, I struggled every single day. That being said, Professor Chu cares about her students a lot and is very kind and understanding. She was extremely accommodating when I reached out to her for help. While she may seem intimidating at first, if you struggle in this class I would definitely suggest reaching out to her sooner than later (I definitely wish I had).