My advice for getting a good grade in this class:

Tests: To make the tests Eggert will watch recordings of his lectures and randomly pull topics for his tests, on my midterm he put a question on how make files, a topic he had spent all of 5 seconds on in class. This is why this class is almost impossible to study for, the best you can do is look over high level concepts (he really likes to ask what if questions) and if you have the time, rewatch the lectures. While taking the test you might feel discouraged because you don't know the answers, this is because you aren't expected to get many right. Eggert shoots for a 50% average on his tests, which is why I recommend just word vomiting on anything you don't know to try to get partial credit.

Hw: the hws are worth 1-1.5% of your grade each and there are 6 of them, considering how little they're worth you'd think they'd be easy, but they can legit take over 10 hours each. The reason people do them is he likes to put questions from the hw on the test and if you have your hw solution with you its really easy to copy bits and pieces from it to the test and they also teach you the content. However if you something else more pressing, for example the project, its fine to turn them in really late or not at all (I personally didn't do assignment 6 for that reason) as the late policy is really generous and they aren't worth much.

Project: All I can say is try to take this class with people you know, if you get a bad group you're just screwed. Most people spend week 10 grinding nothing but this project, break the cycle, start early.

Final grades: Its a little odd that I have to say this but your raw score isn't very correlated with your final grade if that makes sense? He doesn't have a curve, or even a set amount of A's he wants to give out. To determine your final grade he goes over your work and determines what grade you deserve. Eggert is not afraid to fail an entire class if they don't live up to his expectations. But that won't happen to you ... hopefully.

This class absolutely sucks, but has some silver linings. Here's a review from someone who isn't insanely cracked at programming and doesn't converse in Mandarin:
First: assignments. There are 6 assignments, most of which do not pertain to anything said in lecture, each of which takes a stupid amount of time and is pretty pointless for your grade (worth 1.5% each). Use GitHub + GPT to save your own time and sanity.
Second: The TAs. The negative reviews of the TAs are completely accurate, most TAs for this class are insanely useless, not familiar with the content, or teach you the wrong information that screws you later on the test. I stopped going to discussions as the TA-lead section is almost completely useless and sometimes even negative for your own learning. Also, the TAs constantly screw up grading and misgraded 4 out of my 6 assignments, so be sure to regrade request any possible assignment + midterm. The midterm averages increased by 4% just because of regrades and how incompetent the 35L TAs are.
Third: The tests. I got about a std deviation below the mean of 48% on the midterm, but somehow crushed the final and got in the top 20%. Here is the strategy to do good on a Paul Eggert exam: take notes of everything he mentions in lecture/writes down. GPT/understand all the concepts you are unfamiliar with. The stuff he barely goes over or covers is always tested. Become really familiar with the workings of the assignments, especially shell commands, Linux, and Python. Print all lecture + searched up notes. The small things he mentions in lectures are very similar to test questions, Having all lecture notes printed saved me for the final.
Lastly, some tips. Participate a few times in Piazza for participation points. He covers things really fast during lecture, I preferred to watch the recordings to actually write down what he says. The final project was easily the best part, but be sure to get a good group and start early. The content after the first 4 weeks begins to get slightly more interesting and useful. This class is pretty useful as a whole (besides Emacs Lisp). It's also pretty generously curved: around average on the tests will get you a B, above and below average and between 1 Std dev will get a B-/B+, anything above/below std dev will get you an A/C.

I would argue that this is one of the most important classes for being able to understand software development practically. You learn a good deal of skills that are useful in the software development industry - Git, Linux/CLI, web development, etc. That being said, the class is intense in terms of workload. There are six "lab" assignments going over a variety of topics (Linux/Emacs, Python, Javascript React, Git, C, lower-level Git) that are very loosely related to what is covered during lecture (sometimes the lecture reaches the topic AFTER the assignment is already due), so there is a lot of learning on your own time. You also have a group project involving a full-stack web application, typically using Javascript and React, which is another time sink.

The exams are by far the hardest part of the class though, since Eggert makes his exams with the intention of a 50% average, despite being open-note. A lot of people say there is no way to study for them, but I'd recommend paying attention to the topics and overarching ideas during lecture as he tends to base exam questions on these ideas, though the questions themselves often require you to think beyond those ideas. You can think of his exams as testing your intuition behind certain computer science topics rather than specific, concrete concepts.

Advice:
- Plan out what you're going to create for the group project accordingly and try to learn what you need to on your own time. At the bare minimum, you'll probably need to know Javascript and React. For your backend, if you plan to use a dedicated backend framework it would probably be best to learn ExpressJS and a database (usually MongoDB or mySQL). It would probably be easier to use a backend-as-a-service platform such as Firebase or AWS.
- Find reliable people to group with - groups are usually of five.
- Assignment Difficulty (Easiest to Hardest): Two (Python) < Three (Javascript/React) < Four (Git Basics) < One (Linux) < Five (C) <<< Six (Git Internals)

If you do not have a background in the technologies that are supposed to be taught in this class, you will struggle. However, if you do, Eggert's lectures will teach you a lot about the broader concepts behind them.
Homework is not that bad and were graded fairly generously.
Tests are Eggert Tests so they tend to be pretty tough.
The project required a lot of outside work.

Unclarity. Unclear lectures explaining anything vaguely. Unclear assignment specs that makes you wanna smash the computer. Absolutely ridiculous project that the professor teaches you nothing about, and you have to learn every single bit from online resources.

This is my fourth time taking this class. Yep, you read that correctly: 4 times. To be sure, however, I wouldn't exactly say I really took this class until this past quarter. That is because all previous times, I would get psyched out upon looking at the first assignment, procrastinate, think 'oh this prof has a nice late policy' (2^n points off for n days late), and then boom, the late policy would creep up on me, and I would never get the assignment done.

Which brings me to advice on how I got an A in this class, after 2 withdrawals and an F: Treat this class as your absolute number 1 priority.

This class is extremely tough. With the addition of the project (in which you design a web application), this class is essentially a 'lower-division capstone'. You should not expect Eggert to cover what is needed for each assignment and you especially should not expect him to really cover anything needed for your project. For example, we didn't even really cover Git (which is absolutely essential for the group project) until around week 7 I think. And if you waited until week 7 to start your project, well that just isn't a good idea.

You should start all of the assignments as soon as they're released. Do not wait for Eggert to go over everything needed for it, because he won't. The lectures serve as high-level explanations of software construction, and while he uses the assignment topics as kind of guidelines for him to go over various topics of software construction (i.e. Git for version control), he won't go into specifics. It is up to you (and hopefully the TAs' hints video if they keep doing them) to figure out what the hell to do, probably with a couple of visits to office hours. Eggert is very strong on learn-by-doing.

Another thing to be prepared for are Eggert's exams. They are absolutely terrifying. It is quite possible that you will not really know how to do any of it. That being said, you need to realize that everyone is probably on the same level as you, and so everyone will get around 50% most likely (as that is the score that Eggert aims for, because he 'likes a nice bell curve'). In other words, don't freak out too hard on the exam. Just get as much down as you possibly can.

And finally on the final project: Your group will pretty much be on your own. Finding a group that is around the same skill level as you is most definitely the way to go also, as going with the CS gods who have been coding since the womb will probably just give you some intense imposter syndrome, and you really won't learn anything. Nobody on my team had ever even used any of the languages/technologies we used on our project prior to this course, and we still got a 100 on it. Again, online resources/tutorials are godsend.

Anyways, hope this review helps you all not to make the same mistakes I did 3 times in a row.

(P.S. Emacs > vim)

35L was definitely one of the most unique classes I've taken. Since this class is taught by TAs, everyone's experience seems to be different. Having a good TA is critical to understanding everything in this class, however without any ratings on TAs, it is kind of a wildcard when signing up for the class. Thankfully my TA (Shivam Dalmia) was phenomenal and explained everything thoroughly while also being very helpful with projects. The projects in this class are all over the place with new topics coming up every week. Some projects were extremely tedious like learning Eggert's beloved Emacs in Project 1 and literally logging every single key you press in a text file. Projects varied in difficulty and usefulness overall with most projects just being Eggert flexing some patch he made to Coreutils or another GNU project. Project 9 was new this quarter and took a lot of people by surprise. Overall it wasn't too difficult if you gave it some time, but it seemed kind of pointless dedicating a whole project to digging around the git internals.

The final in this class was interesting to say the least. Eggert (who does not show up until the final) strolled in with a stack of exams that were ridiculously thick (at least twice as long as the practice final that was given out). He prefaced the final by saying that he didn't have time to edit the final which was why it was "a little bit longer than he wanted". This was an understatement. I don't think a single person finished the final and the point distributions of questions were completely off. For example, answering in a few words what a git branch is was equivalent in points to writing an entire Makefile for a C program that you also had to write by hand. If you take this class, be sure to do the easy questions first on the final to maximize your points.

Overall this class was a wild ride, but the material you learn is undoubtedly extremely useful. After 35L, it's amazing how much faster and competently I can work on linux servers and use all of the tools that are provided.

I placed an incomplete as my grade since it has not been officially recorded yet, but I'm probably headed towards an A.

First off there is no professor for the class, only TAs that can help you solve small problems with your code or clear up concepts. The entire class is broken into 10 assignments and a final exam.

Assignments:
For most of the assignments they are "assigned" Monday and due that Friday, giving you roughly one school week to finish them (some exceptions like the shell scripting program that takes 2 weeks). I quickly learned to start the assignments the weekend before so I could space my work out properly. I would say to prepare to dedicate on average 15 hours for each assignment. Most of them are not even long, you just need to do a lot of the research on your own. There were multiple times were I had to scrap everything on Wednesday and restart to finish that Friday. Many people think they get easier further down the class. I think there's definitely hard ones throughout the class(Assignment 8) but you get into a nice groove. Also project 10 is just a presentation and short report, and it's pretty easy.
My advice: Break assignments into small chunks and work a bit everyday, while testing all the time of course. Always play around with your code a little too, it'll help answer some of your own questions.

Final Exam:
Focus on the TA slides and overall concepts for the assignments. Just make sure you get what is important from the slides and study these concepts every so often and you'll do fine.

Overall, this class is like a marathon were you think you are always behind. Just put in your best effort for the assignments and study a bit for the final and you'll do fine :)

He clearly doesn't care about how COVID-19 will affect some of the students. All the family shit, inconvenience or fairness cannot be compared with the joy from torturing students. Dr. Eggert is an extremely caring professor and, I sincerely love this course. I love CS but this class is just disgusting.

Wow. This is the worst class I've taken so far. The skills are all valuable but you are given little to no guidance / explanation and the work load is absolutely ridiculous. I EASILY spend twice as much time on this class as CS 32--the weeder class. Not to mention this class is only worth 3 units. :(