CMU Course Review and Recommendations

Here I share my thoughts on the courses that I took at Carnegie Mellon University. Note that my experiences with some of these courses can be highly dependent on the professors, or due to the impact of virtual classes during the COVID-19 pandemic.

Courses with a ⭐ are those that I found transformative, and those with a ❤️ are those that I personally enjoyed a lot.

Feel free to ask any questions about the courses at CMU, including those that I have not taken, in the comments section below.

A lot of inspiration for this page came from Wan Shen’s CMU course review page.

This page was recently updated on 11/9/2022 to help students decide the classes they may want to take ahead of course registration week.

Fall 2018

  • ❤️ 15-151 Mathematical Foundations for Computer Science, John Mackey

    It is said that the best predictor of a student’s success is how well they did in 15-151. Having been through the whole process, I can testify that it is indeed true. Much of computer science depends on math, and you need a strong and firm foundation in discrete mathematics and proof writing in order to succeed in all subsequent classes.

    Seriousness aside, Mackey is an amazing lecturer. In fact, I would go so far as to say his lectures are more like a performance, full of wit and humor. I will always remember how after the first lecture everyone stood up and gave him a standing ovation. I believe that was the first and only time I have ever seen 200 students in a packed lecture hall give a standing ovation after a lecture.

  • 15-122 Principles of Imperative Computation

    I was quite bored during lecture as I already knew most of the content due to my competitive programming background. The assignments were still pretty cool though.

  • 21-120 Differential and Integral Calculus

    I could not transfer AP credit from A-Level H2 Mathematics as the SEAB course code changed while I was serving National Service as they modified the syllabus and split it into H2 Further Mathematics and H2 Mathematics, and was therefore forced to take the class by my first-year advisor. It was honestly largely a waste of time, but it was also the only class that I took at CMU where I was classmates with college football players. It was quite funny because I was the only Asian kid in the class, and since I already knew all the content, I would always go up to the blackboard and write up the answers to all the TA’s questions during recitation, to the applause of all the other kids. The whole scene is quite stereotypical but it’s also funny, and having this experience is perhaps the only silver lining of taking this class.

  • 76-106 Writing about Literature and Art

    I enjoyed the assigned readings of literature from different cultures, and the class discussions were also quite engaging.

  • 76-107 Writing about Data

    Found this class relatively dry, and most of the content seemed obvious and boring.

  • 80-100 Introduction to Philosophy

    I had some prior interest and experience with philosophy, and found this a really interesting class that covered a good amount of topics. However, the workload was quite high for a gen-ed (2 sets of assignments and readings per week), and I don’t think I could have tolerated the workload if I had taken it beyond freshmen year.

  • 07-131 Great Practical Ideas in Computer Science

    Teaches you the tools of the trade like Git, Vim, etc.

  • 15-051 Discrete Math Primer
  • 99-101 Computing at Carnegie Mellon
  • 07-128 First Year Immigration Course

Units: 55

Most of the last few courses are just orientation courses that are not real classes with actual workload.

Spring 2018

  • ❤️ 15-251 Great Ideas in Theoretical Computer Science, Venkatesan Guruswami, Vipul Goyal

    The class was very well-taught and structured. Homeworks are done in the form of weekly writing sessions, where you have to reproduce proofs to selected homework problems independently in an exam-like setting. This helps to ensure that all students fully understand the proofs that they write up.

  • 15-150 Principles of Functional Programming

  • 15-213 Introduction to Computer Systems, Seth Goldstein, Brandon Lucia

    This class unlocks all other systems classes, and many classes also have this as a requirement to ensure that students have had experience implementing large projects. Much of what is covered will form the bread and butter of subsequent systems classes, and many of the topics will also be extremely useful in your future career as a software engineer.

  • 21-122 Integration and Approximation, Eric Baer

    I liked his lectures, although Eric is now at UChicago.

  • 21-241 Matrices and Linear Transformations, Irina Gheorghiciuc

    I personally liked Irina’s to-the-point, no-nonsense teaching style. Her lectures are quite clear and interesting.

  • 98-317 StuCo: Type Theory (Hype for Types), Jeanne Luning Prak, Vijay Ramamurthy, Chris Grossack, Charles Yuan

    We were given a crash course of SML in the first week, as everything else in the course depended on that, and it was required for the weekly homework. I would say that taking this concurrently with 15-150 definitely made 15-150 much easier, but at the time I was also pretty lost during many of the lectures in this class. Somehow I was able to complete all the programming assignments despite understanding very little from the lecture, which goes to show how much a strongly typed functional language can inform and guide your code. It was only a few years later after having taken both 15-312 Foundations of Programming Languages and 15-317 Constructive Logic that I could fully appreciate much of the content in hindsight.

Units: 57

Fall 2019

  • ❤️ 15-319 Cloud Computing

    This post by Lisa Hou discusses the projects of the course in detail.

    I personally enjoyed this class a lot and the amount of industry knowledge that I gained from the course was like having done 3 internships back-to-back, which happened to make it really great interview prep as well.

    I would recommend taking the class with friends as it is easy to get stuck in weird errors of a complex system that you just learned, and to go for the graduate 15-619 option if possible, as it includes a very transformative team project that will stretch your wits in finding ways of improving the throughput of a distributed web service in the cloud.

  • 15-330 Introduction to Computer Security, Bryan Parno

    Bryan is a great lecturer, and the course is divided into 3 portions: binary exploitation, cryptography, and web security. I took this course because I wanted better knowledge of topics in computer security, so that I can get better at playing Capture-The-Flag (CTF) competitions with the Plaid Parliament of Pwning (PPP).

    I personally think it is a form of gross negligence if you ever write critical software systems without having a good understanding of computer security, especially if you ever touch or deal with anything related to cryptography, or maintain critical and sensitive user-facing platforms like banking systems. The number of software engineers who still don’t know the difference between private and public keys is stupefying, and you really don’t want to cause your company to get hacked or lose customer data because of a lack of understanding of fundamental security concepts.

  • 15-210 Parallel and Sequential Data Structures and Algorithms

    I found the course okay, some portions were interesting but I don’t remember being very excited by any topic in particular. I already knew quite a lot of the algorithms from doing competitive programming in high school, so it was relatively easy.

  • 21-268 Multi-dimensional Calculus, Jack Schaeffer

    This is the honors version of 21-259 Calculus in Three Dimensions, and I would recommend mathematically strong students take this (or 21-269 Vector Analysis if they are on the math honors track). It covers more content and is more rigorous.

  • 69-151 Introduction to Yoga

    Took this for fun because I attended a lot of free yoga classes at the office while I was interning at Asana.

  • 98-349 StuCo: Design and Analysis of Logic Puzzle Games

Units: 52

I dropped 21-373 Algebraic Structures in the last week of classes.

Spring 2020

  • 15-410 Operating Systems Design and Implementation, Dave Eckhardt, Brian Railing, Dave O’Hallaron

    This is probably the most “famous” systems class at CMU. The slides from the first lecture will probably give you a good sense of how the class is like.

    A few pieces of advice:

    1. Start early and aim to finish 2-3 days before the deadline. It is hard to debug a complicated kernel under stress, and you will always find a few more bugs just when you thought you were done.
    2. Choose your partner wisely. Preferably they will be someone that you have worked with before. Avoid choosing your significant other as your partner - this class is very stressful and it will introduce many fault-lines into your relationship.

    I will probably write a dedicated, separate post for this class someday.

  • 15-259 Probability and Computing

    Mor is absolutely amazing at teaching and in maintaining student’s interest during classes. She will give out chocolates in class if you answer a question, leading to very high in-class participation. People fight to get seated closer to the front, so that it is more likely that they will get called on to answer questions.

    Aside from that, her teaching is very clear and she has a wonderfully written textbook that accompanies the course. Homework problems are on the challenging side, but also very fun.

    If you are a CS major with a strong mathematical background, you should definitely take this class to satisfy your probability requirement instead of taking the one from the statistics department (which is not as rigorous). This course is tailored for CS students and covers many topics that are pervasive in CS research, such as concentration bounds including Chernoff and Hoeffding, classical randomized algorithms, and Markov Chains.

  • 15-260 Statistics and Computing

    This class is offered as a mini, meant to accompany 15-259 Probability and Computing. It allows CS students to satisfy satistics requirement for some ML or graduate statistics classes without having to take another introductory statistic course.

  • 15-451 Algorithm Design and Analysis, Danny Sleator, David Woodruff

    This is the main algorithms class of CMU, and Danny Sleator and Splay Trees (which he invented) are the heart of it. Since students are expected to have already completed several other introductory algorithms and theory classes prior to taking this, the course covers many more advanced topics.

    One misconception that many people have is that they need to take 15-451 before they know ‘enough’ algorithms to feel confident enough to apply for software engineering jobs and pass the interview. Most of the content covered in 15-451 are probably out of scope for most interviews (nobody is going to ask you to code max-flow, or prove LP duality, or write Rabin-Miller hashing from memory during a 30-minute interview). The only relevant topic for interview preparation is probably dynamic programming, but given that DP was already covered in 15-210, there is really no reason to wait for this class.

  • 33-228 Electronics I, Jeffrey Peterson, Ben Hunt, Simranjeet Singh

    I took this class to satisfy my lab requirement. I personally thought that this is the best class for the lab requirement for CS majors, since it introduces you to the basics of circuits and electronics, which seems quite useful as there are no other CS classes that does anything comparable. One of the most memorable projects was in building a 555 timer from scratch (not using the IC) with resistors, transistors, capacitors, and voltage dividers. It made me realize that if debugging software was bad, debugging hardware is on a whole new level.

  • 79-396 Music and Society in 19th and 20th Century Europe and the U.S., Naum Kats

    This was a relatively low-stress and fun class, where each week you would watch a live play, musical, or orchestral concert, and also visit art galleries and museums. The weekly homework is just to write a one-page reflection of the experience, and apart from that there are only two book reviews to complete. It was quite a good class to take to destress from my other more demanding classes.

Units: 61

Fall 2020

  • ❤️ 15-411 Compiler Design, Seth Goldstein

    Compilers is the other “star” systems class in CMU apart from OS. The best part of the course were the labs by far. They are done in groups of 2, and you can choose to use OCaml (best-supported, most people use this), C++ (ok support), or Rust (very limited support, maybe better now?). Why not be the next legend to write it in JavaScript? (please don’t: reasoning will be given later). There are 6 labs in total, with each lab depending on previous labs. They are as follows:

    1. Lab 1: You will implement lexing, parsing, typechecking, register allocation, and code generation in x86 for a very simple language that only performs arithmetic for integers.

    2. Lab 2: You extend the language that your compiler can compile to boolean expressions (including integer comparisons that results in booleans), conditional expressions, while and for loops.

    3. Lab 3: The language that your compiler supports now includes function prototypes, function declarations, typedefs. It will be necessary to perform some tail-call optimizations to avoid stack overflows on some of the test cases that performs recursive calls.

    4. Lab 4: Your compiler must now be able to allocate/free memory on the heap, deal with pointers & deferencing, support structs and field dereferencing/selection, support allocation and de-allocation of fixed-sized arrays of a given type.

    5. Lab 5: In my opinion, this lab was the most fun. The goal is to implement various compiler optimizations such as strength reduction, single static assignment (SSA), improved register allocation, aggressive deadcode elimination, partial redundancy elimination, etc. You need to beat gcc -O1 in order to receive full credit, and it is possible to earn bonus points if you can beat it further. There is a scoreboard as well, which encourages teams to be competitive and creative with their optimizations.

      The running joke about Lab 5 is that many teams spend most of it implementing SSA, but then run out of time to actually build optimizations on top of it. This is because SSA is just a mechanism for transforming your intermediate representation into a form that is more suitable for implementing many other globla optimizations, but implementing it just by itself without optimizations does not speed things up and instead makes your code slower since code in SSA form is longer.

      This lab allows you to go as crazy as you want, and you can work on whatever optimizations that interests you the most personally. For instance, in the past there was a group that wrote an optimization to vectorize operations using SIMD extensions. It did not really improve the performance of the binary by a lot on most of the test cases, since most of them are testing performance on other cases like deadcode elimination or loop optimizations, but it was a cool project nonetheless.

    6. Lab 6: In the last lab, you are asked to write your own proposal for extending your compiler, and then to implement it. My group chose to add object-oriented features to the language, including inheritance, access modifiers (i.e private/public/protected), and runtime polymorphism via vtables.

    Ok, so I mentioned previously that you shouldn’t use some weird language for compilers unless you really know what you are doing. This is because in Lab 5, the amount of time given to your compiler to compile each file is limited. Some of the more advanced optimizations are actually very computationally expensive, and therefore you want to make sure that the language that you use is fast, or otherwise you know how to make it fast. There are many teams using OCaml that lost points on Lab 5 because their compiler could not compile many of the test cases in time (this can be avoided by optimizing your compiler code, even if it’s heap-based like OCaml, although it might be trickier since people are generally less familiar with how to write performant OCaml code). We also faced compiler runtime issues with a few test cases initially even though we were on C++, but we were able to resolve all of them by performing some optimizations.

    Another fun part about this course is that on top of the test cases provided to you for each lab, you will also have to write at least 20 programs to be submitted as test cases, which will be added to the common pool of test cases that everyone will be evaluated on. This creates some sort of cat-and-mouse game where over the years the tests get increasingly harder and catch even more edge cases, and your compiler must be faster and be more robust. Some of the test cases even revealed bugs in the reference compiler. Of course, there is a limit to how adversarial the programs can be - the reference compiler must be able to compile them within the time limit. Our team did something quite evil by binary searching for the parameters determining the difficulty of our programs that barely passes the threshold of what the reference compiler can accept, which tripped up quite a number of other teams.

    Another piece of advice for this class is that you cannot afford to fall behind on any of the labs. This is because each lab depends on the successful implementation of previous labs, and your compiler will be run against test cases in previous labs. In other words, if you are failing 5 test cases in Lab 2, then you will at minimum continue to fail all 5 of them in Lab 3 because they will re-appear. This makes it critically important to get everything right for each lab when it is due, if not the amount of points that you lose will continue to compound to subsequent labs.

  • ⭐ 15-455 Undergraduate Complexity Theory, Venkatesan Guruswami , Jonathan Mosheiff

    I really enjoyed 15-251 Great Theoretical Ideas in Computer Science under Venkat, and decided to take this class with him as well. Undergraduate Complexity Theory (UCT) is considered to be the follow-up class to 15-251. The lecture pacing was quite fast, and he covered a lot of advanced topics which would usually only be touched upon in a graduate class (i.e parameterized complexity, pseudorandomness), but all for the better. The homeworks and exams are notoriously difficult and I ended up spending much more time on this class than I expected to (~20 hours/week), but it was a great preparation for the follow-up 15-855 Graduate Complexity Theory course that I took next semester. Also, don’t worry too much about doing extremely well on his exams because they are always generously curved at the end.

    Unfortunately, Venkat is now no longer at CMU, but has moved to Berkeley, which in my opinion is a very great loss for CMU’s theory community. He is truly an amazing lecturer.

    Recordings from a past offering of the course by Ryan O’Donnell can be found on this Youtube playlist.

  • ❤️ 15-445 Database Systems, Andy Pavlo

    Andy’s lectures are a whole lot of fun, and it is hard to not be fired up by his enthusiasm and energy for databases. You will get to build the major components of a database through the class projects. Did I also mention that Andy really loves Wu-Tang Clan, and once gave an extra credit question worth the entire final if you can list all members of Wu-Tang Clan?

    Recordings from a past offering of the course can be found on this Youtube playlist.

  • 15-300 Research and Innovation in Computer Science, Bogdan Vasilescu, Jonathan Aldrich

    The goal of this class is to encourage undergraduates to contact professors and get into research. However, from what I saw people who already started doing research before the class simply continued with their existing topics, and those that were not engaged in research previously also did not continue after the class. In other words, don’t expect this class to suddenly turn you into a researcher - the motivation must come from within.

  • 98-212 StuCo: Competitive Computer Security, Chris Lambert

    This was a great class on popular cyber-security Capture-The-Flag (CTF) topics. The depth of the topics covered go beyond introductory pretty quickly, so even CTF veterans will take away a lot from this course. Unfortunately, it is unclear if/when the class will be offered again.

Units: 48

I dropped 15-312 Foundations of Programming Languages in the middle of the semester, as UCT ended up taking much more time than I anticipated, and so that I could spend more time on compilers.

Spring 2021

  • ⭐ 15-855 Graduate Computational Complexity Theory, Ryan O’Donnell

    This was my first graduate theory class, and needless to say I struggled a lot with the homework. Interpreting the homework problem was oftentimes a challenge in itself, and there were problems that I was stuck on for days, which at the time was really depressing and led to me questioning my intelligence and aptitude. However, in hindsight I grew a lot from this experience, and the euphoria of finally solving something that you have been struggling with for ages is indescribable. I gained a lot more confidence in my mathematical abilities, and became better in engaging in long periods of deep thought about a problem.

    Recordings from a past offering of the course can be found on this Youtube playlist.

  • ❤️ 21-301 Combinatorics, John Mackey

    I loved 15-151 (Concepts in Mathematics) and after that class I swore that if Mackey ever taught another class, I will take it for sure. Mackey is just as great and fun in Combinatorics as he was in Concepts. The homework is challenging, and the exams even more so. After the first midterm (where the variance was really high) he explained that he had to make the course challenging because there were many people who already came in with a lot of math competition background, the bulk of which involves combinatorics, and he did not want them to be bored. Unfortunately I did not have such a background and struggled with solving all the problems during the stressful time-crunch of the 50 minute midterm (I can’t really think creatively when I am stressed), and this class ended up being the only B that I got in my undergraduate career (all others A). That said, I don’t really care about my GPA and my main goal is to optimize for learning, so I am still very glad I took this class. Not having a 4.0 also ironically gave me more courage to take a more challenging course schedule in the future, as I no longer had to worry about losing my perfect GPA.

  • ❤️ 85-102 Introduction to Psychology, Kody Manke

    My view of psychology was pretty misguided (think Sigmund Freud, Carl Jung) before coming into this class, and it ended up being one of my favorite geneds. Kody is a very energetic and fun lecturer, and the class helped to open my eyes to many social phenomenom that I encounter in daily life, such as stereotype threat and priming.

  • 10-701 Introduction to Machine Learning, Geoff Gordon, Aarti Singh

    I did not really enjoy this class, and felt that it tried to cover too much too quickly, which led to a very shallow and surface-level understanding of many topics. Maybe this is the whole point of an introductory survey class, and maybe my lack of background in the area also led to me feeling oftentimes very confused about what is going on. I don’t feel like I remembered a lot from this class, and none of the homework assignments were memorable.

    Unfortunately, there are not many great options for introductory ML classes.
    People I knew who took the undergraduate Introduction to ML class (10-315) complained about it being hand-wavey and not rigorous, and 10-601 is sort of an in-between. As such, if you are a motivated and mathematically mature student, 10-701 would still probably be your best option for an ML class. Another choice would be 10-715, which is geared towards Ph.D students in the Machine Learning Department (MLD) and is the fastest-paced and most challenging option.

  • 15-354 Computation and Discrete Math, Klaus Sutner

    Klaus has a reputation of trying to add abstract algebra in everything that he teaches. This was definitely true in his trademark class Computation and Discrete Math (CDM), where he condensed a semester’s worth of material from 21-373 Algebraic Structures covering groups, rings, and fields into two lectures, and for good measure also threw in some discussion about Galois theory. This culminated in a formal introduction of Polya counting, algebraic feedback shift registers, and many other algebraic applications.

    There was also a lot of discussion about advanced concepts in automata theory in the first part of the course, building upon the basics introduced in 15-251 Great Theoretical Ideas in Computer Science. This was his research area and was therefore unsurprising.

  • 15-440 Distributed Systems, Mahadev Satyanarayanan, Padmanabhan Pillai

    Having already taken 15-410 (Operating Systems) which covers many concurrency and cache coherence concepts, 15-319 (Cloud Computing) which has an entire module on distributed consensus protocols, 15-445 (Database Systems) which talks about distributed databases, I did not really get much out of this course and wish I had taken something else. The projects were fairly straightforward compared to the other systems classes I have already taken. This course is usually considered the easiest systems class and I would only recommened it if you are new to systems or if this is the only systems class that you are planning to take.

  • 98-242 StuCo: Introduction to Esoteric Programming Languages, Ari Cohn, Jonathan Loungani

Units: 69

Fall 2021

  • ❤️ 15-459 Quantum Computation, Ryan O’Donnell

    This course covers the theoretical aspects of quantum computing, starting from the Elitzur-Vaidman bomb algorithm (I bet this already got your attention) to classical results like Shor’s and Grover’s algorithm. The class starts off initially relatively slowly, but then ramps up in the middle half.

    A curious trait of this class is that all weekly homeworks are optional, but you can turn in two selected problems per week to offset the weightage of your midterms and final exam. As a result, it is possible to score worse in the class if you turn in garbage for your homework but do well on the exam. My personal recommendation and what I did is to always do all the problems and turn in all the selected problems so that you can receive feedback. I only missed turning in homework for one week due to many overlapping deadlines from other classes. This approach helps you stay on track with the class and improves your confidence of your abilities during the midterms.

    Recordings from a past offering of the course can be found on this Youtube playlist.

  • ⭐ 15-641 Computer Networks, Peter Steenkiste

    I dedicated an entire post to review this course. Trust me, it’s worth a read! But the TLDR is this course is very different from other systems courses, and you will likely stand to gain a lot from it even if you already have a lot of systems experience.

  • 15-317 Constructive Logic, Karl Crary

    It can be hard to see how this class is relevant without subsequently taking other PL classes. I found the theoretical foundations gained from this course immensely helpful for preparing for 15-312 and 15-819. However, if you are only planning to take a single PL class, I would recommend another course that is more immediately applicable.

  • 15-356 Introduction to Cryptography, Elaine Shi

    I found the class relatively easy as I had already taken 15-330 prior to this, and so I only started seeing new content near the middle of the course. The last part of the course covers blockchains and distributed consensus protocols, which is one of Elaine’s major research areas. There were some pretty cool content like oblivious data structures, multi-party computation, and zero-knowledge proofs, but personally I wished that it went faster and covered more content like lattice-based and post-quantum cryptography.

  • 15-462 Computer Graphics, Keenan Crane

    The course assignments are pretty fun. and there’s many moments of instant gratification, such as when you see your ray tracer paint a beautiful image of light refracting through glass balls. The course staff cares deeply about the class and there’s a very active Discord server for the class to ask questions, get help, and post memes. While I think I am pretty competent at systems debugging, I found that debugging graphics code required a completely different set of skills since the visible effect of bugs are usually the result of many different matrix operations, which can be quite unintuitive to trace back to the source. It was a great learning experience for me.

    Recordings from a past offering of the course can be found on this Youtube playlist. In fact, when I took this course we were told to watch the lectures from this playlist asynchronously before class, and lecture time was reserved for in-class activities and Q&A. So together with the publicly available homework materials from the course website you can effectively self-study the class.

  • 18-746 Storage Systems, Greg Ganger, George Amvrosiadis, Huaicheng Li

    During the first lecture, the professor talked about NAND flash alll the way down to the gory details about how it is implemented with MOSFET cells, and how reads, writes, and erases are performed at the voltage control level. I knew nothing about ECE, had no idea what was going on, and thought that if the entire course was going to be so low-level (since it is from the ECE department after all) I was probably going to drop the class.

    Fortunately, that was not necessary as most of the subsequent lectures stayed at the layer of abstraction of the software level, and therefore don’t be afraid to take this class if you are not a ECE major.

    There are two big assignments in the class. In the first project, you will implement a Flash Translation Layer (FTL) for a SSD, and optimize your implementation such that it preserves the lifespan of the SSD for as long as possible for different workloads. This is because NAND flash can only tolerate a certain number of erases before it fails. In the second project, you will implement a FUSE-based filesystem (cloudFS) that automatically saves large objects to the cloud (i.e AWS S3), performs optimizations like de-deduplicating identical segments of stored files, and extend it to be able to read/write large files that can fit on the cloud but not on disk by performing segment-based read/write operations.

    Overall I thought it was a good class that provides you with a good sense of where the bottlenecks of various I/O-based workloads could lie (i.e database queries) for different filesystem designs, which is quite useful for optimizing the performance of many real-world systems you might work on in the future. It also gives you a good understanding of how many distributed filesystems (NFS, AFS, Google Filesystem) and storage systems (Google BigTable) that big tech companies use works.

  • 84-380 US Grand Strategy, Andrew Stravers

    As someone who is interested in history and geopolitics I really liked this class. It offers a critical and balanced examination of past US foreign policy and grand strategy under various administrations. It was refreshing to see opinions which are not just variants of US/West is good and Russia/China/non-democracies are bad which permeates online discourse. Classes are structured such that the first hour is spent on lecturing, and the remaining 20 minutes is spent on group discussions.

Units: 75

Spring 2022

  • ⭐ 10-725   Convex Optimization, Yuanzhi Li

    I did not enjoy 10-701 as it covered a lot of content, but did not go into much detail about many topics, and I felt like there was no true understanding and everything was very hand-wavey. That experience made me hesistant to take any other ML classes.

    10-725 changed that for me, as Yuanzhi Li started from first principles and rigorously proved how many machine learning algorithms can converge in some amount of steps given various assumptions. For instance, just in the second lecture you will learn how gradient descent can converge to the optimum up to an epsilon error in a number of states which is proportionate to a chosen learning rate, given assumptions on the smoothness of a convex optimization landscape. This will then be extended to more complicated settings such as stochastic gradient descent, gradient descent with momentum (ADAM), distributed gradient descent, and even quantum optimization.

    Yuanzhi Li also understands that the students taking the class have very different learning objectives, and therefore the homework contains a mix of required and bonus problems, where the bonus problems are usually significantly more challenging than the required ones, but are tailored for people who really want to get deep into this stuff. The grading policy is extremely gentle and you essentially only have to score just half the points on the required problems to get an A-. The late day policy is also extremely generous (14 days), so it is quite a good class to take if you want some flexibility in your schedule.

  • ⭐ 15-751 A Theorist’s Toolkit, Ryan O’Donnell

    This class aims to prepare students for doing theoretical computer science (TCS) research in the future. It covers a wide range of topics that frequently crop up in TCS research (see the playlist below for a taste), and the homework is challenging but fun. I have been previously exposed to a number of the topics covered in previous courses, but still found many of the topics new to me such as spectral graph theory and semidefinite relaxations incredibly cool. It is usually only offered once every few years, so if you have any interest in doing TCS-related research I would highly recommend that you take the class.

    Recordings from a past offering of the course can be found on this Youtube playlist. It also includes recitation videos where Ryan goes through homework problems.

  • ❤️ 15-312 Foundations of Programming Languages, Jan Hoffmann

    The programming portion of the homework is the most fun part of this class. You will get to write typecheckers and implement the dynamics of various well-specified languages, starting from the simple lambda calculus to concurrent Algol (which is Golang-like). This class is great for appreciating language design and understanding the pitfalls and antipatterns that pervades most programming languages used in industry.

  • ❤️ 21-355 Principles of Real Analysis I, Robin Neumayer

    It is true that different sections of math classes taught by different professors are run like entirely different classes, so your experience with any math class highly depends on which professor you are with. I am really glad that I took the class under Robin, whose passion for teaching, and care and concern shown towards students (in one of the first few lectures she took some time to have everyone introduce themselves so she can know everyone on a more personal level), made me really enjoy the class and the subject matter. It also helped that she followed Rudin pretty closely, so anything that I was unclear about can be easily checked. Her weekly homework has reasonable difficulty and is quite fun.

    The pace of the course under Robin is faster than most standard analysis classes, where we covered up to Chapter 7 (Sequences and Series of Functions) in Rudin. I enjoyed the class so much that I wanted to take another analysis class in the future, which led me to take General Topology (21-651) in the subsequent semester. If you are interested in taking analysis, I cannot recommend doing it with Robin enough.

  • ❤️ 21-484 Graph Theory, Wesley Pegden

    The class was quite fast-paced and many times I felt quite lost during the longer proofs (some of them took multiple classes to prove). I definitely had to review the content after each lecture to get a better sense of the proof technique. However, this is more due to the complicated setup of many of the proofs. Wesley is a great teacher and I really appreciate how he would re-explain the key ideas many times in different methods so that we can understand them better. His exams are reasonable, and he will send out a review sheet between each midterm where you are only expected to remember the statements for some of the more complicated theorems, instead of being able to reproduce them fully.

    The textbook for the clas (Graph Theory by Diestel) is quite tersely written as it is intended for a graduate audience, so definitely do not miss lectures!

  • 15-819 Advanced Topics in Programming Language Theory, Robert Harper

    The class covered many advanced topics in PL theory where there isn’t much publicly available resources on, so when I got confused during lecture it was quite hard to find other materials online to supplement my learning. Very often I would end up on the nLab wiki, and I’m pretty sure anyone who has visited that knows that it’s not entirely the best place for beginners to understand anything.

    The class is offered pass/fail to reduce stress, and homeworks are assigned weekly. You will be asked to re-do questions that you get wrong as Bob really wants to make sure that you understand the material. I think I generally had a ok-understanding of what was going on in the class until the segment on logical frameworks, where it became very abstract. I still hope to rectify this gap in understanding someday when I have time, perhaps by playing around with Twelf.

  • 16-385 Computer Vision, Matthew O’Toole

    I took this class as a follow-up to Computer Graphics (15-462). Many computer vision techniques covered will abuse linear algebra heavily, so if you were not already an expert in SVD decompositions and making use of eigenvalues/eigenvectors for engineering, this course will definitely make you one. You will also get very comfortable with convolutions and some elementary Fourier analysis. A major part of the course also covers convolutional neural networks, which is the mainstay of many modern computer vision methods.

  • 18-358 Introduction to Amateur Radio, Tom Zajdel (AI6CU)

    To be very honest I was a pretty bad student for this course. Given the workload of my other classes, I had to skip many lectures and only studied extensively for the FCC licensing exam, because passing the exam is the only requirement for passing the class.

  • 70-350 Acting for Business, Evelyn Pierce

Units: 93

Fall 2022

  • ⭐ 15-859 CC   Algorithms for Big Data, David Woodruff

    Woodruff is one of the giants in sketching and numerical linear algebra, having developed many of its most important algorithms. There is even a sklearn function called the Clarkson-Woodruff transform that is named after him.

    His teaching is extremely clear as he makes sure to justify and explain every step used in a proof. The analysis for many sketching algorithms is highly non-trivial, but Woodruff manages to pull off explaining it in a way that reads like a storybook. He cares deeply about the class and the student’s learning, and one thing that still amazes me to this day is how he will respond to my Piazza questions on a weekend in 2 minutes consistently. I even made a meme about it.

    The homework problems are long but rewarding, and you will become initimately familiar with all sorts of linear algebra manipulations and properties.

    One caveat is that the weekly lectures are 3-hours with a 10-minute break in the middle. Given how dense the lectures are, this can be quite taxing, so bring snacks or caffeine if needed.

  • ❤️ 15-859 OO   Randomness in Computation, Pravesh Kothari

    I had limited exposure to most of the topics in this course (mostly from Theorist’s Toolkit 15-751, Graduate Complexity Theory 15-855, and Graph Theory 21-484) such as spectral graph theory, expander graphs, derandomization, etc, and this course helped to solidify and reinforce my understanding. It also proved a lot of things that did not have time to be proved in those earlier classes. Overall I felt that Pravesh is a great lecturer, and the topics covered are very interesting and applicable. The course was offered for the first time this semester, so there were a few rough edges (i.e in the proof of Cheeger’s inequality he initially did not want to prove it in terms of the Laplacian of the graph to avoid introducing new concepts and notations, but doing so ended up being more confusing than helpful), but overall it is quite a good class. The homework problems are reasonable and the workload is on the lighter side.

  • ⭐ 10-708   Probablistic Graphical Models, Andrej Risteski

    This class has a reputation of being one of the hardest ML classes, but I think it is actually an excellent class that is very well-taught, so I hope that this reputation does not discourage people interested in the content from taking it. The class can be categorized into three module: representation, inference, and learning. In the representation module, you will learn about how joint distributions of several variables can be represented efficiently by various models, taking into factors such as causal relationships. In the inference module, you will learn that sampling from such models is very hard in general (assuming \(\P \neq \NP\)), and develop probabilistic ways of sampling from them such as Monte-Carlo Markov-Chain and Variational Inference methods. In the final module, you will learn how such models can be fitted to training data. Graphical models form the backbone of many modern machine learning techniques like generative adversarial networks (GANs) and diffusion models, and the way that Andrej teaches all of these topics in a rigorous way to provide a solid mathematical understanding of how they work is essential for keeping up to date with the state-of-the-art in this field.

  • 15-784   Foundations of Cooperative AI, Vincent Conitzer, Caspar Oesterheld, Tuomas Sandholm

    I did not enjoy this course as much as I would have liked for several reasons. The way that the content was presented was relatively hand-wavey, the slides are not very organized, and there are many slides which are essentially summaries of papers that the professors wrote, which made it too high-level to be able to concretely understand anything. That said, the course is being offered for the first time, so it will probably improve in subsequent iterations.

  • 10-617   Intermediate Deep Learning, Ruslan Salakhutdinov

    Ruslan is one of the household names in the machine learning community (he invented the Dropout technique to prevent overfitting which is now standard in neural network architectures), and I was very excited to be able to take this class with such a legend in the field. I really enjoy his lectures, and he made many remarks about what was happening in the field when various techniques were being introduced as he was introducing them, which really gives you a sense of how the field has evolved over the last few decades from a man who has seen and been through it all.

    However, I think the course infrastructure requires more improvement. Some of the starter code for the assignments are quite poorly written and contain many inconsistencies and wrong/outdated documentation, which leads to a fair amount of frustration from students. One particularly annoying inconsistency was how the data formats of their starter code were transposed from Homework 1 to Homework 2. My guess is that someone tried to update the assignment but did not have time to fully go through to fix all the inconsistencies before it was released.

    Many people ask about whether they should take 11-485/785 (Introduction to Deep Learning) offered by the Language Technologies Institute (LTI), or this class offered by the Machine Learning Department (MLD). The main difference is that 11-485/785 is more hands-on and practical (most assignments are working on Kaggle datasets), whereas 10-417/617 is more theoretical.

  • 10-703   Deep Reinforcement Learning, Katerina Fragkiadaki

    After the middle of the semester, I found it pretty hard to focus and understand what is going on in the class. I also frequently found it hard to understand the professor’s explanations, and she speaks very quickly. I think a big reason for my confusion is that the class assumes that you have done the paper readings before each lecture (my workload meant it was infeasible for me to do that), and so I gained very little from lecture. So please avoid my mistake and do your readings before the lecture if you take this class!

    The homework for this class is really fun as you get to implement reinforcement learning algorithms for agents in various OpenAI Gym environments. All assignments are done in groups of up to 3, so remember to grab a friend or two if you’re taking this class.

  • 21-651   General Topology, Florian Frick

    This class generalizes many concepts that is taught in an undergraduate analysis course from metric spaces in \(\mathbb{R}^n\) to arbitrary topological spaces. It took some time for me to un-learn some of the things that I implicitly assumed was just always true, i.e while in a metric space you learn that all sequences contains a convergent subsequences in compact sets, this is no longer true in arbitrary topological spaces. Much of the content have connections and parallels to other deeper areas of mathematics, which I found very beautiful.

  • 17-603   Communications for Software Leaders I, Dominick (Nick) Frollini

    This course felt like an MBA class. It is a required class for Masters of Software Engineering (MSE) students, and one thing that I did not expect was how much the course was geared towards international students (i.e there was quite some emphasis on what is appropriate for US customs and norms), which is understandable as most of the MSE students taking the class are international. I found the segments about how to give oral presentations useful, but did not gain as much from other topics, in particular those concerning written communication.

  • 15-604   Immigration Course, Dave Eckhardt

Units: 90

Some CMU-Specific Things

This FAQ is mostly geared towards people who are unfamiliar with CMU.

How does the course numbering work?

From a note regarding course numbers:

Each Carnegie Mellon course number begins with a two-digit prefix which designates the department offering the course (76-xxx courses are offered by the Department of English, etc.). Although each department maintains its own course numbering practices, typically the first digit after the prefix indicates the class level: xx-1xx courses are freshmen-level, xx-2xx courses are sophomore level, etc. xx-6xx courses may be either undergraduate senior-level or graduate-level, depending on the department. xx-7xx courses and higher are graduate-level. Please consult the Schedule of Classes each semester for course offerings and for any necessary pre-requisites or co-requisites.

Here are some of the common ones that you will see as a CS major:

  • 15-xxx: Computer Science
  • 21-xxx: Mathematical Sciences
  • 02-xxx: Computational Biology
  • 05-xxx: Human-Computer Interaction
  • 10-xxx: Machine Learning
  • 11-xxx: Language Technologies Institute
  • 16-xxx: Robotics
  • 17-xxx: Institute for Software Research
  • 18-xxx: Electrical & Computer Engineering
  • 98-xxx: Student Led Courses

Overload Policy

In the School of Computer Science, students have a unit cap of 54. Unit overload requests must be submitted to your academic advisor, contingent on past academic performance.

First-year students are not permitted to overload.

What are StuCos?

Student Taught Courses (StuCos) are low-stress classes taught by other fellow students. They are pass/fail, and are always 3 units each. These are usually fun and interesting topics, such as lockpicking, stand-up comedy, esoteric programming languages, etc.