o/ this is a work-in-progress to make a page of course reviews with opinions from lots of current students about courses (mostly related to SCS). If you’re a current student and want to contribute, feel free to reach out and I’ll add your reviews! Courses with a ⭐ icon are courses that I personally enjoyed a lot <:

(also insert shameless plug for 98-012, Fun with Robots & 98-043, Chess Tactics and Strategy, taught by myself and @ChessDouDou respectively)

Courses listed by department

Computer science courses (07-XXX, 15-XXX)

Math courses (21-XXX, 36-XXX)

Computational biology courses (02-XXX)

Machine learning courses (10-XXX)

Science courses (03-XXX, 09-XXX, 33-XXX)

Engineering courses (18-XXX, 19-XXX)

General education, StuCos, and other (XX-XXX)

First year writing courses:

Other:


– Actual course reviews –

Computer science courses (07-XXX, 15-XXX)

07-070 - Teaching Techniques for Computer Science, Charlie Garrod & Kelly Rivers

(Spring 2024, chessdoudou)

  • Rating: 4/5
  • Difficulty: 1/5
  • This is a class meant for first time CS TAs, where you learn some things about TA/teaching in general. Charlie and Kelly both have a lot of passion for the class, and it’s still a work-in-progress. I think it’s worthwhile to take since it’s only a couple hours a week and the case studies are fun.


07-128 - First Year Immigration Course, Tom Cortina & Veronica Peet

(Fall 2023, kale)

  • Rating: N/A
  • Difficulty: N/A
  • There’s not much to say / rate about this course since it’s required for everyone. Most of it is informative “how to be a SCS student” sort of content. There was free backpacks and merch sometimes (:


(Fall 2023, matchacastella)

  • Rating: N/A
  • Difficulty: N/A (the final is fake)
  • I have nothing to add to what kale said except that I thought the part where they talked about the different majors, and the part where they talked about some of the opportunities (research, study abroad) was a little useful. Also I missed the lecture during oweek where they gave out backpacks :(


(Fall 2022, jackowacko)

  • Rating: N/A
  • Difficulty: N/A
  • Course that forces you to listen to lectures about the SCS program and pitches from various departments, which is a bit unfortunate if you already surf CMU courses and degrees on the website for fun. The one memorable pitch I remember from this class was the sample computational biology lecture by Compeau who POPPED OFF and was the moment I seriously put the comp bio lab on my radar. There were also some lectures about resources on campus like tutoring, health services, research, etc which are good to remember to exist if you ever need them. Also some free merch.


07-131 - Great Practical Ideas for Computer Scientists, Tom Cortina and Veronica Peet (in theory)

(Fall 2023, matchacastella)

  • Rating: 3.5/5
  • Difficulty: 1/5
  • Despite officially being listed as being taught by Veronica and Tom, all instruction is actually done by the TAs. Thus, it functions much more like a StuCo than an actual class - including the fact that it is not intended to be difficult.
  • This is basically a small seminar on a few tools of the trade: git, vim, LaTeX, and shell scripting. To be honest I thought the second half of the class (all the shell scripting parts) was basically useless until I wrote a script to automatically scp and untar my 150 assignments. Then I realized it was actually somewhat useful.
  • I will say that the final lecture was very cool. However idk if Kyle will still give the same lecture next year sooooo


15-122 - Principles of Imperative Computation, Iliano Cervesato

(Spring 2023, KT)

  • Rating: 3/5
  • Difficulty: 2/5
  • With my only previous programming experience being in APCSA, I actually didn’t know most of the content in 122 before I started taking the course. Thus, I consistently went to lecture, and I don’t think Iliano’s a bad teacher at all. He’s definitely dry, but he delivers the content well enough. If you don’t go to lecture, there are lecture slides and comprehensive lecture notes that you can learn from. In terms of the homework, I thought the writtens were boring but not too difficult, and the programmings were mostly fun and pretty straightforward. I think the best piece of advice I can give for this class (and other CS classes too) is to always think before you code. If you think first and maybe draw a few pictures if needed, you’re less likely to write a bunch of buggy, spaghetti code. I know some TAs of 122, and they really do want you succeed, but you need to make use of the resources you are given if you are struggling.


(Fall 2023, chessdoudou)

  • Rating: 5/5
  • Difficulty: 3/5
  • I felt that this was the best class I’ve ever taken up to this point in my life. There are so many resources and opportunities to learn the information, and the content was super interesting. My favorite part of this class was the programming assignments, which were super rewarding and fun to do (especially the bonuses)! I personally thought Iliano was a fun lecturer as well. As a current TA, I present my completely unbiased and objective opinion that you should take this class. It’s a challenging class, but with time management and respect for how long the assignments take (as well as reaching out for help!), you can definitely succeed.


(Fall 2023, Dennis Chen)

  • Rating: 2/5
  • Difficulty: 2/5
  • 15-122 has the unenviable position of teaching a potpurri of (imperative) programming concepts, so the content is not organized as well as you might like. However, on the plus side, the materials are fairly thorough: unlike some of the other classes (math especially), you will never need to look outside of the course materials to learn a concept. (Footnote: Whether this is actually a good thing is up for debate. I, for one, think it is good to expect students to do their own research and enjoy taking courses where the syllabus isn’t just “precisely what was covered in class.”) Iliano is notorious for being a poor lecturer, but I personally thought he was alright. Not the absolute best lecturer I’ve ever had, but passably good.
  • Now for the minuses. And there are a lot.
    • The writtens (i.e. “fill in info here” worksheet style assignments) are kind of utter bullshit. A lot of fill-in-the-blank questions, with the worst traits of them exemplified (e.g. four things make sense here, but you need to guess which three the course staff want you to use), and not much value gotten out of it.
    • The programmings are merely ok. Nothing inspiring, but not horrible.
    • Don’t get caught cheating. Seriously. This class hands out a lot of AIVs (Academic Integrity Violations), and you are hosed if you get one. Two and you are expelled. Seriously, just don’t.
    • The tests are the WORST. The format is the same as the writtens, but with the added component of time pressure. Understanding the concepts is not enough to ensure a good grade; you have to actually be good at the exam format. No other class I’ve been through has had exams as unfair, and even much harder classes have fair exams. (This class was the only class I ever consistently got Bs on in exams, despite — in theory — being the easiest of them.)
  • In particular, if you are aiming for an A, you should only aim to do OK on the exams (in the 85-90 range; even 80 might be fine). The way grading works, homework will more than make up for it.
  • The content itself is not extraordinarily difficult, but it is something to pay attention to, particularly in the second half of the semester. If you have prior programming experience, especially in C, it may very well be a cakewalk. But for most people it will work the brain, though hopefully not fry it.


(Fall 2023, matchacastella)

  • Rating: 2.5/5
  • Difficulty: 3.5/5
  • This is a relatively standard data structures course. My hot take (which is somewhat parroted from KT) is that contrary to what a lot of people say, Iliano isn’t the worst professor out there. He is rather strict, but generally he’s also very by-the-book - for better and for worse. That’s where most of his strictness comes from - he basically abides exactly by the letter of the syllabus, and also gets rather snippy about it. Same underlying principle with questions - if you ask a basic question that he covered in lecture, he’ll probably wave you off and act annoyed. If you ask a deeper question, he’ll actually get into it and explain stuff.
  • Iliano’s perspective on things is that realistically, you are one of 500 students in his class. He will probably never recognize you even if you actually go to lecture, and thats ok. He’s not there to be memorable or to be nice to students; he’s there to drill this information into your mind. Honestly, I kind of respect it.
  • That all being said, there’s a reason why his ratemyprofessor is 1.9/5. In addition to being a bit of a rude wake-up call to college, he also isn’t a particularly noteworthy lecture (excluding the one lec) the first week or two, the lecture hall will be packed. then it will thin out to be, idk, roughly half-full? as the semester wears on. this is partially because he has the morning lecture and 8 ams suck, and partially because to be frank the lectures are pretty skippable and the review slides are just better.
  • that brings me to what the saving grace of 122 is: its extraordinarily well-organized, which you don’t really appreciate at first but definitely grow to appreciate as you go through some courses that are…. less organized. there are a very large amount of resources available for you, the student, to teach yourself everything instead of actually going to lecture. The review slides are excellent (arguably better than the lecture), and in addition there are also past lecture notes written by Frank Pfenning, an OLI course, and the help of an army of TAs (although, a common pitfall is to go to the TAs immediately when you run into any sort of difficulty on the programming. please do not do this. please do the bare minimum of print debugging and test cases).


(Fall 2023, saffron)

  • Rating: 4/5
  • Difficulty: 2/5
  • Om nom nom scrummy class. I should preface this by saying that I loved coding at the time (and still do), and I was a Dietrich major taking a lighter workload than a comparable SCS student. So, I both had the willingness to code my silly little problems and the time to spend on doing so. I feel like my difficulty rating is very much because this is a class where the programmings take a lot of time, but aren’t technically that hard beyond normal coding problems like debugging. I’ve heard it described as how progs can be completed with just enough time thrown at them versus other classes’ psets that might just be very conceptually hard.
  • Like many others, I also replaced going to lectures with the given lecture notes (written first, then the slides if I wanted to review). Also, yes, please do think first before coding. Draw pictures and conceptually understand the problem statements as/before you begin coding, don’t blindly throw spaghetti at the wall. This worked for me.
  • Maybe I just got stockholm syndromed into liking it though, idk.


15-150 - Principles of Functional Programming (Multiple instructors - see below)

(Fall 2023, KT)

  • Instructor: Steve Brookes
  • Rating: 2/5
  • Difficulty: 3/5
  • 15150 is not a terrible course, but for a course named “Principles of Functional Programming,” it sure does a terrible job at showing me why functional programming is cool and why I should care about the paradigm. The difficulty of the programming homeworks stems from the fact that you have to do them in SML, which makes for a frustrating experience because many of these problems are relatively simple in an imperative language. And although the homeworks have different topics each week, it all really just felt like different flavours of recursion. So yea, if you can’t already do recursion or wrap your head around it in the first few weeks of class, tough luck buddy, but I think you might be screwed.


(Spring 2024, chessdoudou)

  • Instructor: Dilsun Kaynar
  • Rating: 3.5/5
  • Difficulty: 3/5
  • While I found SML to be a very neat and interesting language, I can’t say the same for the course. I didn’t really pay attention to most of the lectures, and I found the last few homework assignments to be quite boring and tedious. Still, SML is cool and functional programming is fun, plus the exams are quite easy compared to the homeworks.


(Spring 2023, jackowacko)

  • Instructors: Karl Crary, Michael Erdmann
  • Rating 2/5
  • Difficulty 3/5
  • You love it or you hate it. There’s no middle ground. Its value as a course depends on how well it sells the functional programming paradigm to you and how much you end up appreciating the elegance and problems. While I can see how someone can appreciate the FP the class teaches you, to me the class leaves a lot to be desired.
  • I’m going to pull a certified classic of surrendering my illusion of free will to the opinions of KT and repeating their sentiment that it doesn’t do a good job of making me interested in functional programming and leaves me confused on how to apply it. The class runs on bare pure FP, and so while I’m now comfortable writing code and writing proofs about it in a pure-functional syntax, that skill set doesn’t generalize. If I’m writing code in an imperative setting (which I imagine I will be doing pretty much all of the time out of CMU), I have no clue how anything I’ve learned in 150 applies.
  • I guess a more dubious way to phrase my wishes is “make 150 a software engineering class”, but I wish I had learned why I should care about immutability or minimizing side effects, or how functions can represent complex systems more cleanly than imperative code, or how do I practically apply its ideas in conjunction with imperative code. What 150 taught me was SML-specific organization syntax (modules), or advanced stylish recursion techniques I have no clue how to apply (CPS), or how to do imperative programming but literally just worse (ref cells).
  • I can’t say for sure, but to me, the class feels like more “prerequisites you need to know to pursue PL (programming languages) theory classes, and for like a little bit of 210.” Maybe 150 pays off if you end up taking more advanced PL courses in the future, but a majority of students will never show interest in these topics, let alone take the courses. Maybe CMU likes exposing you to new areas of theory like 251 does, but while 251 makes up for not being directly useful by being interesting, rewarding, and encouraging a new meaningful perspective, I just cannot say the same about 150.
  • I can litter in some small micro-level nitpicks to justify why I don’t feel like 150 was rewarding; slow lectures/labs, the occasional focus on SML-specific behavior, the occasional BS proof, obsession over details that I really think should be handwaved (mostly totality like why do I care about totality). Maybe I just like algorithms more but the functional programming philosophy I think 150 was trying to push was not captivating, tarnished by being forced to reason about excessively simple ideas under forced constraints in a “stateless, immutable, no-for-loop” FP setting.
  • My biggest complaint by far though is that the class didn’t teach me a thing about how a monad is a monoid in the category of endofunctors. Completely unacceptable. https://www.youtube.com/watch?v=ADqLBc1vFwI


(Fall 2023, Dennis Chen)

  • Instructor: Steve Brookes
  • Rating: 4/5
  • Difficulty: 2/5

The good

  • This class teaches you an entirely new paradigm of thinking. I’d already seen many of these ideas before, but it was cool to see some of them implemented in practice. And many other ideas I had not seen before. HOFs and CPS were incredibly cool, and seeing how SML (an eager language) could also exploit lazy evaluation was very interesting too. The TAs are incredible too: all of them are knowledgeable and passionate about the course, are very kind-hearted, and are exceptional at explaining things.
  • Because functional programming is really cool, a lot of people have devoted time to writing out amazing explanations of the core concepts (CMU people in SML, some other universities in OCaml, and normal people in Haskell). A few examples:
  • So you can learn functional programming from plenty of sources, and I strongly recommend you mix and match to get a more complete understanding.

The bad

  • But there are a few kinks to be ironed out. For one, very few people go to lecture, so “lab” (which is largely a review session) is usually painfully slow. (I’m unsure what can be done about this, and I hear it gets better in the spring, but this is still a pain point.) There also seems to be very little communication between the TAs and the professor, so the professor just says words and the TAs run the brunt of the course. This means that you will just randomly have very hard problems on homework assignments (the worst offender being Datatypes 5.5), but honestly in retrospect nothing was absurdly unreasonable. Still though, it’s utterly hilarious that the TAs can just do whatever they want and the professor will have no clue.
  • Also, Games is somehow the least fun I’ve had in any class so far this semester, despite “Games” being the name.

The ugly

  • Now, for some more substantive criticism than “course administration is janky”. Unfortunately, this is moreso “what I didn’t like” (and what you will not like if you already have background in FP), rather than “here is what the course should do”. This class is far too applied, in the sense that problems look more like “solve genuinely tricky problems with these tools” rather than “learn the theory behind functional programming” (of which there is a lot).
  • Some things I expected to see but did not:
    • Formal logic
    • Monads
    • Type theory
    • Category theory
    • Curry-Howard Isomorphism
  • Granted, it would be really bad if 15-150 just became “crazy PL stuff exactly 3 people would benefit from”, and objectively, the correct response is “OK just go take more PL courses”. But if you’re one of those three people, be prepared to be very ambitious. Email the 15-312 professor and ask if you can sit in or something. (I know someone who tried to skip 15-150, with really strong reason to, but in short — good luck with that.)


(Spring 2023, A) ⭐

  • Instructors: Karl Crary, Michael Erdmann
  • Rating: 1/5
  • Difficulty: 3/5
  • Taking this course feels like learning to walk after having your legs amputated below the kneecap, for no apparent reason. The curriculum forces you to adopt functional programming, which essentially means programming without loops (Why cant we use loops? Masochism? “provable” code that you would never actually prove if it wasnt required for the homework? Who knows?). It’s as if they’re taunting you with the simplicity of loops, only to snatch it away and make you hobble along with their convoluted paradigm. Every assignment feels like a cruel joke, where you could easily solve the problem with a single loop, but no, you must contort your brain to fit their masochistic standards. And don’t get me started on the amount of LaTeX you have to write to prove your code works. For every line of code, you write three lines of LaTeX. It’s like the actual code (written in the warcrime known as SML) is just an afterthought. In short, if LaTeX is your love language, this course is your soulmate. Otherwise, brace yourself for a semester of intellectual contortionism.


(Spring 2024, matchacastella)

  • Instructors: Karl Crary, Michael Erdmann
  • Rating: 4/5
  • Difficulty: 2/5
  • One of my major issues with 122 as a class is that it never really feels clean or elegant. The general pattern of doing a 122 programming assignment is you do an initial solution, you see it fails on a bunch of autolab test cases, you go all over the place writing test cases and inserting print statements, and eventually you fix everything and out pops a vaguely working program and you can breathe a sigh of relief. It’s not particularly fun.
  • 150, in contrast, feels elegant right from the beginning. To begin with, 150 is inherently about an entirely different style of programming and reasoning about problems compared to 122, and compared to what you’ve most likely seen before. This is because 150 is about functional programming.
  • But what exactly is functional programming? Well, to understand what functional programming is and why it’s useful, we need to look at its opposite - imperative programming, as in 122. The imperative model is that a program is essentially a set of steps telling a machine to do things. You can tell it to change variables, repeat a certain action a certain amount of times, and so on. Inherently, what an imperative program does is it modifies state - which is a general idea of what everything in the program is doing at a given point.
  • The nice thing about the imperative model is that its conceptually pretty easy to understand. You have a machine and you give it commands, simple as that. The problem with the imperative model is that it’s a total mess to reason about anything. Because from any part of the program, you can modify any other part of the program. This means that you cannot guarantee that any given function will produce the same output when run twice on the same input.
  • To use an analogy from Brandon Wu (former summer instructor for 150, “150man”), imperative programming is like a kitchen where every chef shares the same cookware. This means that individual chefs can mess with each other, and in general you have no idea what’s happening in the kitchen if you aren’t careful.
  • Functional programming solves this by telling the chefs to shove it and do only their own things. The central idea of functional programming is that functions are “pure”. Unlike the imperative model, functions cannot modify state - all they do is take in and return values. Thus, on the same input, a function will return the same value - just like a mathematical function. So instead of the individual chefs getting all over each other’s ingredients, the chefs finish all their work and then pass it on to the next chef - much more clean!
  • Like 122, 150 also has proofs; unlike 122, these proofs are actually pretty real - in the sense that you do actual mathematical reasoning, and not “uhhhh it seems like there are at least three things that would be reasonably correct here so I guess this is the one the TAs probably want”. This comes from the nature of pure functions - you are guaranteed that functions return the same output given the same input, so you can actually reason about the correctness of code.
  • The primary downside to 150 is that the lectures aren’t actually all that great. The professors (Erdmann and Dilsun) are incredibly sweet people! They’re really, really, nice! They just talk at roughly 2 words per minute, which is very unfortunate.
  • Luckily, Brandon Wu has lectures for the entire course available online. I highly, HIGHLY recommend his lectures. They’re much faster paced, cover more content in less time, are more engaging, and he even has infinitely better graphic design!
    • There are also many other auxillary online resources, such as SMLHelp and Bob Harper’s Programming in Standard ML (this specifically is probably overkill, however).


15-151 - Mathematical Foundations for Computer Science, John Mackey

(Fall 2023, kale)

  • Rating: 4/5
  • Difficulty: 1/5
  • This is your standard intro-to-proofs course and is cross-listed as 21-128 Mathematical Concepts and Proofs for non-SCS students. I had a pretty strong math background from high school (i.e. I did not learn a single new thing from this course the entire semester) so I don’t have much to say. It covered basically all the content I expected from an intro course so I think it’s a pretty good course (oh and Mackey is an amazing lecturer, etc, etc.). I think this is probably the most important course to do well in because well, all of CS is really just built on math… (and some call it an ego-check for SCS students, which has been true for many people in my experience)


(Fall 2023, matchacastella)

  • Rating: 4/5
  • Difficulty: 4/5
  • Discrete math is something that’s absolutely foundational in any CS curriculum. But it’s also something that is not particularly standard in high school math curriculum. Some people (see: kale) come in with a lot of experience. Me personally, I had basically no experience with discrete math outside of the probability and combo stuff I learned for math competitions. (except I wasn’t particularly good, so even that is not a lot…)
  • CMU tries to level this out with Concepts. From the formal course description, it’s your standard course in discrete math - sets, functions, relations, a bit of discrete probability and combinatorics, etc. But that’s not the main purpose of Concepts, necessarily. The main purpose of Concepts is to teach you to write proofs, and as a general crash course in mathematical maturity (which in turn prepares you to take higher level math and theory courses such as 251 down the line).
  • With all that being said, Concepts was definitely my favorite class freshman fall. However, be warned - generally, unless you already have significant proof experience, you will struggle for the first few homeworks. This is partially because the TAs are definitely significantly more pedantic on the first few homeworks, but also because there really is a significant difference in rigor between any previous math course most ppl have taken (eg, Calc BC), and Concepts.
  • Anyway, once you get over the hump of the first midterm and get into the flow of things, the course becomes much more fun. Mackey is a fantastic lecturer (with rather, um, interesting stories) and both he and most of the TAs are very passionate about teaching.
  • That said, Concepts is absolutely a course that demands much of your time and resources throughout the semester. One of the best ways to be prepared is to START EARLY. With most math courses you might have taken in the past, time spent on course is generally linearly related to work done on course. This is not the case at all with Concepts. There are many times where you’ll be stuck on a proof for an hour or two, only to find that the solution was right in front of you the whole time.
  • Thus, the most efficient way to do Concepts is generally NOT to start it a day before it’s due (I know from experience). The best way to do Concepts is to read over the problem set as soon as it’s released (usually a week before it’s due) and just let the ideas marinate in your head.


(Fall 2022, jackowacko)

  • Rating: N/A
  • Difficulty: N/A
  • I would write an actual review here but having two out of the three 151 reviews just be “class easy lol” would probably be extremely disproportionate to the actual collective sentiment over all of SCS. matchacastella’s review covers most of the big opinions and advice that I would want to include. I don’t remember too much about the class other than Mackey condoms lecture anyways.


15-195 - Competition Programming I, Daniel Sleator

(Spring 2024, chessdoudou)

  • Rating: 5/5
  • Difficulty: 3/5
  • Free pizza 😋😋😋 but the difficulty of the problems depends on who sets them, which changes often. A good strat is to just come to class and eat pizza and solve problems without being officially registered.


15-210 - Parallel and Sequential Data Structures and Algorithms (Multiple instructors - see below)

(Spring 2024, KT)

  • Instructors: Umut Acar, Danny Sleator
  • Rating: 4/5
  • Difficulty: 4/5
  • If 150 is the tunnel, 210 is the light. As someone who enjoys thinking about brain teasers and algorithm problems, I found the programmings really fun to think about (albeit much less fun to implement in SML), and many of the written homework problems were surprisingly interesting to solve as well. I also like 210’s bucket system because it encourages you to understand the big picture without stressing about small details.
  • The main difficulty of the course stems from its exams, whose averages often fall in the 60s. 210’s exams are the hardest of any class I’ve taken because there isn’t a specific formula to the problems; you just need to understand the techniques and be able to apply them when needed.
  • As for the professors, I think Professor Umut Acar went on tangents too often, and Professor Danny Sleator was just okay. Most of my learning happened in recitation, which is taught by some wonderful TAs, or as I was looking through the textbook.
  • Anyways, this course was so interesting I might just give functional programming another chance…


(Fall 2023, jackowacko)

  • Instructors: Charlie Garrodd, Guy Belloch (spent 10+ hours writing this review but too lazy to check if my spelling here is right)
  • Rating: 2.5/5

  • Difficulty: 3/5

  • 150 walked along the winding path of functional programming in the hopes that 210 could run. I held some high hopes going into 210; it’s a coding and algorithms class, which given my strengths suggests that on paper, I should have enjoyed the class and taken curiosity in it. And having come out disappointed with the direct takeaways I got out of 150, I hoped that 210 could teach me to appreciate the magic of FP that 150 told me but failed to show me.
  • What really happened was that 150 walked so 210 could lightly kick me in the shins. While 210 usually generally did not give me too much trouble most of the time, and I will always feel some reward from designing algorithms, that’s basically all of the good I have to say about this class; issues with the class content and design resulted in me not really enjoying it and left little desire to learn more.
  • Let’s start with the so-called “light” of 210: its promise to bring real purpose and appreciation to the FP paradigm. 210s sort of “opening pitch” is that you learn to parallelize algorithms, i.e. write algorithms that can take advantage of multiple processors. And functional programming is championed as the ideal way to write parallel code, since you can break down an algorithm down into multiple function calls which are automatically assigned to multiple processors, and by the stateless/no-side-effect virtue of FP these functions don’t need to interact with each other.
  • I’ll admit, it’s a clean way to write parallel code. To be fair, I’ve never tried to optimize algorithm parallelization in an imperative language, so I don’t know how much cleaner it is in FP than imperative. But I did find the divide and conquer paradigm interesting and the algorithms I had to design felt new and unique, and so I felt like I was learning something.
  • The light didn’t last long. The FP parallelization hype died with divide and conquer. They spent a good 2-3 weeks on it but past that, the praise I gave regarding 210’s interesting content on parallelization faded away. It’s not like they completely abandoned the idea of parallelization, but it started getting more and more irrelevant. It eventually just started feeling like footnotes; “oh btw, this algo has a lower span complexity (i.e. benefits a lot from parallelization), maybe that fun fact will pop up on the final”. Maybe I’m not adequately appreciating that FP improves the parallelization of algorithms for free when this would be a lot of work in an imperative language, but it didn’t feel like parallelization was ever actually that useful because I never really observed its positive impact.
  • To 210’s credit, there was an attempt! Enter wafflelab competition, which was created to encourage and reward people for writing code optimized for parallelization. I won a prize for 3rd place, outplacing many people who carefully optimized their algorithms for efficient parallel usage…by writing effectively zero parallelism optimization and instead writing a funny “heuristic” algorithm that was sometimes (randomly) wrong. Long story short, from my perspective, wafflelab’s purpose backfired; honestly, much to my delight, because writing my algorithm was a hilarious exercise in creativity. And I think it says something about a class if some of the most fun I had in the course was writing an algorithm proving some of the course’s core tenets wrong.
  • I didn’t talk much about 150’s strange class/lecture structure in my 150 review, but 210 took the questionable and sort-of-off-topic lectures from its predecessor, and essentially double downed. 210 tries to “teach two different classes at once”; one with the homeworks, and one with the lectures. In other words, the lecture content has almost nothing to do with helping you with homeworks, and instead goes off into some opposite direction where the lecture content won’t come up again until the next test. I’ve seen this trend in some higher level classes too, but I think 210 is the worst offender and combined with a 9:30 class time makes 210 lecture probably the class I’ve skipped the most.
  • Both the lecture content and the homework content of 210 ended up feeling really shallow because of this. Actually whatever material was presented in lectures was worse than shallow, it might as well not exist, because I don’t remember any of it from the lectures I did attend. Without homeworks to reinforce my understanding or show me the potential applications of these ideas and algorithms, on top of the lack of incentive/reward for learning them to do well in the class, meant that the only role of class material was to be an extra thing to cram in for the test and then immediately forget.
  • With the absence of meaningful lectures for support, the quality and depth of homeworks also suffered. There would be a minimal amount of content, techniques, and patterns you would really need to know beforehand for the homework, and so the homework would just be reinforcing those few shallow ideas. It didn’t help that my prior experience in algorithms meant that I already knew some of these topics, or just found them too simple/familiar to be interesting. To me this made the homeworks seem unoriginal and haphazard; many didn’t have anything that made them unique or made me feel like I was learning something new I wouldn’t learn outside of 210.
  • If I wanted to just crack brain teasers and do generic algorithmic problem solving without any sense of direction or innovation, I’d probably get higher quality problems and learn more from a competitive programming focused website like Codeforces, or heck, even Leetcode. A 210 TA once said “I think the best way to practice [for 210] is to just do a Leetcode every day”. And look, I’m not saying leetcode student premium is a good deal or anything, but $99 a year is a lot cheaper than what CMU wants to charge you for 12 units.


15-213 - Introduction to Computer Systems (Multiple instructors - see below)

(Spring 2023, A)

  • Instructors: David Andersen, Brian Railing
  • Rating: 4/5
  • Difficulty: 4/5
  • This is a rather broad introduction to systems. It provides a basic understanding of basic system concepts such as assembly, cacheing, memory allocation, multiprocessing, etc. The concepts themselves are not too complex, but the workload is quite large for this course. Each assignment is due in about 2-3 weeks, and is a rather long programming assignment, so time management is very important to get everything done on time. I would recommend this course for people who are going into CS-related fields, even if they are not doing systems specifically, as provides foundation of systems knowledge that is useful across many fields.


(Fall 2023, Joshua Charat-Collins)

  • Instructors: Brian Railing & Philip Gibbons
  • Rating: 5/5
  • Difficulty: 3.5/5
  • Provides intro to a bunch of different systems concepts. Skips around, focuses primarily on details of implementations with some lesser emphasis on theory behind those implementations (i.e. here’s how virtual memory works on UNIX systems, and here’s why it’s done this way).
  • Uses CS:APP textbook. A lot of other colleges have courses based on this book (and also on 213), so at least by peer consensus this has to be a good class.
  • Mixture of both general systems concepts (virtual memory, memory allocation, processes, now covers filesystems but didn’t when I took the course, permissions and authorization systems, concurrency and parallelism, caching) and specifically C/UNIX/POSIX libraries stuff (implementing malloc, implementing a proxy, implementing a shell)
  • Very hard if you don’t read documentation, including lab writeups and the textbook. If you read docs (writeups, textbook, manpages), class becomes a lot more manageable. Without reading all relevant documentation as soon as it becomes relevant, you will likely have a very hard time implementing things correctly and efficiently on the first try.
  • Also very hard if you operate on a “write now, fix later” basis with respect to bugs. Use the skills you learned in 122 to ensure your code is fail-fast (i.e. adding pre- and post-conditions to literally everything). Your brain is not a CPU, so don’t make it try to be one. Invariants will also help you reduce helper functions and other subsections of code to easier-to-process behaviors that you can mentally cache, which prevents you from having to look up what something does later.
  • If you read documentation thoroughly (especially for things like ShellLab and ProxyLab) and program using best practices (and are generally somewhat adept at bugfixing), this class is not as hard as people make it out to be.


15-251 - Great Ideas in Theoretical Computer Science (Multiple instructors - see below)

(Spring 2024, kale)

  • Instructors: Anil Ada, Feras Saad
  • Rating: 3/5
  • Difficulty: 3/5
  • Some courses are hard and useful, and others are easy but useless. 15-251 hits the amazing “sweet spot” (/s) of being hard and useless. Personally, I like hard and useless things, and the lectures for this course are entertaining. The unique thing about 15-251 is that the homework is presented in the form of “writing sessions,” meaning you first solve the homework, and then meet once a week on Wednesday night and write up a subset of your solutions in 80 minutes. This forces you to actually understand the material to some capacity, so while I personally am not a fan of it (since it involves me spending more time on the course), I think this is a good decision from a teaching standpoint.
  • This course also teaches you how to collaborate and work with others through GROUP problems on homework where they encourage you to work in a group of 4 students. I think this is a pretty common trend among the SCS core, and it’s very nice. I personally feel like 15-251 is a math course masquerading as a CS course (and iirc (I’ve been told this is true now) math majors can take it in place of 21-228 Discrete Mathematics).
  • As a side note, the course mascot is a giraffe named Cilantro. I’m allergic to Cilantro. This course was not made for me.


(Spring 2024, Dennis Chen)

  • Instructors: Anil Ada, Feras Saad
  • Rating: 3/5
  • Difficulty: 2/5
  • This course is one with a lot of variance: some people absolutely struggle while others think it is the easiest class they have taken in their life. Full disclosure, I am in the latter group.
  • kale has explained the logistics so I won’t duplicate her explanation, beyond adding one thing:
  • you may elect to replace 5% of your homework grade with attendance.
  • I strongly recommend this. We do not all have the willpower of a demon to be on top of things all the time, and it is somewhat good to have the decision made for you. I will say that lecture tends to be fairly slow (I actually think this course is slow), but I find it helpful. I’ll explain why going attendance-mandatory is such a good idea:
  • You’ve already taken a semester at CMU and have some idea of your academic strengths (unless you skipped Concepts and linear algebra, in which case the second description below applies):
    • Either you’d struggle in this sort of class, in which case it is fairly obvious why you should go attendance-mandatory,
    • or you are doing exceptionally well in your classes. Now if you are the latter and 15-251 really will be that easy for you — and this is not a lot of people! — in my opinion you should be overloading quite heavily, whether it is difficulty-wise or credit-wise (or both). In which case, doing well in 251 requires you to allocate an appropriate amount of effort, and forcing yourself to go to lecture/recitation is a good way to do that.
  • Some tips to succeed:
    • Find a group of people who are responsible and will work on the problems early. (kale is one of these responsible people who forces her group to meet Friday to discuss problems: for context they only come out one day prior! Meanwhile my group finishes half an hour before, we grab dinner if we have time, and then we go to the exam room.)
    • However, what is important is that you find a capable group, even if they are all procrastinators. It’s easy to forget that the problems are hard when you have lots of smart people working on them at the same time, and when grading is so lenient.
    • Make an effort to understand proof strategies. For instance, you should be able to do a structural induction, recognize and create your own halting arguments, etc. The content may be hard, but the bulk of the difficulty is actually in solving the problems, not comprehending the material. Understand strategies rather than memorizing facts.
  • Now I’ll comment on the course itself. The material is pretty standard theoretical CS fare: formalizing a turing machine, and then exploring graph algorithms and probabilistic algorithms, and finishing out with some number-theoretic ideas and applications. It’s nothing crazy hard, and honestly it is not super rigorous.
  • But if you have any experience with formal logic, the way we reason about theoretical CS is the same. In principle we could “compile” our word proofs to formal logic; also in principle we could “compile” our informal appeals to the Church-Turing thesis to formal Turing machines. But for a first-year course this is not necessary. Even as someone who enjoys rigor, I recognize formalizing every Turing Machine would be a great waste of everyone’s time and a great trial of their patience. So understanding the general ideas is enough to get you by.
  • One final note on the difficulty and writing sessions. Unlike kale, I think writing sessions actually make you spend less time on homework (I genuinely think I spend no more than 6 hours a week on this class, and this is counting attendance; some of my older friends have the same experience).


(Fall 2023, KT)

  • Instructors: Anil Ada, Pravesh Kothari
  • Rating: 5/5
  • Difficulty: 4/5
  • Two days after the first homework was released, I called my dad and said that I didn’t know where to start and was considering dropping the class. Nevertheless, I stuck with it. I did pretty well on that homework and even solved a group problem individually. Immediately after the second exam, I called my dad and said that I wrote “idk how to do this :(“ in lieu of a proof and was considering dropping the class. Nevertheless, I stuck with it. I showed some work, so the grader gave me a pitiful 2.5/10 points which was more than I expected. And somehow, I still scored better than the median. There’s a point here to be made about how you should “never give up,” but my main point is that 251 was a wonderful class that is worth powering through for. It’s hard, but if you stick with it, it’s extremely rewarding.


(Spring 2024, matchacastella)

  • Instructors: Anil Ada, Feras Saad
  • Rating: 4/5
  • Difficulty: 3.5/5
  • The Good:
  • 251 is a very well-organized class. I’ve heard a remark before that among CS core professors, “Iliano cares the most about his course; Ada cares the most about his students”. From what I’ve seen so far, this is true. Ada is a great lecturer; his lectures are by the far the most organized and cohesive of any course, and it felt like the lectures respected my time far more than any other course. Fundamentally, it felt like my brain got just a little bit bigger after each lecture, which is an experience I’ve had in no other course (except for Brandon 150 lectures). He was also extremely helpful and understanding the one time I went to instructor OH.
  • The material is also incredibly interesting and rewarding. One of my gripes with Concepts was that it felt like it jumped from place to place, especially after we got past induction (like seriously, how does AM-GM or Cauchy-Schwarz relate to anything else in the course?) 251 basically never feels this way. With the possible exception of crypto, every topic feels like a natural extension of the one that came before. I especially appreciated how new topics would be somewhat lampshaded in problems on the previous week’s problem set - for example, introducing simple languages in the first problem set, then noting that they corresponded exactly to regular languages afterward, which can then be solved with finite automata.
  • Finally, I much preferred the writing session to normal homework submission. One of my smaller gripes with Concepts is that I never quite knew the correct level of formalism, which often meant I spent too much time making one problem too formal and ended up having to rush other problems. By using writing sessions, 251 takes out a certain level of pedantry and focus on formalism in favor of checking for overall understanding of concepts - which is a turn for the better.
  • Specifically, the general pattern for solving a 251 problem is that you only need to solve it to the point such that you understand the “trick” to a problem, rather than fully fleshing out the formalism as you would in Concepts. This makes 251 homework extremely rewarding - because you don’t need to focus on formalism, the experience is limited only to seeing the intuitive trick, which in my opinion is the most fun part of solving any kind of problem.
  • The Bad:
  • Some of the topics towards the end feel a bit finicky (primarily cryptography). OH lines can be somewhat long (though not nearly as bad as say, 213’s), which is exacerbated by the fact that there is relatively little OH compared to Concepts. Of course, this is because the staff intend for you to work on the problems more with your group. This works well if you have a good group (I did, to the point where I think I might have actually gotten a little too carried), but if you don’t then you’re kind of shit out of luck.
  • The programming problems are genuinely horrible. I don’t know if this is because I’m horrible at Python or what, but I think the 251 programming assignments have caused me more stress than any other programming assignment I did this year.


15-259 - Probability and Computing, Weina Wang

(Spring 2023, jackowacko) 15259


15-451 - Algorithm Design and Analysis, Daniel Anderson, David Woodruff

(Spring 2024, jackowacko)

  • Rating 3.5/5
  • Difficulty 3/5
  • Whoever thought 15122 is a “potpourri of various concepts” is not going to have a fun time in 15451. My big complaint after the first half of the semester was that there were too many topics that all felt too separated and too shallowly explored. A topic would be discussed for a lecture or two, it would appear as one or two problems on a homework, and then the topic would never come up again until the midterm. Worse, it felt like there was no progression between topics. Frequently in other SCS cores, content you learned last week would be important the next week, e.g. you need to understand functional types to understand higher order functions. There’s no such connection of topics in 15451, which amounts to not feeling like you have learned anything deep.
  • Into the second half of the semester, the problems I outlined above didn’t really go anywhere, and class topics still had little to directly do with each other. But there were some questions found on recitations and homeworks and even tests (especially the tests) that combined some otherwise unrelated topics together in unexpected ways, which often required looking at class concepts from a new perspective. I personally found these combinations of topics rewarding and made the class feel like a tiny bit more than just a discount package of random inadequately explored topics, but your mileage may vary.
  • Otherwise, it’s an algorithms class… prepare for brain teasers. Some questions (including one on the final I found a little questionable) won’t test you on class content as much as your ability to recognize patterns you might see in a competitive math or programming context, a skill the class expects you to learn just through brute force practice.


Math courses (21-XXX)

21-127 - Concepts of Mathematics, Clive Newstead

(Fall 2022, KT)

  • Rating 4/5
  • Difficulty: 5/5
  • This course just about killed me my first semester here. I had zero knowledge of anything the course covered other than induction, and I was struggling immensely in the beginning. It got a lot easier as the semester went on, but this is definitely the class where I felt like the gap between my knowledge and what was expected from me was the greatest.


(Fall 2023, chessdoudou)

  • Rating: 4/5
  • Difficulty: 2/5
  • This class was quite interesting as it covers lots of different topics. I personally believe that the proof-writing is not the most challenging part; rather, simply solving the problem and being able to explain your thought process is. The formalization is just following a list of rules such as defining your variables and stuff. Additionally, strong problem-solving skills built from competitive math and similar things helps a lot with being able to tackle the problems, but it’s definitely possible to succeed in this class with no prior experience. The textbook is online with lots of practice problems and examples which can help a lot for the 50-minute midterms.


21-241 - Matrices and Linear Transformations (SCS Majors), David Offner

(Fall 2023, kale)

  • Rating: 3/5
  • Difficulty: 2/5
  • Note that the section of 21-241 taught by David Offner is SCS-specific, so the course covers different content from MCS 21-241 and has a final project.
  • Offner produces some of the best handwritten notes I’ve seen from a professor, and his lecturers are actually “lectures” - I felt like I had to attend all of them to keep up in the course. That being said, I found recitations mostly useless, but despite not being too familiar with linear algebra (and especially proofs in linear algebra), I found it was super easy to keep up with the course just by attending lectures and doing the homework. The prep materials provided in advance of exams are also amazing. The final project was the most interesting (and most difficult) part of this course for me. My partner and I implemented a Kalman filter from scratch & did a ton of math to derive properties of the matrices involved, was super rewarding and worth it.


(Fall 2023, matchacastella)

  • Rating: 3.5/5
  • Difficulty: 2.5/5
  • This is a relatively standard math class. Unlike with concepts, you actually can reasonably start a pset the day its due and finish it (albeit with quite a bit of grinding). Offner is super chill and his OH is really comfy. other than that its a fairly run of the mill course.
  • the only thing i’d note is that offner’s lectures are very content-laden. he’s not a stellar lecturer in the way that mackey is, but he’s certainly more efficient. also, recitation can be helpful, but only with a good TA. I actually went to every single TA’s recitation one way or another, and my thoughts were that there were 2 actually good TAs, two pretty middling ones, and two where you’d be better off just using the time to take a nap or read the notes on your own instead.
  • the Julia recitations are completely useless until you do the final project. Then you need to speed-review them to try and vaguely learn enough Julia to implement your final project. Luckily, this is a partner project, so if all else fails you can divide your work so that one person does all the math and one person just does the Julia.


21-241 - Matrices and Linear Transformations, David Handron

(Spring 2023, KT)

  • Rating: 3/5
  • Difficulty: 3/5
  • If we’re talking purely based on final grades, this is probably the hardest class I’ve taken at CMU. Handron’s 241 is much more proof-based than other offerings (though I’m not sure how it compares with Howell in fall), which makes the exams HARD. I think exams 2 and 3 had averages in the low/mid 60s. I’d say the homework difficulty is a 2/5 and exams are probably 5/5. I kind of regret not putting more effort into the class because I definitely could’ve done better, but I think my shortcomings were my own, not the course’s or the professor’s.


21-259 - Calculus in Three Dimensions (Multiple instructors - see below)

(Fall 2022, KT)

  • Instructor: Tim Flaherty
  • Rating: 3/5
  • Difficulty: 2/5
  • Very standard calculus 3 class. Flaherty is super dry as a lecturer, but he posts lecture notes with really nice drawings, so it’s not really like you need to attend lecture. When I took it, the exams were pretty straightforward, about the same difficulty as homework problems, but that might’ve changed. Flaherty somehow lost my final, so I had a C final grade in the class for a while, but everything ended up working out.


(Spring 2024, chessdoudou)

  • Instructor: Dejan Slepcev
  • Rating: 4/5
  • Difficulty: 2/5
  • This was a pretty standard 3D calc class, no complaints. Not sure if Slepcev will ever teach this class again, but he was an interesting professor in that he went off track often to do the most horrendous algebra to prove theorems. We kinda ran out of time at the end of the class to cover all the topics in multivariable integral calculus, but the class was fine.


(??, jackowacko)

  • Instructor: Tim Flaherty flaherty


21-266 - Vector Calculus for Computer Scientists, Clive Newstead

(Spring 2024, kale)

  • Rating: 4/5
  • Difficulty: 5/5
  • Vector calculus as a topic seems like it should be relatively easy, especially coming out of 21-266. This is probably the case for any instructor not named Clive Newstead. The material is well-taught, lectures are engaging, and the homework is manageable, but sometimes, Clive just likes to haze you. Like, have you ever taken a 14th degree partial derivative on the test? The computation in this course is real and difficult but it really hammers the material into your brain.


(Spring 2024, matchacastella)

  • Rating: 2/5 (4/5 if the midterms weren’t cancer)
  • Difficulty: 6/5
  • I agree with everything kale said. I’ll just also say that I think I fundamentally do not vibe with calculus based on how poorly I’m doing in this class. Also I think a sizeable portion of the problems tend toward being either you see this one little trick (which is sometimes related to the content, but sometimes just a matter of algebra 2) and it enormously simplifies the problem, or you end up with horrendous mountains of computation. personally I kind of hate that but ymmv.
  • Also I’m fairly sure Clive’s midterms are basically 4/3 the length of Offner’s in terms of content but still in the same 50 minute period, which is kind of disgusting.


(Spring 2023, A)

  • Rating: 3.5/5


21-270 - Introduction to Mathematical Finance, David Handron

(Spring 2023, KT)

  • Rating: 2/5
  • Difficulty: 3/5
  • I came into this class considering a compfi minor and found out that I had absolutely no interest in computational finance whatsoever. Handron was fine at lecturing, save for those times where he would go over some horrendously complicated proof to some theorem, but I had zero intuition for the content. The class itself was not fun, but I enjoyed those late night midterm study sessions where 5 of us just wrote on the blackboard like madmen. If I didn’t have so many friends taking it with me, I think I would’ve dropped the class.


(Spring 2023, jackowacko)

  • Rating 3/5
  • Difficulty 3/5
  • Also known as the “Omg I’m gonna be a quant right out of college” to “Maybe quants are cringe” pipeline. The easy assumption to make about this class from its low FCE (8-ish) and intro name is that it’s a sort of gen-ed like class that introduces baseline financial concepts.
  • Well, no. It’s a math course the same way you’d call 21-241 a math course; computation problems with a healthy side of proofs. What made the math difficult was that a majority of the course did its math inside a sort of “market model” where you would reason about the interaction between market items and the values of “portfolios”. And for some reason the model just kind of defies all existing intuition on how to break down math word problems. Maybe the content was overcomplicated, maybe it wasn’t quantified enough, I’m not sure; but something has to click in your mind to really understand the inner working details of the math you do here. For me, that click didn’t occur until basically the last third of the semester, and for others I don’t think it ever happened.
  • Despite this class being sometimes the most confusing class in my freshman spring (with brutal tests to boot), it was never close to being my heaviest class; the content isn’t that fast and there’s not too much homework (although maybe I can contribute this perspective to the lenient collaboration policy and my large group…). But I wish to leave a fair word of warning to any hopeful quant-to-be’s that you might have a perspective change after this class, and you might want to try to not take the path alone.
  • Maybe the real portfolio value was the friends we made along the way.


21-295 - Putnam Seminar, Po-Shen Loh

(Fall 2023, chessdoudou)

  • Rating: 5/5
  • Difficulty: 1/5
  • Po-Shen Loh is an excellent instructor with a lot of passion! 100% recommend everyone to take this class even if you have absolutely zero prior experience with competitive math, it’s a great time and the lectures are super engaging. The only thing you have to do to get an A is take the Putnam competition at the end of the fall semester, where you can challenge yourself and eat free pizza 😋


36-202 - Methods for Statistics and Data Science, Gordon Weinberg

(Fall 2023, KT)

  • Rating: 4/5
  • Difficulty: 1/5
  • This class teaches some genuinely useful techniques for when you want to analyze data and it’s really easy. That being said, you should go to lecture or at least read the lecture notes since the homework and labs will assume you know the content.


36-225 - Introduction to Probability Theory, Tudor Manole

(Summer 2023, KT)

  • Rating: 5/5
  • Difficulty: 1/5
  • It’s hard to say whether I enjoyed this class because it itself was a truly good class or because I like probability so much. Going in, I knew a lot of the basics of probability theory, but I still learned a lot about things like distributions, transformations and MGFs, which I all found very interesting. In fact, I don’t think a single lecture bored me, save for the first one where we spent the entire class going over set notation. I also found the class exceptionally easy — this is by far the easiest proper technical course I have taken at CMU. As a whole, this was a great course, and if you’re at CMU over the summer and need to get a probability requirement out of the way, it’s a fantastic choice.


36-226 - Introduction to Statistical Inference, Zach Branson

(Spring 2024, KT)

  • Rating: 4/5
  • Difficulty: 2/5
  • The course content is cool. This is the class that rigorously proves why those things you take for granted in AP Stats work. One of my favorite moments was deriving the unbiased estimator for standard deviation, mathematically showing why the denominator was n - 1 instead of n. Additionally, Professor Zach Branson is incredibly nice and receptive to feedback. My main issue with the course is that the problems are too formulaic and “plug-and-chug” to be interesting. This is very telling in the exam results where people, myself included, do very well on the word problems but lose many points on multiple choice and true-false questions that test our fundamental understanding of statistics. Even after taking this class, I don’t feel completely solid on my fundamentals, but I still feel like I learned a lot.


36-350 - Statistical Computing, Spencer Koerner

(Spring 2024, KT)

  • Rating: 3/5
  • Difficulty: 2/5
  • During the first lecture, Dr. Spencer Koerner admitted that this class could be a mini. He is right, but is not. The Tuesday class is a proper lecture, and the Thursday class is extended OH. This class is easy if you’ve ever programmed, it’s even easier if you’re familiar with some functional programming concepts, and it’s borderline trivial if you’ve used R or Python Pandas. Although I knew a lot of the basics already, the course still gave me a newfound appreciation for a lot of aspects of R (my favourite being piping). I would give this a 1/5 for difficulty but I somehow scored worse on this final than 210 even though I genuinely studied, so a 2/5 seems fair.


36-401 - Modern Regression, Larry Wasserman

(Spring 2024, thresh / aprol)

  • Rating: 3/5
  • Difficulty: 3.99/5
  • Rating is only that high because wasserman is a pretty famous, known for writing the stats textbook. The class allows sharing code for homework, and yet, without going to OH/having a reliable friend, it will be hard to complete it. Disorganized course, but surprisingly doable with enough determination. Learn a bunch of regression and forced to learn a bunch of R which is nice.


Computational biology courses (02-XXX)

⭐ 02-251 - Great Ideas in Computational Biology, Phillip Compeau

(Spring 2024, kale)

  • Rating: 5/5
  • Difficulty: 5/5
  • Phillip is probably one of the best lecturers I’ve ever had. This course is super engaging and perfectly balances the difficulty with how interesting the content is, so no matter how hard the programming and theory homework is, I still want to do it to learn. 02-251 gives you the opportunity to work on a half-semester-long final project of your choosing, which is an amazing way to get acquainted with real problems and real papers in computational biology. There’s a pretty heavy focus on string algorithms and sometimes they assume you know things from 15-251 and 15-150 (and 15-122), despite the only prerequesite being 15-112, so it’s a real learning curve.
  • I’ve been trying to make it onto Phillip’s Twitter, but I have not been successful.


(Spring 2024, B)

  • Rating: 3/5
  • Difficulty: 4/5
  • While I did take this course during a fairly rough period of my life, I do genuinely feel this course is far more difficult than the innocuous 15-112 prereq makes it seem. Like kale said, there were moments during lecture where Phillip would introduce what felt like some bizarre or obscure concept, afterwards saying something like “you probably already know this from 251/210/PnC/etc…”. Despite coming with pseudocode, the programming assignments were honestly pretty challenging (like CF ~1500-1600), and Cogniterra (the prog hw platform Phillip uses) sometimes makes it difficult to know exactly what’s due and when. It also annoyed me how the programming assignments were all-or-nothing, i.e. you either got full marks or a fat 0. The writtens were also pretty cancer; there was one written I vividly remember that involved a 20-minute calculation to arrive at a pretty obvious result, and the TAs would just take off large amounts of points for simple arithmetic errors.
  • Though I wasn’t a huge fan of a lot of the course policies, the biweekly group assignments were pretty enjoyable, as they involved more actual thinking than grunt calculations, and the grading felt way more fair. The course material is also extremely interesting, and Phillip—who, by the way, is a generational lecturer—does a great job of teaching it.


02-500 - Undergraduate Research in Computational Biology, Phillip Compeau

(Spring 2024, kale)

  • Rating: N/A
  • Difficulty: N/A
  • It doesn’t make sense to rate this course since it’s research under a specific professor. I will say that the Computational Biology Department guarantees at least 1 semester of research to all primary majors, so if this is something you’re interested in, you can do it. The course has variable units (I took the 9 unit version) and I’m probably doing close to 9-12 hours a week so it seems about right.


Machine learning courses (10-XXX)

10-301 - Introduction to Machine Learning, Matt Gormley, Henry Chai

(Fall 2023, KT)

  • Rating: 5/5
  • Difficulty: 3/5
  • A pretty standard but very well run introduction to machine learning. I found the homeworks interesting and informative — I particularly enjoyed the programming where we implemented modular autodiff from scratch. I think Matt is the single best lecturer I’ve had the pleasure of taking a class with, and Henry is fantastic as well. The only gripe I have with the course is that the TAs were sometimes just as confused by the material as I was, or they were just bad at explaining. Hopefully this will change in the future.


10-315 - Introduction to Machine Learning, Pat Virtue

(Spring 2023, A)

  • Rating: 4/5
  • Difficulty: 3/5
  • I took this course in Spring 2023, which was when this course was taught for (I think) the first time by Pat Virtue, and as a result, alot of the course materials were incomplete (homeworks were often released a few days after they were due and then the due date was extended by a few weeks). Now, I am a TA for the course, and I can see that the course runs alot smoother, and the course staff are actively putting in work to improve the course and add new content. That being said, I think this course serves as a decent overview for Machine Learning, as it covers alot of the essential topics such as neural networks, backpropogation, MLE and MAP training, etc. Unlike 10-701, which is the masters version of this course, the course does not go into as much depth, and does not cover alot of more modern model such as transformers (or any seq2seq models), diffusion models, VAEs, GANs, etc. The homeworks of this course are quite manageable: there is a written + programming every two weeks, and an online grade scope quiz every other week (when there isnt written/programming hw). Overall, I think this course provides a decent foundation for taking more advanced machine learning courses, but if you want a more rigorous and in-depth course, I would recommend taking 10-701.


10-417 - Intermediate Deep Learning, Ruslan Salakhutdinov

(Fall 2023, A)

  • Rating: 4/5
  • Difficulty: 3/5
  • This course felt like a more theory-focused version of 10-315. The topics taught here were more advanced and often very relevent in research and industry. One thing to note about this course is that it is very broad, but it does not go into the topics in depth. You would usually spend 2-4 classes on each topic and move on, and on each of the homeworks, you would be working with 2-3 topics. For each of the topics, the course gives you a theoretical foundation for the topic, and provides a few examples of the applications of the topic in industry. The workload of this course is quite manageable, since there are a total of 3 homeworks and a final project for the semester (no exams!). Overall, I think this course provides a good overview of what is used for Machine Learning in industry and research today, and would be a good course to take if you want to explore machine learning and decide which area you want to learn about more in depth.


10-423 - Generative AI, Matt Gormley, Yuanzhi Li

(Spring 2024, KT)

  • Rating: 3/5
  • Difficulty: 4/5
  • Given that S24 was the first time this was being taught, there were a lot of issues early on. That being said, it was still a decent course that covered some interesting new developments in the field of genAI. In addition, Professor Matt Gormley was super receptive to student feedback, using it to improve the course. Professor Yuanzhi Li’s lectures felt like they mostly existed to pad out the class, but I enjoyed learning about the techniques used to actually train large models in private research nonetheless. Unfortunately, he left CMU, so I’m not sure this content will be in future iterations of the course. The final project was surprisingly boring for me, maybe because I picked a dull topic, maybe because I worked with two master’s students that didn’t care much, but I still enjoyed working on something open-ended. I can’t fully recommend this class as it is, but it has a lot of potential, and I think it’ll improve as the instructors find their footing.


10-708 - Probabilistic Graphical Models, Andrej Risteski, Albert Gu

(Spring 2024, A)

  • Rating: 5/5
  • Difficulty: 5/5
  • This course is one of the most difficult courses I have taken at CMU. It isn’t difficult in the sense that there are difficult brain-teasers on the homeworks (like in 15251 or 15451). Instead, the course explores various probabilistic methods in machine learning in a very rigorous way, and the concepts themselves require quite alot of effort to grasp. However, for me, the course was very rewarding, since it explained alot of aspects of machine learning that just seemed hacky at first. The workload in this class is quite heavy as well. There are 4 homeworks and a final project, and each of the homeworks are due in 2 weeks and are usually ~20-30 pages long (where you would have to do an average of ~1 derivation per page) along with a programming section.


Science courses (03-XXX, 09-XXX)

03-133 - Neurobiology of Disease, Daniel Brasier

(Spring 2024, thresh / aprol)

  • Rating: 5/5
  • Difficulty: 1/5
  • One of the best ec’s in my opinion, easy yet interesting, with a slight bit of boring homework. Has exams, but they are very doable with little studying. Great course with a passionate and nice professor.


⭐ 03-151 - Honors Modern Biology, Jonathan Minden

(Fall 2023, kale)

  • Rating: 5/5
  • Difficulty: 5/5
  • This was easily the hardest class I took this semester, but the instructor was amazing and I’d highly recommend 03-151 over 03-121 Modern Biology if possible. Despite taking (and teaching) AP Biology in high school and taking 4 more biology electives, I still felt like I didn’t have enough knowledge to go through this course without attending copious amounts of office hours and every review / study session possible. This course really teaches you how to study… and also how to apply problem solving skills to the life sciences, which is pretty cool.


09-105 - Introduction to Modern Chemistry I, Lenny Vuocolo

(Spring 2024, kale)

  • Rating: 1/5
  • Difficulty: 3/5
  • To quote my friend, “this course makes me never want to take a MCS class again.” And that’s the nicest thing I’ve heard anyone say about 09-105.
  • The advice I’ve heard is that if you’re in MCS, take 09-107 Honors Chemistry: Fundamentals, Concepts and Applications if you can. The lectures for this class are pretty awful and you can learn everything by just reading the notes, if you can read the instructor’s handwriting, that is. Chem is a pretty self-study-able course. The one really good thing is that the recitations are extremely useful for learning, and will teach you almost everything you need to know.


33-104 - Experimental Physics, Antonella Palmese

(Fall 2023, KT)

  • Rating: 3/5
  • Difficulty: 1/5
  • Professor Palmese is very accommodating, and the class was very easy in my opinion. Not a bad choice to fulfill a gened requirement.


Engineering courses (18-XXX, 19-XXX)

18-100 - Introduction to Electrical and Computer Engineering, Jian-Gang (Jimmy) Zhu

(Fall 2023, chessdoudou)

  • Rating: 3/5
  • Difficulty: 1/5
  • This class is literally Intro to ECE, as it covers all the topics in ECE. The main part of the class are the 9 labs, each about a specific topic (circuits, adders, op-amps, etc). Jimmy is a nice professor and is universally loved by the ECE department. Personally, I found the latter half of the labs to be less interesting and the course a little less structured as I would’ve liked, since there isn’t a textbook for the course (yet) and the lecture notes are sometimes unfinished. Everyone gets a free toolbox though, which is super cool.


18-213 - Introduction to Computer Systems, Swarun Kumar, Gregory Kesden

(Spring 2024, chessdoudou)

  • Rating: 4/5
  • Difficulty: 4/5
  • This class covers a lot of super, super interesting content. The main part of the class are the 7 labs, where each one covers a different part of the class and none of them are easy (well, maybe except attack and cache). The best part of 18213 compared to 15213 are the small groups, where you get mini-office hours and get to ask questions about anything relating to the class. This semester, the two professors alternated lectures, which was somewhat confusing at times since they teach the content in completely different ways. Although not 100% of the lecture content is covered in the labs or the final, it’s 100% worth going since there’s a lot of interesting and confusing information presented (I still have no clue how linkers work). There are lots of small issues with the class for some reason, but talking to TAs and reading the textbook helps a lot with filling in the holes (especially for shell and proxy!).


(Summer 2024, matchacastella)

  • Instructor: Gregory Kesden
  • Rating: 3/5
  • Difficulty: 3.5/5
  • One of my friends who’s a 122 TA has said that, “122 is a reading class, except students don’t know how to read.” 213 is basically that on steroids. In 122, at the very least everything you need for a programming is contained within the doc for a given programming assignment. In 213, however, its spread out between the textbook, the lecture slides, the various faq docs the TAs have made, and occasionally some old resources you manage to dig up online. Nothing is conceptually extremely difficult in the way that Concepts or 251 is, but it requires a significant amount of time to understand whats being asked and the details of implementation, and especially to debug. Thus, I think 213 is the class with the highest correlation between the amount of time you put in and how well you do in the course.
  • That said, there are a few caveats to this during the summer iteration of specifically the 18-version of 213. First of all, over the summer the course is online. Second of all, I was doing nothing else during the summer (besides a 3-week trip to China). Third of all, the TAs over the summer are incredibly flexible with deadlines (I got a few 2-day extensions just by asking, and I know people who got much longer extensions). This meant that I could spend obscene amounts of time on 213, book many office hours slots (especially for malloc), and get everything right, which would not be the case if I was taking this over the semester.
  • The lectures themselves are pretty boring. I think Kesden would be a fantastic lecturer in person, but unfortunately he is being streamed into my laptop from a houseboat in Florida. This meant that by the end of the semester only about 20 people actually showed up to lecture, out of a class of about 120.
  • That said, the other main problem is that I think 213 lectures don’t really create any deep understanding of the concepts, because the concepts just aren’t really that deep. Whenever I went into a 251 lecture and fully digested the concepts, I felt like my brain had expanded by some miniscule amount. I can feel my braincells atrophying whenever I log onto Zoom for 213 lecture (the fact that it’s at 9:30 AM EST = 6:30 AM PST doesn’t help).
  • Also, I feel like as a whole the concepts in 213 feel very disconnected from each other, to the point where I think 213 feels like the most unconnected class I’ve taken so far. Granted, this is partially because by nature 213 is a survey of systems, but I feel like there’s nothing that builds on each other in 213 - it’s just “week 4: this is how X systems thing is done. week 5: this is how Y systems thing is done. go implement it.”
  • The programming assignments themselves are very hit-or-miss. A few thoughts on them:
  • Datalab is just really stupid, and I feel like it’s by far the least practically useful. Like I understand the importance of bitwise operations, but why would I ever need to figure out how to determine if an int is a palindrome using only bitwise operations?
  • The assembly labs (bomblab and attacklab) are actually pretty cool. They get you very familiar with understanding the gist of asm, as well as how to use gdb effectively.
  • Cachelab is pretty alright. Parts 1 and 2 (writing a cmdline program and a parser) are a little boring, but I understand how it’s a necessary skill. Part 3, the cache simulator itself, is pretty interesting. Part 4, optimizing transpose, is pretty fun for the 1024 x 1024 but absolute BS for the 32 x 32.
  • Malloclab is fantastic. (unless you get a really stupid bug, but even then it’s still very interesting.) It also helps that there’s many, many materials on the internet about malloc especially (for example, Stanford’s CS 107 has lecture slides that IMO are better at explaining how malloc works compared to our lecture slides).
  • Shellab is an incredibly unbalanced lab, which is not helped by the fact that the documentation is very vague (and especially when you consider that the most valuable documentation is not the textbook, not the writeup, but a random TA-written roadmap). There are maybe 3 traces which are difficult to pass, while the rest involve minimal changes. But those 3 take forever to understand, and it feels like the intended solution just isn’t very intuitive.


(Spring 2024, B)

  • Rating: 4.5/5
  • Difficulty: 2.5/5
  • -> Note: I took the “18” (ECE) version of this class, so my experiences (esp wrt course logistics) may vary widely from those who take the “15” (CS) version.
  • The first 2/3rds of 213 comprises probably the best course I’ve ever taken in my entire life, period. To give an idea of the quality of the course, the same course (along with the textbook) is pretty much copied slide for slide by pretty much every other American university. As many have said, the labs are what define the course, and they do an excellent job of teaching you the material in a way simple lectures never could. Beyond teaching you important systems fundamentals, they also teach you how to be a good software developer—e.g. how to use git, how to write good test cases, how to write modular code, how to document, how to debug, and how to read documentation. 213 taught me to write code I never knew I was capable of writing, and looking back, I feel so proud of my work in that class in a way I’ve never felt before. And not gonna lie, nothing beats the feeling of running driver.pl after six hours of straight debugging and seeing “all tests passed” on your terminal window.
  • The final 1/3rds of 213 teaches you about important OS fundamentals, including processes, I/O, signals, and concurrency. It was still pretty solid, just noticeably less so than the rest, but YMMV. Shell lab is also noticeably much more difficult than the other labs, and felt much less satisfying to complete (mainly because I begged my TAs for answers and didn’t actually understand anything lmao). The write-ups also significantly declined in quality (ex. Malloc lab writeup was a 40 page roadmap of how to write our allocator, while shell lab writeup was a vague 5 page spec of how our shell should handle certain obvious things). While proxy lab was a far better experience than shell lab, I’m still somewhat disappointed with how the course ended.
  • Still overall a fantastic course, and one you absolutely must take if you enjoy figuring out how computers work at a low level, or if you just want to sharpen your software engineering skills. Also note that, while this course isn’t too difficult, you’ll need to allocate quite a bit of time towards some labs. During Malloc lab part 2, by far the most time-consuming section of the course, I believe I was spending close to 9-12 hours per week on debugging and implementation.


19-101 - Engineering and Public Policy, Deanna Matthews

(Spring 2024, kleps ’27)

  • Rating: 5/5
  • Difficulty: 3/5
  • If you are a chronic procrastinator, this class is either a wake-up call or a great adrenaline ride. Every assignment has a built-in grace period of anywhere between a week to a month so make sure you are keeping pace with the actual deadlines or you will easily fall behind. The class also functions as a SUDS grading scale so you do not need to complete every assignment, it is clear what assignments take priority for the letter grade you want. In terms of actual work, the math, calculations, and writeups are meant to expose you to learning public policy but the content mostly consists of things you have seen or learned beforehand. Grading-wise, it is quite polar. It is either a zero out of one or one out of one but with zeros you are allowed to revise assignments, this is to reinforce the learning aspect and not just aim for a grade. Do not try and fight the course structure and do assignments without excel.


General education, StuCos, and other (XX-XXX)

76-101 - Interpretation and Argument (Multiple instructors - see below)

(Fall 2023, matchacastella)

  • Instructor: Barbara George
  • Rating: 2/5
  • Difficulty: 1/5
  • Teaching quality varies wildly and there’s not a lot to go off of in course selection because honestly, CMU just kinda gets random English postdocs to teach it so they can lower their median class size for the sake of admissions. I personally got a pretty easy section. The good thing was that it was literally a subset of AP Lang, and I spent an average of 4.5 hours a week on that class (including the 3 hours of class time). The bad thing was the teacher was quite possibly the most boring teacher period I’ve ever had.
  • That said, if you are able to register for any first year writing, take it. Not because it’s a good course (it’s not), but because slots fill up quite fast and you do not want to take first year writing as a sophomore.


(Fall 2023, chessdoudou)

  • Instructor: Julia Salehzadeh
  • Rating: 2/5
  • Difficulty: 4/5
  • English is hard and I dislike writing. Choose an interesting topic for 76-101 otherwise it’ll be both boring and painful. My original topic got cancelled and I ended up in this class which was about virtues and I did not have a good time.


(Fall 2023, KT)

  • Instructor: Peter Mayshle
  • Rating: 2/5
  • Difficulty: 1/5
  • I second matcha’s statement that this is Diet AP Lang. On one hand I wish this class was harder, more interesting, and dived more into the actual topic I signed up for (Rhetoric of Space), but on the other hand, the hardest part of the class was finding the motivation to do the assignments. Dr. Peter Mayshle is super chill and a very lenient grader, which is good for many people (I was genuinely disturbed by the terrible writing quality of some of my peers). I liked researching and writing my final paper, which was on architectural styles at CMU.
  • Whether to take interp or the minis is up to you. The general consensus is that interp is less work but more intellectually difficult while the minis are more busy work. I chose interp because it worked with my schedule better and also because I hated the thought of having two final projects.


76-102 - Advanced First Year Writing: Special Topics, Kevin Haworth

(Fall 2022, thresh / aprol)

  • Rating: 4.5/5
  • Difficulty: 1.5/5
  • Great course if you enjoy writing and don’t want a class too boring. The writing projects are more “creative” than the other freshmen options, and both the professor and students are engaging. Relaxing and fun.


76-106 - Writing about Literature, Art, and Culture, Chap Morack

(Spring 2024, kale)

  • Rating: 1/5
  • Difficulty: 1/5
  • My personal understanding of literature and the essay contradict everything taught in this course. 76-106 emphasizes the 5 paragraph essay and trivializes analysis and close reading - this course has actively made me worse at writing, and I went to a high school for math. Take this class only if you don’t care about writing and you just want an easy grade with low FCE.


76-107 - Writing about Data, EJ Jo

(Fall 2022, jackowacko)

  • Rating 1/5
  • Difficulty 2/5
  • In the words of an upperclassman, “cannot be salvaged into an interesting class”. If you’re hoping to write about interesting data and STEM-like subjects, well, you’ll at least learn how to pretend to write about something interesting, because in my experience this class was an exercise in expanding a three sentence comment into a three page paper. Course load also kinda spikes near the end of the semester which wasn’t super fun and why it isn’t 1/5 difficulty, even though the content is super trivial and the homework is usually light.


76-108 - Writing about Public Problems (Multiple instructors - see below)

(Spring 2024, kale)

  • Instructor: Stephen Sudia
  • Rating: 3/5
  • Difficulty: 1/5
  • 76-108 is a course where we write about a problem we perceive at CMU (or some other relevant community) and write a proposal of how to fix this. The real problem all along was that the scheduler is capable of scheduling courses such as first-year writing in the Mellon Institute. (Luckily, the course was moved a week in after the instructor talked to every higher-up possible). I think this is an interesting first-year writing course and is worth taking because it’s a completely new style of writing, and you get to have some fun interviewing people and / or making a Google Form.


(Fall 2022, jackowacko)

  • Instructor: Julie Kidder
  • Rating 4/5
  • Difficulty 1.5/5
  • 76108 is a class that is as interesting as you make it. Most of the class focuses on a self-chosen topic or proposal you will write, and then gives you freedom on how you research your topic, gather public opinion, and finally write your paper, with of course general guidelines and good writing principles in mind. I chose to write about CMU lanternflies which quickly became a topic that was a lot deeper than I was expecting. The amount of freedom I had while writing the paper was a big contributor to me actually enjoying writing for a humanities class.
  • My prof was also a super cool and chill person, which is generally true across almost all FYWs since they’re postdocs, but I think Kidder was an especially nice and engaging professor.
  • You also have the option to actually submit your proposal to some sort of CMU admin, if your proposal regards the CMU community. I have no clue if these proposals are given any genuine consideration but I didn’t submit and now I kind of wish I had done that, because I would’ve looked prophetic in hindsight given the fall 2023 lanternfly outbreak.


70-311 - Organizational Behavior, Kori Krueger

(Spring 2023, jackowacko)

  • Rating 2.5/5
  • Difficulty 1/5
  • I’ll be kinda damned if there’s an easier class to fill SCS Humanities Category 1. All there is to the entire 14 week semester are three pretty straightforward 50-MCQ exams, four case studies which take 2-3 hours tops each, and like writing a brief paragraph about each lecture so you kinda need to pay attention to class (or you just be a Tepper student and network). That’s basically it.
  • None of the class was really memorable or instructive except for maybe the negotiation unit. I played some negotiation games in class, realized I still sucked at any flavor of social activity, and got to write about my failure for two hours.


73-102 - Principles of Microeconomics, Serra Boranbay Akan

(Spring 2024, chessdoudou)

  • Rating: 3/5
  • Difficulty: 1/5
  • My AP Econ teacher was super cool, so I wanted to learn more about economics as a subject. This class focused a lot on Game Theory, probably since Serra was teaching it. Game theory is interesting but the problems that we solved in the class felt monotonous, and the examples given felt quite fake. Still, the class is super easy.


79-262 - Modern China: From the Birth of Mao… to Now, Benno Weiner

(Spring 2024, matchacastella)

  • Rating: 4/5
  • Difficulty: 1/5
  • I took this class for the Category 3 humanities gened requirement for SCS. I personally greatly enjoy this course, but that’s also because I’m kind of a nerd over 20th century Chinese history.
  • The class definitely implicitly assumes a minimum degree of familiarity with modern Chinese history - I would not suggest taking it absolutely blind. That said, given you have many, many choices for Category 3, I really don’t see why you would take this if you didn’t have any sort of interest in Chinese history.
  • For what it’s worth, I think the professor is very knowledgeable (unfortunately, he has horrible Chinese pronunciation) and lectures are very informative (albeit on the drier side).


80-100 - Introduction to Philosophy, Joel Smith

(Spring 2023, KT)

  • Rating: 5/5
  • Difficulty: 1/5
  • I really enjoyed reading philosophy articles and discussing different perspectives on moral/ethical questions in recitation. The workload was very reasonable, and I actually really enjoyed writing things down since it helped me process my own thoughts on the philosophical questions posed. Professor Joel Smith was wonderful, and although attendance was mandatory, he was very understanding if you missed class as long as you weren’t abusing the system. I didn’t expect to like this class as much as I did, and it ended up being one of my favourite classes I’ve taken at CMU.


98-016 - Genshin Impact Theorycrafting and Lore, Allan Lyu, Marina Wang

(Spring 2024, matchacastella)

  • Rating: 4/5
  • Difficulty: 1/5
  • This class has made it onto Chinese news sites and resulted in at least 1 ED application to this school. Take that however you would like.


98-043 - Chess Tactics and Strategy, Andrew Peng, Ethan Gu, Vionnie Khong

(Spring 2024, A)

  • Rating: 5/5
  • Difficulty: 6/5
  • Idk man, one of the instructors (Andrew) locked us in a room and made us do self mate puzzes. He didn’t even let us use the restroom… In the end we managed to break out with a crowbar after being confined for more than 72 hours.


(Fall 2023, chessdoudou)

  • Rating: 5/5
  • Difficulty: 1/5
  • I took this stuco and now I’m coteaching it with Ethan and Vionnie!!! Sign up even if you’re interested in learning more about chess I promise it’ll be a fun time :))))))
  • (Also do not trust the other review by A it’s all lies and slander)


98-057 - Intro to Polytopes, Aresh Pourkavoos

(Fall 2023, matchacastella)

  • Rating: 3.5/5
  • Difficulty: 5/5 (conceptually), 2/5 (actual work)
  • If this class actually had any work, it would be the hardest class I’ve taken at CMU, because holy crap I did (and still don’t) have the necessary background in abstract algebra to even comprehend this class.
  • Luckily this is a stuco and I ended up getting completely carried by 2 other freshmen in the class who actually did have the math background to somewhat understand things.


98-061 - UXplore: Uncover the Best of Modern UX Design, Pranav Addepalli

(Fall 2023, kale)

  • Rating: 3/5
  • Difficulty: 1/5
  • This course singlehandedly made me consider majoring in HCI, which is probably what the instructors would consider a success. It also forced me to learn Figma which was super useful.


98-242 - Esolangs, David Krajewski, Gil Shteyman, Harrison Wiseblatt, Ethan Muchnik

(Spring 2023, KT)

  • Rating: 2/5
  • Difficulty: 1/5
  • This class was really chill, and the instructors clearly had a lot of fun teaching it, but it’s just not that interesting listening to people talk about esolangs. I did, however, enjoy messing around with my friends in the class. This was also the class that finally convinced me to read GEB, though I didn’t end up enjoying the book.
  • Also, esolangs


98-258 - Intro to Competitive Pokemon, Ryan Kim, Richard Sbaschnig

(Fall 2023, matchacastella)

  • Rating: 4/5
  • Difficulty: 1/5
  • I don’t think I actually learned anything in this class, but it was an excuse to play Pokemon Showdown for an hour so I’m not complaining.


98-335 - Intro to Glowstringing/Poi, Zhejia Yang, Ben Sun

(Fall 2023, matchacastella)

  • Rating: 4/5
  • Difficulty: 1/5
  • Basically this was “whirl around glowsticks and vaguely try to actually do choreography for an hour”. Personally I thought moving around and gasp touching grass was very valuable and helped a lot with managing the stress of adjusting to college.