Codebase’s Guide to Berkeley Computer Science

Photo: Creative Commons/ brainchildvn on Flickr

With Phase II rolling around for the upcoming Spring semester for many sophomores and juniors, there’s often a sudden rush among students to determine their plans for next semester, including which classes to take. When looking at the long catalog of classes that Berkeley’s EECS department offers, it sometimes seems daunting to make such a decision: Which classes are light on workload? How many midterms will I have to take? This class sounds cool, but will I need a friend to take it with me for projects? What will I learn in this class, and will it be useful for industry or research?

These are all questions that every student thinks about every semester, when it’s time to choose the next classes to take. We thought it would be helpful to gauge the opinions of our members on the upper division CS classes that they’ve taken, and compile all of that information into a single place so that future students may find it helpful!

Here we go!

Disclaimer: All of the contents of this article are just our own opinions! Different people may have different experiences taking the same classes. These are just the general takeaways that the majority of our members had after taking each class. Also, these are definitely not all the upper division EECS classes offered at Berkeley, just the ones that many of our members have taken before! Overall, since we’re a club focused on software engineering, most of our members end up taking more systems classes as opposed to theoretical and mathematical classes.

CS C100 (Data 100) — Principles and Techniques of Data Science

Class topics:

Data 100 is labeled as an introductory course to the overall field of data science, often taken after Data 8 as the bridge between the lower division courses and other more advanced upper division computer science, data science, and statistics courses.

The course covers a ton of topics, albeit at a pretty surface level, ranging from “question formulation, data collection and cleaning, visualization, statistical inference, predictive modeling, and decision making,” from the course website. More concretely, you’ll learn how to use languages for transforming, querying and analyzing data including pandas and SQL. You’ll also learn how to implement the core algorithms for machine learning including regression, classification and clustering. You’ll also explore the principles behind creating informative data visualizations using libraries such as matplotlib. The latter half of the course is spent learning statistical concepts of measurement error and prediction, and techniques for scalable data processing (in some semesters, Ray is taught).

Class workload:

Throughout the course, there are:

• 2–3 projects, which are relatively small and can be done in a few days.
• Short weekly lab assignments doable in about an hour.
• 8 HWs: most are coding, but a few may be written.
• 1 midterm and 1 final.

Class prerequisites:

The official prerequisites for this class are:

• Data 8.
• CS 61A or CS 88 or Engineering 7.
• EECS 16A or Math 54 or Stat 89A.

That being said, these prerequisites are occasionally not enforced, and Data 8 itself is not too necessary to know content-wise going into the class, there have been multiple cases where students are able to enroll and succeed in the class without having taken Data 8 before. In general, it is highly recommended to have taken one linear algebra course and one coding course before taking Data 100.

The course will be in mainly Python (and a tiny bit of SQL).

General opinions:

Overall, compared to other upper division courses, Data 100 is usually considered to be one of the chillest classes. Unlike some other classes, the workload is very steady and there aren’t times where you need to spend hours on end in a day on the class. It is often recommended to take this class along with one of the more intense upper division classes, such as CS 162.

Overall, most of the people who take this class fall into 2 main categories: (1) people who take it as one of their first upper division classes as they get more involved into data science and machine learning, or (2) students who aren’t really thinking of doing data science or machine learning, and are just curious to learn the basics. This class serves its purpose for both groups, although it definitely is not necessary for the first group of people: many students have gone straight from the EE16 series to Data 102, CS 189, and other stat classes without taking Data 100. If you have already taken CS 189, then taking Data 100 will do almost nothing for you, as you’ll already know almost all of the concepts taught, and you should easily be able to pick up pandas.

Data 100 is a good intro to data science from analysis all the way through to machine learning stuff, although it tends to abstract away almost all of the math behind the models you’re using. If you’re looking for a super in depth course on machine learning, then 189 or DS 102 are probably better classes for you. If you’re curious about machine learning/data science in general and want to learn about how to use industry-standard libraries, then this class is a great place to start! The work is straightforward (weekly labs and homeworks) and the professors are also usually awesome. :)

Other notes:

The (online) textbook for this class is amazing!! Use it, because it’s very concise and good at summarizing the topics covered in class.

EECS 126 — Probability and Random Processes

Class topics:

EECS 126 is an advanced course that teaches you the fundamental concepts in probability and random processes. It builds upon the beginning courses in probability such as CS 70 and develop a deeper mathematical understanding behind probability and how it can be applied to different areas.

There is a very comprehensive outline of the course content on the course website:

• Fundamentals of Probability (4 weeks): Discrete and Continuous Probability Bounds, Convergence of Random Variables, Law of Large Numbers, Discrete Time Markov Chains.
• Random Processes and Estimation (6 weeks): Transforms, Central Limit Theorem, Queueing, Poisson Processes, Continuous Time Markov Chains, Communication, Information Theory, MLE/MAP, Detection, Hypothesis Testing.
• Applications of Probability (4 weeks): Kalman Filtering, Tracking, Markov Decision Problems, Linear Quadratic Gaussian Control, Hidden Markov Chains, Optimization.

Class workload:

Throughout the course, there are:

• Weekly problem set HWs, take a pretty long time.
• Weekly coding labs, in Jupyter notebook.
• 2 midterms and 1 final.

Don’t be deceived by this short list! The work in this class really adds up and this class can be a fat grind for the majority of students.

Class prerequisites:

The official prerequisites for this class are:

• CS 70 or STAT 134.
• EECS 16A or Math 54.

Definitely don’t take these requirements lightly! Given that this is an advanced course, the content will move by very quickly, so be sure to brush up during the break before.

Testimonials:

• “This class was a fat grind, especially since I didn’t have any math competition experience. By far the hardest class I’ve taken at Berkeley and it’s not even close. It’s one of those classes that’s highly conceptual and intuition-based, which reflects in both the homework and exams. That being said, Ramchandran is a really great professor and I am glad I took the class — I just wish I chose a lighter coursework for my other classes. Recommend only if you’re interested and confident in the material, pass otherwise.”
• “Really enjoyed this class. I took it with Ramchandran, and he was a fantastic prof. Everything made sense, and the p-sets were not too long or too bad, but really quite interesting. Definitely recommend if you enjoyed 70!”
• “As advertised it’s one of the harder classes at Cal, and especially as someone who was eh at 70 probability, I struggled a lot at the beginning of the semester. While the concepts are the same, the questions are insanely hard and straight up make you just feel bad. But, after some patience and if you just try to keep up with the p-sets and lecture it is incredibly fundamental and interesting. It’s not pure CS or pure EE and just gives a really nice breadth over the power of probability in engineering. On top of that, it also has some useful stuff for ML/AI (MAP/MLE, Joint Gaussians, Stochastic GD, Markov Modelling, etc.) so really applicable, too. Overall, it’s very hard but very interesting and pushes you to look at problems and just not be too scared to not get them at first but slowly put intuition and concepts together.”

CS 160 — User Interface Design and Development

Class topics:

This is a course that helps to teach design through getting to build your own application. As of Fall 2020, the class has shifted to being a project-based course with no midterm or final assessments. You will spend the first half of the class learning about design concepts during lecture and through short reading or video responses usually due twice a week (before each lecture). During the second half of the class, you will get a chance to fully build an Android application from scratch, meaning that you go through every step of the design process: ideation, user research, low-fidelity and high-fidelity prototyping, user testing, and coding the app.

Specific topics that are covered in this course include:

• User research (personas, storyboarding).
• Design heuristics.
• Graphic design (typography, color theory).
• Prototyping.
• Using APIs.
• App development.

Class workload:

Throughout the course, there are:

• One final project with random group (work on it throughout the semester).
• 2 programming assignments.
• 3–4 design assignments.
• 10–15 reading/video responses.

These assignments were based on the Fall 2020 semester, which was completely remote. Potentially during a normal semester, there will also be a midterm and final.

Class prerequisites:

The official prerequisite for this class is just CS 61B! In general, though, just make sure that you know Java and understand object oriented programming. In the class, you’ll be designing and coding an Android application in Android Studio (which can be in Kotlin or Java).

General opinions:

In a usual semester, 160’s lectures are mandatory, however starting Fall 2020, lectures have become optional. There are mixed opinions in terms of how beneficial the lecture content is because some lectures focus on pointing out what not to do in design, which may not necessarily correlate to what you should do in design. However, because there are no longer tests on lecture content (this may only be for remote semesters), you can choose not to attend lectures and instead learn through coding projects. What separates this course from other design courses is that you are actually getting to code, so take advantage of the opportunity to do so!

160 takes feedback very seriously, which is really great. Following mid semester feedback, the course staff did a lot to improve how the course was taught. The course staff is very supportive in helping you succeed in this course; during weekly discussions there are signups to check in with the TA if you have any concerns or need any help.

This course is not super time intensive compared to other upper division CS courses, the amount of effort you put into coding assignments will reflect how much you get out of the class. Make sure that you keep up with assignments, especially the written responses because they can go unnoticed unless you are checking bCourses. Also it is kind of the luck of the draw for whether you will get a good final project group, but again this is something that we think course staff is happy to step in on if needed.

Other notes:

One great thing about a remote semester is that Fall 2020’s lectures are open to all Berkeley students, so if you are interested in learning about design but cannot get into 160, consider watching the recorded Zoom lectures!

This course is fairly small with only around 100 students a semester. Although it means that the chances you will get into this class if you are not a CS major with an early enrollment time, you get a lot closer to your TA’s and other students in the class.

This is a joint course with the grad-level version of this class, so you may get paired with a graduate student on the final project.

CS 161 — Computer Security

Class topics:

This course serves as a great introduction to the field of computer security, covering a wide range of topics. You’ll start learning about overall security principles and operating systems attacks and defenses, before moving to cryptography and encryption protocols. The latter half of the course is spent learning about web security topics, before finally ending on network security. Scattered throughout the course are real-world case studies applicable to the concepts being learned. There may be a brief tangent about blockchain technology about halfway through the course.

There will be projects exercising the 3 main topics of the course. In the first project, you try to use operating systems attacks to hack into a virtual machine. In the second project, you use cryptography concepts to design your own secure file sharing system. In the third project, you exercise web security concepts by trying to hack into a website.

Class workload:

Throughout the course, there are:

• 3 projects, which can be done in partners. They are on the larger side, where you have to either hack into a system, or design and build a secure system.
• 7 written HWs, occurring biweekly throughout the semester.
• 1–2 midterms and 1 final.

Overall, although not very busy on a daily basis, during project times it may get a little busy. This class is also one that is relatively medium light on workload, so it’s recommended to pair it with a class of high workload, such as problem set class.

Class prerequisites:

The prerequisites for this class are: CS 61A, CS 61B, CS 61C, and CS 70. Definitely highly recommend fulfilling these prerequisites before taking this course! You should know basic Python and C. The second project may be in Go, which you are expected to pick up on your own.

General opinions:

There is a general consensus that this is a must-take class if you’re planning on becoming a software engineer in the future. There are a variety of reasons:

1. This class serves as a great survey of the most important security concepts, something that all software engineers should know to some extent when they’re building software for real-world applications. Although the majority of software companies have dedicated security engineers to maintain the application’s security, everybody should know the core basics.
2. On a related note, the concepts that you’ll learn in this class may pop up in system design interviews later on during recruitment.
3. The projects for this class are some of the most well-designed at Berkeley, from concept to execution. Through these projects, you’ll learn a crucial skill: how to design, build, and test something from scratch without much scaffolding set in place. This is something that almost no other class at Berkeley has.

Overall, multiple of our members have said that this was their favorite class at Berkeley. Definitely recommend trying it out!

Other notes:

If you can, take the class with Popa and Wagner! Many have noted them as being some of the best professors that they’ve ever had, and they’re super good at teaching complex concepts. Weaver is also often a very popular professor for this class; with him, you’ll definitely have a lot more fun, although he may cover slightly less content on the syllabus and more about real-life security scenarios (such as voting systems, the Boeing 737 Max incident, etc.).

CS 162 — Operating Systems and System Programming

Class topics:

This is THE operating systems courses at Cal. By taking this course you’ll learn the core operations systems concepts that make your computer run, as well as make your own (with significant help from skeleton code)! The course starts off by going over the core OS concepts, including threads, processes, files, and inter-process communication, before diving into synchronization concepts. The next major topic is learning about scheduling algorithms that operating systems use. Next, you’ll learn about how operating systems deal with memory, and then move on to how a file system works. The final few lectures cover the basic concepts of distributed systems.

There are 3 projects scattered throughout the semester, where you’ll design and build different components of a very basic operating system: Pintos. In the first project, you’ll build the mechanism for loading and running user programs. In the second project, you’ll work on the scheduler in the operating system. Finally, in the third project, you’ll expand the operating system’s file system.

Class workload:

Throughout the course, there are:

• 3 projects, which can be done in groups of up to 4. Each of these projects are essentially building different parts of an operating system. These projects are HUGE and HARD. Each requires a flushed out design document, and can take the entire group many painful nights to figure out.
• 6 coding HWs, each of which are pretty large on their own and can take multiple days to work on.
• 3 midterms, but no final.

CS162 projects are notoriously known for being the most difficult projects across all of Berkeley. Combined with the frequent homeworks, hard concepts, and multiple midterms, CS 162 is considered as one of the most difficult and intense CS courses. Heavily recommend taking this class with breadths or classes with lighter workload, such as CS 161, CS 168, or CS 188.

Class prerequisites:

The prerequisites for this class are: CS 61A, CS 61B, CS 61C, and CS 70. Definitely highly recommend fulfilling these prerequisites before taking this course! The entire course is in C, so definitely brush up on that before the course. For CS70 in particular, probability concepts only appear once throughout the course, in HW 3 about scheduling, so you may be able to get away from not taking that class if you’re able to self-study or are willing to tank that particular HW.

General opinions:

If you’re at all interested in systems, this class is in the center of everything. It is also considered as one of the most important classes that software engineers should take, for a variety of reasons:

1. After taking class, you’ll have a much better idea of what’s exactly happening under the hood whenever you run a program, or what your computer is doing every time you turn it on!
2. This class will test your ability to work in a giant codebase where you don’t really understand what’s going on, as well as your ability to make significant progress on a massive project with a group of engineers.
3. The concepts that you encounter in this class will come up again and again in the future, even if you’re not a systems engineer. Almost every software engineer has to deal with memory and distributed systems at some point.

After taking this course, you’ll definitely leave as a much better software engineer. This class is perhaps the most hands-on course in all of Berkeley, so you’ll really get to put your coding skills to use.

Other notes:

As you may notice, this class covers a TON of topics, so everything is very fast paced! At any given point in time, there is something due or something to study for. Be sure to keep up with the work or you’ll find yourself very behind.

A good group can make or break your experience with this class. If you can, go into the class knowing which students you’re going to work with, and clearly communicate everybody’s expectations for how much effort everybody wants to put in. If you and your group are on the same page, this class goes a lot smoother.

It’s completely okay to not finish your project completely! Many groups are not able to completely finish their projects, so don’t worry if it seems impossible!

CS 164 — Programming Languages and Compilers

Class topics:

This is an introductory course to the design of programming languages and the implementation of translators for them. Throughout the course, you’ll learn each of the steps of compiling a language: converting the source program into a token stream through lexical analysis, parsing the tokens into an abstract syntax tree (AST), doing static semantic checks and type checks, and then finally translating the tree into assembly language through code generation.

To solidify the concepts you learn into a more hands-on approach, there are three projects where you work on different stages of a compiler for a custom language, ChocoPy, which is a statically typed version of Python. In the first project, you’ll work on the lexer and parser, which takes in the source code and outputs an AST. In the second project, you’ll work on a type checker to verify the AST. In the third project, you’ll implement a RISC-V code generator for ChocoPy.

Class workload:

Throughout the course, there are:

• 3 projects, which can be done in groups of up to 4. These projects are pretty large, and can take your group multiple days of working together to accomplish.
• 7 coding HWs, occurring on weeks whenever there is no project checkpoint or midterm.
• 2 midterms and 1 final.

Class prerequisites:

The prerequisites for this class are: CS 61A, CS 61B, and CS 61C. Definitely highly recommend fulfilling these prerequisites before taking this course! The projects are all done in Java, although some HWs will be done in Python, and a knowledge of RISC-V may be helpful during the code generation portion of the course. In addition, in the projects, you’ll be building a compiler for ChocoPy, which is a statically typed version of Python.

General opinions:

This is a course to take if you’re done with your requirements (or are nearing the completion of them), and are looking for a very interesting course to take. The things that you’ll learn in this course are very cool, but unlike CS 161, CS 162, or CS 186, there will most likely be less of a chance that you’ll encounter these concepts in the future as a software engineer. The main reason, as Hilfinger admits, is that there are only a few languages out there compared to applications, and compilers is one of the oldest areas of computer science that has gone through a lot of development, so many things will most likely have already been figured out. As a software developer, you may very rarely interact directly with a compiler unless you are trying to design your own language.

This can kind of be seen in the libraries that you’ll use throughout the course. Many of the libraries that you may use in HWs and projects can be dated back to the 1990s.

That being said, this course is still very fun to take, and we highly recommend taking it if you have some time left in college!

One thing to note that is this is a relatively difficult course, especially if you want to get a good grade. Perhaps not as much as CS 162, but definitely more than CS 161, CS 168, and CS 186. Hilfinger’s most well known for teaching this course, and this course definitely has a reputation of being intense, especially on the project-side. On the bright side, like many of the other project-based courses, you’ll learn a lot about coding and working together in a group!

Other notes:

The notes above are all based on our experience taking the course with Hilfinger. None of us have taken the course with Sen, unfortunately, so we are unsure if the same applies when he teaches the course.

One difficult aspect of the course with Hilfinger is that he does not reveal all of the tests that are part of the autograder, and only runs the autograder a few times before the deadline, so don’t expect to get 100% on your project grades. The class is also bucketed, so you’ll have a clear idea of what your grade is throughout the semester, and what you need to do to get a certain grade.

CS 168 — Introduction to the Internet: Architecture and Protocols

Class topics:

This is a class that covers the fundamental concepts of networking and the internet. You start learning the basics of the internet’s architecture, from the OSI model to design goals of the internet, before moving on to the largest topic of the course: routing algorithms. After you’ll dive in different protocols at each layer of the OSI model, starting with IP, then moving onto TCP. In the latter half of the course, you’ll learn about DNS, and how the web operates on a larger scale through congestion control. The last few lectures will be dedicated to miscellaneous topics such as ethernet and data centers.

There are 2 projects in this course. The first will cover routing algorithms. The second will be implementing the basics of TCP.

Class workload:

Throughout the course, there are:

• 2 projects, done individually. Each is relatively short, and can be done in a few days.
• Quick self-tests after each lecture.
• 1 midterm and 1 final.

That’s right, there is no HW for this class. This, combined with the fact that the projects aren’t too bad, makes this one of the easiest upper division CS classes, along with Data 100. If you want, definitely take this course with a more workload-intensive course, because it should be doable.

Class prerequisites:

The prerequisites for this class are: CS 61A, CS 61B, and Math 53 or Math 54. On some websites, you may find that CS 162 is a prerequisite, but in our experience this is definitely not needed. The other prerequisites aren’t enforced, and in our opinion, Math 53 and Math 54 are not necessary to take this course either, 61A and 61B should be enough! All projects are done in Python.

General opinions:

We would say that this class’s usefulness is about on the same tier as CS 164. After CS 161 and CS 162, you’ll have most likely learned the core concepts of networking and how the internet works. This class dives into much more detail about specific protocols, but this is something that you can learn on your own if you’re interested. Because of this, definitely don’t feel bad if you aren’t able to take this course! However, if you have time and are looking for a very chill class to take while learning some interesting concepts about how the internet works, this class is for you!

Other notes:

This class isn’t offered too often, and the version of the class when we took it went remote due to COVID. As a result, take it with a grain of salt because the class might have been made easier due to remote, but to be honest, these policies were set in place before the semester went remote, so it’s unlikely to be that different in-person.

CS 170 — Efficient Algorithms and Intractable Problems

Class topics:

Contrary to popular belief, this class is NOT an extension of CS 70. Instead, it’s an extension of CS 61B. In this course, you get introduced to the overall theory of computer science algorithms. You’ll study the design and analysis of a variety of algorithms, including graph algorithms, divide and conquer algorithms, greedy algorithms, dynamic programming, and linear programming (in that order). In the last few lectures, you’ll also learn about number theory, complexity, and NP-completeness.

There is a final, very open-ended project, where a problem is posed and you and your team comes up with an algorithm that is a combination of the different types of algorithms you learned throughout the semester to optimize a solution in a variety of criteria (one of which is correctness, one of which is time).

Class workload:

Throughout the course, there are:

• Weekly written problem sets that take a few days to complete.
• 1 final project that can be done in a group of 3. This is a coding, open-ended project, so it can take a variable amount of time. In general, it takes most groups multiple days, but some have spent more/less.
• 2 midterms and 1 final.

This class has a medium-heavy workload. The p-sets every week will definitely take time, but the good thing is that the workload is very steady, with no sudden jumps from projects or anything. As a result, it’s a good idea to pair this class with a project-based course such as CS 61C, CS 186, or CS 188. It’s doable to pair with a higher workload class, but you may want to limit your other techs then!

Class prerequisites:

The prerequisites for this class are: CS 61B and CS 70. It is doable to take 170 without having taken 70, as there is no strict content that 170 covers that relies heavily on 70, but the requirement is there mainly as a way to develop mathematical maturity. As a result, we still highly recommend still taking 70 before 170. The final project is done in Python.

General opinions:

There’s a common conception that this class is something that you need to take in order to do well on interviews. However, that’s not necessarily true. In reality, you’ll probably most likely learn almost everything you need to know for interviews in 61B: graphs, trees, heaps, priority queues, other data structures, etc. In a few interviews, though, you may be asked a problem that requires knowing one of the algorithms that this class discusses. However, these things can definitely be self-studied before taking this class. If you’re planning on interviewing soon, just self-study divide-and-conquer algorithms, greedy algorithms, and dynamic programming, and you should be good! None of the other content taught in 170 will help you in interviews, guaranteed.

That being said, this course is still considered as one that’s core to the CS curriculum at Berkeley, and we would also highly recommend taking it as early as possible, concurrently with CS 61C or whenever you’re done with CS 70. The main reason why is because this class establishes a lot of the logical thinking that will appear again and again when you become a computer scientist in the future, and even if you’re not planning on going into theory, you’ll undoubtedly still be thankful that you took this course whenever you encounter a hard problem that you have to solve.

For some students who are interested in going into theory, DEFINITELY take this class! Taking this class will open up a bunch of theory classes in the 170 series (that we unfortunately don’t have the time nor experience to go into) that you’ll absolutely love.

Other notes:

The textbook for this course is very good! It’s available for download online, and we would highly recommend reading it if you find lecture confusing.

For the project, don’t dedicate too much time if you have other things to do! As long as you have a pretty logical solution, you should get the majority of the points. The project itself is a pretty low portion of your grade. Also, even though some points for the project come from your rank in the class, this portion is really minimal, and the majority of the points come from the quality of your design doc and your reasoning for trying out the algorithms that you did. So, don’t worry about having to stay up 24–7 monitoring your algorithm’s progress and just relax and have a good time solving an interesting problem :).

CS W186 — Introduction to Database Systems

Class topics:

This course covers the essentials of database systems, specifically the relational database management system (RDBMS). You begin the course by learning SQL, before jumping through the different layers that a RDBMS encompasses. The course starts with storing records on disks, buffers, and files, as well as a core data structure in this process called B+ trees to build indices. You’ll next learn about relational algebra, as well as key database operations such as sorting, hashing, iterating, and joining. On a similar note, the course will then cover query optimization, before moving onto key concepts that almost all databases utilize: transactions, concurrency, and recovery. The class ends by going through DB design concepts, distributed transactions, and touching on NoSQL briefly.

Similar to other systems classes, there are projects scattered throughout to provide hands-on exercises for concepts learned in class. All the projects are in the same repository, in a RDBMS coded in Java. The first project is purely about SQL. The second project is implementing a B+ tree. The third project is implementing joins and query optimizations. The fourth project implements concurrency in the RDBMS. The fifth project implements recovery systems in the database. The sixth project, which is relatively new, touches on NoSQL databases.

Class workload:

• 5–6 coding projects. In some semesters, these are partner projects; in others, these are done individually. Each of these projects take a few days to complete.
• Weekly vitamins on lecture material.
• 2 midterms and 1 final.

Despite the projects themselves being not trivial, they are definitely easier than CS 162’s, and are about the same difficulty as CS 161's. Because almost all of the workload in this class comes from the projects, this class is a relatively light workload class, about the same as CS 161. It’s common to take this class with a heavy p-set class such as CS 170, CS 189, or a heavy systems class like CS 164 or CS 162. If you’d like to take other breadths, it’s also common to pair up CS 161 with CS 186 in a single semester.

Class prerequisites:

The prerequisites for this class are: CS61A, CS 61B, and CS 61C. The prerequisites aren’t enforced, and in our opinion, 61C is not necessary to take this course, 61A and 61B should be enough! Knowing the concepts discussed in 61C (especially caching) may help you pick up material faster, but it is definitely not a requirement. All projects are done in Java.

General opinions:

Along with CS 161 and CS 162, if you’re going to be a software engineer, this class is a must-take! Data storage is one of the most important things that software engineers will have to deal with on a daily basis, and it’ll be very useful to know about how a database system works. In addition, you’ll really be able learn the core big ideas that will pop up across almost all systems topics. In fact, this class will most likely be the most useful class for systems design interviews that you may encounter in the future when recruiting.

In addition, since all of the projects are in the same repository, one major skill you’ll learn is how to extend an existing massive codebase!

General notes:

One interesting thing that makes this class stand out is that it’s run almost completely online, and it’s run really well! The lectures are all pre-recorded, and divided into small chunks. After each chunk, there are a few multiple choice questions to make sure you are paying attention. By doing this, watching lectures goes by a lot faster; not only is there literally no time spent wasted on technical pauses or answer questions that you may already know, but the shorter videos also allow you to catch your breath between each topic!

CS 188 — Introduction to Artificial Intelligence

Class topics:

This course introduces the basic ideas and techniques behind artificial intelligence. You’ll begin by exploring one of the core problems in AI: search, and different algorithms that seek to solve it. You’ll then move onto a new set of problems, called constraint satisfaction problems. You’ll also learn about Markov decision processes and reinforcement learning algorithms. In the latter half of the course, you’ll dive into the more mathematical side, learning about probability and Bayes nets, before ending with some basic machine learning algorithms with regressions and neural networks.

There are 5 projects scattered throughout the semester, about different topics. One thing that’s cool is that the first 4 projects take place in the same world: Pacman! In the first project, you implement Pacman’s search algorithms. In the second project, you implement multi-agent search with the ghosts. In the third project, you use reinforcement learning to move Pacman around. In the fourth project, you implement an alternate version of Pacman that tries to chase ghosts based on limited information, using Bayes nets. In the fifth project, you will build a neural network to classify digits.

Class workload:

Throughout the course, there are:

• 5 projects, each are relatively small and don’t require too much coding itself. There’s a lot of skeleton code, and each project is like one of those in 61A where they tell you specifically where to put your code.
• 10 electronic homeworks, which take an hour or two to do.
• 4 written homeworks, which take a few hours to do.
• 1 midterm and 1 final.

Overall, this class is relatively light on workload, about the same as CS 161, but slightly more than Data 100 and CS 168, and definitely less than CS 162, CS 164, and CS 189.

Class prerequisites:

The official prerequisites for this class are:

• CS 61A.
• CS 61B.
• CS 70 or Math 55.
• CS 61A AND CS 61B AND CS 70 is recommended.

In general, we agree with these prerequisites! The projects will all be done in Python.

General opinions:

188 is a fun, relatively easy class, but is more for AI enthusiasts rather than people looking into going into industry for machine learning and artificial intelligence. As a software engineer, you most likely will not really use what you learn in this class. Quoting the professor, “a lot of the interest in AI right now is because of advances in deep (supervised) learning. Skills in deep learning are increasingly sought-after in industry. But 188 does not focus on deep learning — you’ll learn some basics in the last part of the course, but it’s really not the main focus of 188. For an advantage in the job market, we’d recommend 189 and 182 instead.”

That being said, if you know that you’re not planning on taking 189 and are still interested in learning some concepts while having some really fun, relatively straightforward projects, then feel free to take this class! One very popular thing that a lot of our members do is take this course along with CS 162 to achieve a pretty balanced schedule in terms of workload.

Although the HWs and the projects are relatively straightforward, one thing to note is that the exams in this class are actually quite difficult. They are pretty mathematical, so be prepared to answer some p-set like questions in the exams!

Other notes:

If you can, take this class with Dragan! She’s an awesome professor, has a very clear enthusiasm for the subject, and is really good at explaining the concepts! The slides that each professor uses are basically the same every semester, so one thing you can do is also watch another semester’s lectures if you don’t end up liking your professor.

CS 189 — Introduction to Machine Learning

Class topics:

CS 189 is one of the most famous courses at Berkeley; it is THE machine learning course. Over the course of the semester, you’ll learn the mathematics behind some of the core machine learning concepts, including (taken from Shewchuck’s website):

• Classification: perceptrons, support vector machines (SVMs), Gaussian discriminant analysis (including linear discriminant analysis, LDA, and quadratic discriminant analysis, QDA), logistic regression, decision trees, neural networks, convolutional neural networks, boosting, nearest neighbor search
• Regression: least-squares linear regression, logistic regression, polynomial regression, ridge regression, Lasso.
• Density Estimation: maximum likelihood estimation (MLE).
• Dimensionality Reduction: principal components analysis (PCA), random projection, latent factor analysis.
• Clustering: k-means clustering, hierarchical clustering, spectral graph clustering.

Class workload:

Throughout the course, there are:

• Biweekly HWs if you are taking the Shewchuck version. Most HWs will have a coding component. These HWs can take multiple days to finish.
• Weekly problem set HWs if you are taking the Sahai version of the course. Most will be written, and can take multiple days to finish.
• (optional) Final project, if you would like for it to be counted as part of your grade (usually it’ll serve as a boost if you put the effort in).
• 1 midterm and 1 final.

This class, especially if you’re taking Sahai’s version, will take up your time. Definitely recommend pairing it with easier classes. Another option that many students have done is take EE 127 along with 189, because there is a slight overlap in content covered.

Class prerequisites:

Official prerequisites for this class are different based on the professor:

If you are taking the Sahai version of the course:

• EECS 16A and EECS 16B.
• CS 70.
• Math 53.
• Highly recommended: EECS 126 and EECS 127.

If you are taking the Shewchuck version of the course:

• Math 53.
• Math 54, Math 110, or EECS 16A+16B.
• CS 70, EECS 126, or Stat 134.

If you’re planning on taking Sahai’s version of 189, I would highly recommend taking at least one of EECS 126 and EECS 127 either before 189 or concurrently. Doing so prepares you for the mathematical maturity that the course requires. If you are taking Shewchuck’s version, there is no need to take these courses beforehand.

General opinions:

Your experience taking this course can vary pretty differently depending on which version you’re taking. If you’re planning on becoming a software engineer and you’re not too invested in diving into the mathematics and statistics behind ML, then Shewchuck’s course may be a better fit for you. However, if you’re much more math-y and enjoy p-sets more than coding, then Sahai’s version is better for you!

If you’re planning on going into research in AI/ML, then we would highly recommend taking this course as early as possible, and putting as much effort into it. When considering applicants for research, many professors ask about whether or not you have taken this course, and whether you got a good grade.

Other notes:

There are a ton of resources available online that professors recommend in preparation for this course. The break before the course, we highly recommend skimming over the following resources, because it’ll make sure your foundations will be solid! This course is pretty fast paced and doesn’t wait for people to catch up, so this will ensure that you’re always on the right track:

• Mathematics for Machine Learning
• Prof. Shewchuk’s CS 189 notes from his iteration of the course.
• CS231n: Stanford’s deep learning course.
• A Comprehensive Guide to Machine Learning (covers topics of the class)

And that’s all we have! These are definitely not all the courses that Berkeley has to offer (there are a TON of other really cool new courses, especially in data science, that have been popping up recently). If you are looking for more information, HKN’s course guide has a lot more helpful info! Hopefully this will be a good resource for you when you’re choosing which classes to take in future semesters!