Here are my thoughts on some upper-year courses I’ve taken. You may find these useful if you’re picking courses.

- Interesting content: 💡💡💡💡💡 / 5
- Usefulness on-the-job: 🔨🔨🔨🔨🔨 / 5
- Conceptual difficulty: 💀💀💀💀💀 / 5
- (Home)work load: ⏳⏳⏳⏳⏳ / 5

- 💡💡💡
- 🔨🔨🔨🔨(🔨)
- 💀💀💀
- ⏳⏳⏳⏳
- Keywords: Locks, Semaphores, Monitors, Baton-passing, Cache-thrashing

As the spiritual successor to Operating Systems (CS 350) and Object-Oriented Programming (CS 246), this course will revisit your understanding of how computer programs work, with a twist - now, “multiple things can happen at the same time!” Like in the games StarCraft or Overcooked, this teaches you how to micro-manage programs. Making sure you don’t trample all over yourself (or shoot your own feet with C++11) is quite a feat.

It’s pretty rewarding, because a lot of real-life software (like web servers, code editors) are concurrent, and the concepts this course teaches come up often if you work on low-/medium-level systems code.

Like 246, the course culminates in a final group project of similar complexity. Hope you learned to time-manage and work in a team over your co-ops! 😂

There’s a decent amount of work as debugging concurrent programs is a pain in the ass, but since this course is mandatory for SE kids, they can’t make it too hard (because even below average students have to pass). 😛

**Pretty applied. If you dislike system-oriented programming or C++, this is not the course for you.**

- 💡💡💡
- 🔨
- 💀💀💀
- ⏳⏳
- Keywords: DFA, NFA, CFG, grammars, Turing machines

This course is CS 245 with different content. You learn about the properties of various tools in “computation” (see keywords), and prove things about them. Prove what, you ask? I forgot, so probably nothing important. The only things I got out of this course are 1) you can’t solve the “balanced parenthesis” problem without a stack, and 2) some problems can’t always be solved in finite time.

**Don’t take this course if you’re allergic to proofs. Save your electives and take 4XX courses instead - they have more useful and interesting material.**

- 💡💡(💡)
- 🔨🔨
- 💀💀
- ⏳⏳
- Keywords: Splines, Finite Differences, Fourier Transforms, PageRank

Despite sharing the name “computation” with 360, this course is vastly different in what it teaches - specifically, things with decimals, and how to do various math on a computer. And by doing math, I mean implementing equations in MATLAB with some fuzzy understanding of how they’re derived (because, hey, we know CS students can’t do real math on their own 😉).

There’s not much to say about this course - if you’re taking it, it’s probably because you want to take Graphics, are an engineer at heart, or dream of being a quant (not data scientist!), so you’ll take this regardless. If not, the material this teaches is probably not on your radar of “interesting things”.

**Decent, but there are better 4XX courses out there.**

- 💡💡💡💡
- 🔨🔨🔨
- 💀💀💀💀💀
- ⏳⏳⏳
- Keywords: Scheme, ML, Haskell, Prolog, Types, Functional Programming, Logical Programming

The course with the most misleading name ever. Yes, you will learn enough Haskell to write Yet Another Haskell Tutorial, but the emphasis of this course is on understanding the theoretical underpinnings of how programming languages are *designed*. You’d learn about lambda calculus with Scheme, type inference with ML, tree traversals with Prolog, and so on.

There’s a *lot* of tricky content to go through, so the course moves really quickly - I actually went to every class because Lushman covers two lectures’ worth of content in one, everyday.

You may ask: with such niche languages, how’s this course useful at all (unless you work at Jane Street)? This course provide you with the theoretical understanding needed to easily pick up *any* language, and, more importantly, teach you how to *think about programming*. An undervalued skill, since most CS students are code monkeys who can barely clobber together Java APIs.

**This course will make you a better programmer. Warning: top 2 conceptually hardest course - not for the faint of heart.**

- 💡💡💡
- 🔨🔨🔨🔨🔨
- 💀💀💀
- ⏳⏳⏳⏳⏳
- Keywords: Java, Grammars, Parsing, Scanning, Type Checking, Code Generation

Over this course, I learned more about Java than I ever wanted to. Did you know that, for instance, an `interface`

without any `super interfaces`

implicitly declares an `abstract`

version of every `method`

in `java.lang.Object`

? Shit like that’s fun to check and enforce at 3 am after 5 cups of coffee.

This course is the equivalent of a capstone project for CS kids, except unlike capstone projects in other programs, you can’t choose to build a fluffy website with React or Vue.js, and instead have to learn everything about a specific, archaic version of Java to build a compiler against it. At least you can implement it using a language of your choice!

This course teaches you crucial life skills, like nagging your teammates to put in work, reading the language spec like a lawyer, writing code to pass tests, refactoring, and learning things like x86 on the fly. Oh, I guess also a few things about compilers and Java.

The most valuable you’ll get out of this class is you’ll understand *everything about how a high-level programming language works* (aka. every modern language), from reading your program as plaintext, to validating your idiotic code, to outputting machine code. You’ll never be confused by a compilation error again.

**This course will also make you a better programmer. You will also not have a life if you take this course.**

- 💡💡💡💡
- 🔨🔨🔨🔨🔨
- 💀💀
- ⏳⏳
- Keywords: Buffer Overflow, XSS, Padding Attacks

If there is a course that everyone seems to be taking for some reason and *should* take, then this is it. Relatively easy, light on the workload, and full of useful and applicable concepts, CS 458 is one of the best 4XX courses out there.

The lectures are full of useful information, and will slowly teach you words you’ve heard about in passing, like proxies or TLS certificates. Assignments are the real gems in this course though - by actually implementing various attacks against binaries and web servers, you learn to identify, exploit, and guard against common software vulnerabilities. This skill will be handy to any software journeyman.

**Great course. Useful, interesting, and not too difficult. Highly recommended.**

- 💡💡
- 🔨🔨🔨🔨
- 💀💀
- ⏳⏳⏳⏳
- Keywords: Hadoop, Spark, Scala, Big Data, Cloud, PageRank, ML

If you’re ever thinking of working at any startup/big tech company in the Valley, you’ll definitely come across the technologies taught in this course. And this course is all about modern technologies that manipulate Big Data™ - you’ll learn how to use Hadoop, Spark, and all the other buzzwords in dept.

At times, this course may seem *too* applied. The assignments are very practical - you’ll write programs that run on a Hadoop cluster In The Cloud™ to compute PageRank and classify text and whatnot. And experience the frustration of debugging large outputs first-hand 🙃.

**Really interesting and applicable course. Highly recommended for the everyday software engineer.**

- 💡💡
- 🔨🔨(🔨)
- 💀💀💀💀💀
- ⏳⏳⏳⏳⏳
- Keywords: Options Pricing, Monte Carlo, Finite Differences, PDE, Optimization

This course is centred around one question: how do you price options? Black magic, it turns out - magic you will painstakingly explore over three months.

This course starts off with a new branch of calculus - Ito’s calculus. It’s like calculus and probability had a deformed baby. At one point, you have to apply LU factorization to a matrix of finite difference terms for a partial differential equation. *This is not a joke.* If you don’t know everything in STAT 230/MATH 235/237/CS 370 like the back of your hand, you’re in for a very rough ride.

**Top 2 conceptually hardest course. There are two types of people who’d take this course: 1) those dead set on quantitative finance, and 2) bored math and CS gods. For everyone else, please stay away.**

- 💡💡💡
- 🔨🔨🔨🔨
- 💀
- ⏳
- Keywords: Simulated Annealing, Hidden Markov Models, Reinforcement Learning, Bayesian Networks

For the easiest fourth-year CS course ever, it’s surprisingly interesting and useful. The concepts (like simulated annealing) are both easy to grasp and apply in practice. The material is also refreshing - you’re unlikely to have come across topics like Bayes Nets and HMMs before (unlike, say, Yet Another Tutorial on logistic regression or neural nets).

Oh, did I mention this course has basically neither math nor homework?

**Highly recommended for CS kids who want to “do ML” but can’t math. Just kidding - it’s a seriously good course to get your feet wet in the field.**

- 💡💡💡
- 🔨🔨🔨🔨
- 💀
- ⏳
- Keywords: Symmetric Encryption, Asymmetric Encryption, MAC, RSA, Elliptic Curves

A focused subset of CS 458. You’ll learn all about modern cryptography techniques like RSA and elliptic-curves in depth, which software engineers actually use everyday, via SSH, HTTPS, SSL, SHA256, WPA2, and other acronyms you’ve probably come across as a web developer or something.

This is also probably the easiest CO course ever - you only need basic MATH 135 knowledge and no coding at all (though it would help).

**Great course. Useful, interesting, and not difficult. Highly recommended for everyone.**