Based on 14 User s
Grade distributions are collected using data from the UCLA Registrar’s Office.
Grade distributions are collected using data from the UCLA Registrar’s Office.
Grade distributions are collected using data from the UCLA Registrar’s Office.
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.
Final: Eggggggggert (not typo)
Project: medium to hard (your choice)
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.
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:
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.
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.
Be warned! This class is nothing like other lower-div classes such as CS31 and 32. I aced CS 31-33 but failed miserably in this class. CS97 and probably CS35l require a higher level of ability of self study and conquering problems on your own.
With all due respect, the TAs carry this class. Everything from assignments to assignment hints to the project to exam grading to piazza posts are handled by the TAs. Daniel Meirovitch is the GOAT TA.
Professor only shows up in lectures and during his office hours. Even though he is very knowledgeable about most of the topics, his lectures are disorganized and there is no flow of topics. He jumps from Lisp to HTML to C/gdb abruptly. The lectures provide little to no preparation for the assignments and the project, all the help came from discussion and Daniel's tips videos. And not to mention the fact that all lectures are typed out on Emacs which gets super boring and unintuitive. He isn't on Piazza to answer any student doubts, which is highly irresponsible in my opinion, and takes days to reply to emails.
The midterm and final don't really test you on your understanding of the material but how many (sometimes vague) questions you can write an answer to in the allotted time. It's sad to see that a subject as important as software construction is neglected as badly as this by Eggert.
- Project-based class, so you walk out of this class with a unique project that you can put on your resume. This is a group project though, so experiences will vary.
- The discussions are super helpful for assignments. We also use Piazza.
- Too much content: This class has so many topics crammed into it, yet it constantly feels like we are behind in lectures. In terms of languages, you have to learn Emacs/LISP, Python, JS, and C for the assignments. Depending on your role in the group project, you'll have to learn other technologies as well.
- A lot of work. The first few weeks are pretty manageable, where you get roughly a week to do each assignment. Assignments 1 (Emacs), 2 (Scripting), and 4 (Intro to Git) were pretty manageable since most of the assignment consisted of lab components that the TAs go over in discussion. Assignment 3 (React) was also relatively easy as well. Assignments 5 (C programming) and 6 (Git internals) were super time consuming and required a lot of things to learn by yourself. You also have the project to work on during this time. At least Eggert has a pretty generous late policy.
- Self-learning: Eggert has a "learn by doing" philosophy, so he has no problems assigning homework and teach the concepts behind them after they are due. Thankfully the TAs are pretty helpful when it comes to this. For the project, you were supposed to build a web app using React and Node.js. They were barely taught in class (1 lecture) and you only had 1 assignment that needed to use React. For the project, you said to learn Node.js and database things like SQL by yourself.
- Exams: They are typical Eggert exams. No real way to prepare for them since the questions are always pretty specific. Taking the exams open-computer was super helpful, but I think the students taking it in-person would have a much worse experience.
---Lecture: Eggert's lectures are overall good. He makes them engaging and easy to follow. He does a pretty good job at explaining difficult topics. One critique I have for them is that he goes into depth about topics that are not too relevant.
---Discussion: Discussion sections are vital for doing homework. Eggert barely covers the homework in class, and they are very difficult to do without any guidance. Other than homework help, I did not find the content of discussion to be too useful.
---Professor: Eggert is a genuinely nice person, contradictory to how difficult his course is. He is very easy to approach with questions and does a lot to help.
---Project: You can choose or be placed in a group of 3-5 people. This quarter we were tasked with building a client-server web application. Contrary to regular school projects I recommend you really try on this since it can look great on a resume. Eggert only covers React, so if you want to use any other technology it's up to your team to learn (basically a no-guidance project).
---Assignments: He gave 6 assignments and most of them were pretty hard. If you understand them well, you can do them in a day, but if you don't it can take forever. Most of them are pretty useless in terms of attaining skills or prepping for the exam. The grading on them were extremely lenient. He also has an insanely forgiving late policy where each day you're late is 2^(n-1) points off (1 day: 1 point, 2 days: 2 points, 3 days: 4 points...)
---Exams: Eggert's exams are by far the hardest I've ever taken. I can't stress enough that there's no amount of studying that will fully prepare you.
---Tips: Go to discussion section before starting each assignment. Go to office hours if you're ever stuck on a project; don't waste time struggling through it. Start your project early and make a weekly product road map to ensure you're not cramming it during finals week. I would say study every detail of lecture for exams, but no one has time for that. To maximize points make sure you understand every coding language thoroughly and try to BS you're way through open ended questions. In coding questions if you find yourself writing many many lines of code, you're doing something wrong.
This is definitely a much better version of 35L, you have to do a lot of work, however, the work is super rewarding and you learn a ton. Lectures are super useful comparing with 35L, overall, I think this is a super useful and practical class.
This class was advertised as a replacement for the notorious 35L but we got egged just as hard. The tests? Terrible. The assignments? Worthless. The only thing good about this class was working with some really cool people on a big project. Even though the requirements were obscure and it took many many hours, it was fun to struggle together.
I'm just an average CS student but this man really had me seriously thinking of changing my major and even dropping out. Good thing I stayed thanks to my other CS professors who actually inspired me to learn.
I took CS 97 as a replacement for CS 35L. Considering this was the first time 97 was offered, I acknowledge that there were a lot of gaps in curriculum/planning.
The topics we covered were some basic linux commands, emacs, basic scripting (python/bash), git, client/server-side programming, and a little bit of C.
Homework: There were 4 homework assignments (regex/scripting, Git, React, and Makefiles with C). They only counted for a total of 5% so I only did 3/4 of them. The homework itself took a decent amount of time, but a lot of students (including me) didn't bother with doing them completely since it was worth so little. One of my concerns is that since the hw is worth so little, none of us really cared to learn it thoroughly, and I feel like there could be gaps in our knowledge compared to those that took 35L and had to do 10 assignments.
Lectures & Exams: Eggert is a great lecturer. One of the main reasons why I took 97 over 35L is because there are actual lectures. From my experience, write down EVERY LITTLE THING HE SAYS / TYPES because all the exam content is from his lectures directly. LITERALLY WRITE EVERYTHING DOWN. We had 2 midterms, each 10% of our grade, and a final worth 23%. His exam style is mostly short answer, very little coding, and a lot of explaining/writing for conceptual questions. Since we were online this quarter, he made it open note and open computer (but the test is still insanely hard lol). My biggest tip is to literally write ANYTHING. Don't leave anything blank and the TAs will give you partial credit.
Project: We had a group project worth 50% of our grade. You're free to create any type of app you want. My group chose to make a web app so we had to learn React/Node.js on our own, but luckily some of my team had experience in web development. As long as you created something, the TAs were generous with grading the project. It was stressful in that the guidelines for the project seemed very loose, and there were random project check-in due dates that weren't laid out beforehand. Besides those logistics, it was mostly self-learning.
The remaining 3% came from LA surveys/feedback surveys.
Overall, there is a lot of room for improvement for this course in terms of organization, but I think the group project definitely gives you experience for industry since you have to collaborate with others through Git.