TL;DR: This class is the most awful CS class I've taken at UCLA, and I've already taken all the required courses. Homeworks were so bad that the TAs couldn't even handle the workload of grading in Winter 2021.

On paper, this should be one of the most useful classes in the CS curriculum. If you work as a software engineer, it's expected to have to work with different technologies and programming languages. It's useful to know the general programming paradigms because languages might change in the future. However, in reality, this class was the biggest clusterfuck of the UCLA CS department I've yet to experience.

- As expected with Eggert projects, specs are often unclear and leave you longing for the 20-page Smallberg specs of CS 31/32. Any questions you have should be answered by the TAs, but they were not active at all on Piazza. There was only one TA (bless Boyan) who was semi-frequently active to answer questions, but there were still entire weeks when questions on Piazza went without an instructor answer.

- There's a super useful CS 131 assignment repo (made by a previous TA) with amazing hints and boilerplate code, but for some reason the current TAs no longer support it? It had sanity checks that are super useful when working with a brand new language, but our TAs wouldn't answer questions about it, or provide any alternatives.

- Grading in this class is so fucked. I spent an entire week neglecting other classes and used multiple late days to finish the Scheme homework assignment, but the instructors just gave everyone arbitrary scores about 90. Yeah, this sounds great, but the class is curved, so it just fucks over the students who actually did the work. I'm convinced that the homeworks were so ridiculous that the TAs used a random number generator because they couldn't figure out grading. I had friends who turned in code that couldn't pass half of the provided test cases, used multiple late days, and got a 100.

- Homework breakdowns:
HW 1: OCaml. Pretty easy stuff, mostly teaching OCaml syntax.
HW 2: OCaml. Much harder than HW 1, but a surprisingly useful project in understanding how grammars and parsers work.
HW 3: Java. Super easy thread stuff, most of your time is spent writing a report that the TAs probably don't read.
HW 4: Prolog. Prolog is a weird language, but this project is pretty easy and a good tutorial on logic programming. Still, Prolog is a useless fucking language that nobody in the 21st century uses.
HW 5: Scheme. LMAO this hw was ridiculous. I'm sure it's useful in some AI/ML/symbolic programming contexts, but the language is so ridiculously hard to read and debug for beginners. This HW in my opinion is the hardest, but don't worry if you don't do it, it probably won't get graded anyways lol.
HW 6: Probably changes every year, but usually it's to evaluate some new language and talk about advantages/disadvantages. Not much practical use, but the skills of identifying pros and cons of languages is probably useful. Doubt the TAs read the report.
Project: Not too hard because it's done in Python, but the specs were unclear and TAs decided to take this week off on Piazza lmaooo

- Somehow, in this quarter, exams were the most fair part of this class. They were still Eggert exams, so strange conceptual stuff, but surprisingly good at measuring how much of the course you understood. I'd recommend reviewing homework assignments and previous exams to prepare for this.

Like other comments stated here, this course is a pain in the ass even though the content is useful. It's disorganized. The workload is so heavy that few materials can be covered during the lab. So, you have to study most of the content by yourself. The final has 26 pages and Prof. Eggert claims it's a 3-hour exam. Some TAs are very harsh on grading, and they take a lot of points off just because you are wrong in one question or you don't include something that is not even asked for in the assignment instructions. Many TAs don't even provide any feedback for your grade unless you ask for it. If you have to take this course, I would recommend you start to study the content, such as python and bash, before the quarter you are gonna take the course. One more thing, some people may be smart enough to be a very good graduate student, but they may not be competent to be a TA, and this is a TA based course. So, be cautious.

This class was a complete mess in Winter 2021. There was only one TA who seemed to care- thank you Boyan Ding.

The workload was so high that the TAs could not keep up with grading and gave arbitrary scores to everyone on HW5 and HW6. For example, I turned in HW5 6 days late (-32 penalty) but got a 100.

If Eggert cares about most of the students learning, rather than only the top 5 or 10% of the class learning, he should make the workload lighter by removing a HW or two, or at the very least simplifying HW2 and HW5.

Anyone who had the unfortunate opportunity to take CS 33 with Eggert will find that CS 131 with him is easier.

But not that easy.

This class crams a ton of programming languages into 10 weeks and expects you to learn them as if you only had this one class for the quarter. Be prepared to slam your head against the wall while doing Homework 2 (the hardest one by far) and spend a lot of hours dissecting the textbook (it's helpful, but dense) to actually learn the material.

For lectures, Eggert invites you to his two-hour TedTalks twice a week. He's a great lecturer if you just wanted to sit in on his history lessons and hear his opinions on language semantics or something. But if you actually want to learn to pass the class, please go to your TAs.

Assignments take forever, but Eggert has that incredibly generous late policy, so make sure to take advantage of it. TAs are a godsend in this class (shoutout to Patricia for spending a whole night writing test scripts for the Python project during Thanksgiving break! <3). Anyways, go to office hours and ask questions on Piazza. Your grade depends on it if you aren't a natural CS whiz.

Exams are hard. Seriously, the average for the midterm was like 45%. And the final will probably be in that range too. There's no way to truly study for Eggert exams. But it's an even playing field because almost everyone is just as confused! Eggert knows people are always lost in his class. He grades on knowledge, but he rewards INTUITION. No matter how wrong your answer may be, if you can back it up with any kind of evidence, you will get partial points. Pro-tip: Eggert's favorite questions in this class are language implementations and optimization languages. Is X language better than Y language for Z task? Is it feasible to implement X's function in Y to do Z?

Lastly, do yourself a favor and do NOT take this class with CS 111. You will die. Literally. I took this course in a four-class quarter and it was not fun to say the least. But everything will be all right. Getting through Eggert is like a rite of passage. You can't call yourself a true CS major without getting Egged after all.

I'm hesitant to post a review for this class because you really don't have a choice on who to take it with since Eggert is the only professor that has taught it in recent memory.

130 is kind of a crappy class. Not at all difficult, just crappy. Tons of assigned reading and quizzes every class. Eventually you learn to ignore the readings and just fake it on the quizzes since they aren't worth much of your grade. The project is worth 40% of your grade, and with our client it was pretty easy (definitely doable in a hackathon context, so not overly time consuming considering you have 5-7 people on the team). The Midterm and Final are open book and open notes, but if you take notes on this class you will probably want to kill yourself, and you are already ignoring the reading assignments, so your best bet is to get someone to make a copy of their class notes for you and borrow some poor sucker's copy of the books (or use your free/cheap printing to print the PDFs that are easy to find with a google search).

At the first lecture the class is billed as one of the most useful classes you will take. I'll let you decide for yourself, but I don't believe it.

I wrote the following when people asked me for my opinion on CS 97 vs 35L. So this may not be a pure review per se but more like a comparison with 35L.

Disclaimer: I am someone who came into UCLA with a healthy amount of programming experience in C/C++ and some experience working with the Linux/Unix terminal. That said I had little to no experience with high-level scripting languages like Python or building web apps using JavaScript/node etc. I took CS 97 as an online class during Spring 2020 because of the COVID-19 pandemic so can say more about that but I will try to compare it with 35L as best I can. I may have missed some (or many) points here. Consult academic counselors/other students for more opinions.

First, some similarities between the classes and some advice for them:

1. Eggert is in charge. He writes the assignments and exams. Exams are typical Eggert exams - brutal with low averages. More on this later.
2. They are intended to teach you practical skills for software development - comfort with the Linux terminal, version control (git), scripting, etc.
3. TAs/LAs are your saviors. All of them were AMAZING this quarter. It is in your best interest to seek their help as soon and as often as possible.
4. There is the generous late policy of 2^(n-1) points deducted for n days late (iirc)
5. Exams are open book, open note and if taking online, open computer.
6. You are largely on your own for learning stuff outside the syllabus which, bear in mind, WILL be required for assignments/projects(CS 97) - this is a radical departure from CS 31-33 where you are taught everything and guided almost entirely (if you need it) for all assignments/homework. Not here - time to wake up and smell the coffee. These classes will significantly improve your ability to learn independently. Google and Linux man pages are your best friends.

Here are the MINOR differences between the 2 classes:

1. 35L is a 3 unit course, 97 is a 4 unit course (you must take it for 4 units if you want to apply credit towards 35L)
2. 35L is requires 4 hours of lab every week, 97 is a full course requiring 6 hours per week - 4 hours of lecture + 2 hours of discussion (the 2 extra hours may be a major difference for some people)

Here are the MAJOR differences:

Grading: 35L has 10 programming/homework assignments each weighted 5% (total 50%) and a final exam worth 50%.
97 has 4 programming/homework assignments which count for 5% total, 2 midterms worth 10% each, a final worth 23% and a project worth 50%. The remaining grade is made up of stuff like LA feedback surveys, class evaluation, etc.

Lectures: 35L is entirely TA-led. For 97, Eggert delivers 4 hours of lecture every week on various topics. More on this below.

Project: 97 has a project requirement (the name of the course is Software Construction Projects) whereas 35L does not . This project is half of your course grade and a major reason this class was introduced in the first place. We had to make something with a client-server architecture and almost everyone opted to build web/mobile apps with node/React. There were groups of 2,3,4 and even 5 people.

Now I will share my opinion on CS 97:

*Pros:*

Lectures: Gotta give credit where credit is due. Eggert is a LEGEND. As a lecturer, he is simply brilliant. Lectures mostly cover shell commands, file systems, Emacs, git, Python, client-server theory, C programming and debugging, etc. along with the history and philosophy of how these techniques came into play. Keep in mind I am someone who is usually irregular with attending lectures but I made it a point to watch and absorb every Eggert lecture and felt it was worth it. In my opinion, this is a major advantage of 97 over 35L which is known to be a broken class for lacking a teaching component like this.

Project: Even though I did not enjoy it too much personally, I’m sure I’m an exception here. The project experience was a huge plus for most people. A lot of people made a lot of awesome stuff. A good learning experience on how to build a large piece of software (much larger than CS 32 Project 3), web development, collaboration with team members, using git/GitHub and solving problems. Also, it’s relatively straightforward to score points so you can secure 50% of your grade if you don’t mess up simple instructions. You also get something to put on your resumé.

Assignments are worth less: I think 3 of the 4 assignments we had were also in 35L and these assignments can be hard. Fortunately, they aren’t worth much in 97 so you need not stress over them. Caveat: a good chunk (say around 30%) of exam questions were rooted in the assignments. So doing them can help you after all. But knowing how to do them may be sufficient for exams instead of stressing over meeting a deadline.

Variety of topics covered: The assignments and project requirements introduce you to a wider variety of material than 35L. Last time I checked, topics like client-server theory, JavaScript, HTML/CSS, React are not covered in 35L but I may be wrong.

*Cons:*

Exams: 97 has two more exams than 35L. Eggert exams are some of the most stressful ones in our CS curriculum. The exams are based largely on the lectures and assignments so you can sort of prepare for them and in an online quarter, the exams are open computer but a midterm is a midterm and I’d rather not have one than have one. But then these exams are what allow them to weigh the assignments at only 5%; also, if you somehow manage to do well (read: better than most other people) on them, you’re almost guaranteed an A since most people get identical grades for the other components. So I guess with exams, it goes both ways. I also feel the exams were fair - they related to the lectures/assignments and covered the objective of the course as a whole.

Assignments: The lectures DO NOT help with the assignments. We covered topics needed for assignments in lecture after the assignment was due. Assignments can put you in a tricky situation. They are medium-long time consuming and worth 0.75% or 1% max. So you may decide to skip them but then the thought of losing those points may linger in your head. Also, as mentioned above, doing the assignments is helpful for exams, so spending those hours may be worth it. YMMV.

Preparation for Upper Divs: I am only speaking from my experience of taking CS 111 so far, this may not be true. Almost all of 35L’s assignments are text editors, Python, C programming, scripting and debugging. This is not the case with CS 97 which covers those topics but not at the same level of depth. Problem is, mastering these techniques is essential for success in upper divs. For example, I struggled much more with Project 0 of CS 111 than I would have had I taken 35L. This point is open to discussion though, someone with more upper div experience could comment better.

Workload: Looking at the course websites, the workload for CS 97 seems heavier than 35L but since I haven’t taken 35L, I cannot comment on this accurately.

TL;DR / Overall Verdict:
Go for CS 97 if you like awesome lectures on CS and really want the project experience. The lectures and project will most likely serve you well in the long run. Also, if you are good at taking exams and have good intuition for things, it might be easier for you to get an A since you can use your intuition to convince the graders.
On the other hand, take CS 35L if you are someone who loves C programming, the Linux terminal, systems programming and someone who lives and dies by the command line. It will prepare you better for upper division classes (CS 111 at least) and help you master command-line tools better.
If I could go back and make a choice again, I would pick 35L since I fall in the latter category and didn’t enjoy web development a lot. I liked CS 97 though, it wasn’t boring or bad in any sense and I ended up learning a lot. But that is just a personal take. Hope this helps.

Eggert is Eggert, just pray for not getting egged on the exams.

Lectures always come after assignments so be sure to start googling early! Never wait for the lectures. The lectures are helpful in the sense that they contain a lot of information, but never count on it to help you with any of your assignments. Be sure to find a better discussion session, especially the ones that guides you through assignments. Getting 100 on each assignment is doable but not neccessary since they worth little.

There is a group project to build a full-stack webapp (start early!!!). As long as your app covered the features in the spec and looks beautiful and that your personal contribution (tracked via git history) and report show enough effort you will get full score.

Since this is still an experimental lecture, some important stuff got left out by the end of the quarter, I think professor Eggert will try to fix that next time.

Difficulty levels
Assignment1: Easy
Assignment2: Medium
Assingment3: Easy/Medium
Assignmrnt4: Easy
Assignment5: Hard
Assignment6: Hard
Midterm: Eggert
Final: Eggggggggert (not typo)
Project: medium to hard (your choice)

The popular opinion for this course is that the projects are way too hard and take way too long. For most people, that does carry quite a bit of truth. However, just saying that would make this review sound exactly like the ten preceding this one, so I'll try to do better.

I would qualify the difficulty in the projects, as not that they themselves are difficult, but rather they require quite a lot of knowledge and maturity in programming in C – something that the previous Computer Science classes do not prepare the students well for. Having done the projects myself and helped numerous others, I'd say the two major pillars that people were not as prepared for were:

- reading documentation (“man pages”): ability to skip the boilerplate and get to what you are actually looking for; finding and adapting example code

- understanding and applying memory allocation: fixed-size arrays vs. malloc(); pointers, lifetime, and ownership. Most people understand what they are and how they are different, but applying that knowledge correctly could be a different challenge.

If you are or become comfortable with these things, the projects will be quite doable.

On the other hand, the exams had a different focus. I hate to use the overused word, but they force you to think critically and provide a reasoned answer backed up with facts and experience. For dreamers and debaters, it was heaven. For the rest of us, it was a first taste at what software engineering is all about: a whole lotta dreaming and debating. (Oh, feel free to replace “dream” with “BS.”)

But where do you get the facts and the experience? The former you get by following textbook readings, which are unfortunately very heavy, as well as by listening and processing Professor Eggert's excellent lectures. The latter you get by stumbling and reflecting while doing the projects.

Of course, many online resources exist for help in the projects. However, a word of caution if you do decide to go down that route: most folks on GitHub who post their solutions were just as clueless as you are when they did it. Thus there is great variance in the the quality of said resources.

But if you do end up finding resources of high quality, make sure to maximize your learning by carefully reading and understanding why they did something but not something else: because there’s an actual reason, or because they just felt like it? How did they think of something that you didn't? Reflect, and you’d become a much better Computer Scientist or Software Engineer for it.

Probably said too much already, so I'll stop. In any case, good luck, and hope you enjoy the class!

WORST OF ALL TIME

I'm prepared for heavy assignments and difficult tests on things he barely lectured in class. However, what I want to tell people right now is his unreasonable, mysterious curve and final grading strategy. The final grading is messy, with some people curved down but some not, just because he thought we would take benefits from generous graders in assignments. He didn't even tell which portion of the class was curved down and how, nor did he seem to consider that some answers might just be good enough to receive a full grade from any grader. It has NO transparency at all. You never know if you would be mysteriously curved down at the deadline of final grade submission day, and you can do nothing about it (since he will also not expose how he did it). I got full grades for every assignment, but if I knew those grades does not reflect anything, I would consider P/NP instead of getting this shitty grade that ruins my GPA (never got a B before).

In a nutshell, he is not the type of professor we usually met that gives you a hard time during the quarter but curve up at the end to make students learn. He is the devil that gives people a hard time till the moment you get your final grade. I don't know how curving down without clear explanation benefits learning, and he might not care.

Haven't gotten grades yet but this class was just awful.