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

The below measures each course across four attributes:

- Interest - how interesting it is
- Usefulness - how useful I’ve found the teachings in my day-to-day work
- Difficulty - how hard it is
- Effort - how much homework there is

Course | Interest | Usefulness | Difficulty | Effort |
---|---|---|---|---|

CS 343 | 3/5 | 4.5/5 | 3/5 | 4/5 |

CS 360 | 3/5 | 1/5 | 3/5 | 2/5 |

CS 370 | 2.5/5 | 2/5 | 2/5 | 2/5 |

CS 442 | 4/5 | 3/5 | 5/5 | 3/5 |

CS 444 | 3/5 | 5/5 | 3/5 | 5/5 |

CS 451 | 2/5 | 4/5 | 2/5 | 4/5 |

CS 458 | 4/5 | 5/5 | 2/5 | 2/5 |

CS 476 | 2/5 | 2.5/5 | 5/5 | 5/5 |

CS 486 | 3/5 | 4/5 | 1/5 | 1/5 |

CO 487 | 3/5 | 4/5 | 1/5 | 1/5 |

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

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).

**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.**

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.

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

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”.

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

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 also make you a better programmer. You will also not have a
life if you take this course.**

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.

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

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.

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

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.

**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.**

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.

**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.**

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?

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

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).