Misc.

Online Courses

  • Algorithms for DNA Sequencing (Ben Langmead)
    • This course begins by explaining how sequencing actually works. According to James Somers, understanding the methods, like sequencing, used to study biology is a more effective way to acquire a “reading knowledge” of biology.
    • The course focuses on string algorithms. Presenting this content in the context of impacting genomics made it far more interesting than if it was presented abstractly.
  • Human Behavioural Biology (Robert Sapolsky)
    • The best lecturer I’ve seen. He does an amazing job of crafting a narrative around the science.
  • Machine Learning (Andrew Ng)
    • This course got me incredibly excited about machine learning. This course provided a solid foundation which I’ve relied on ever since to learn more about machine learning.
  • Learning How to Learn (Barbara Oakley)
    • I originally learned about this course from this article by the instructor.
  • Introduction to Mathematical Thinking (Keith Devlin)
    • I was really curious about what it actually meant to prove something in math and this course was a great introduction that improved my logical thinking ability.
  • CS50: Introduction to Computer Science (David J. Malan)
    • I loved the breadth of topics covered in this course; this was my first deep exposure to computer science and I got to learn about topics such as ciphers, sorting algorithms, hash tables, linked lists, and file I/O. The problem sets are excellent and give a sense of curious exploration.

Courses

Fourth Year

  • ECE1502: Information Theory (Frank Kschischang)
    • This was the only engineering course I took during my undergrad. While this was essentially a math course, I think engineering takes a unique perspective distinct from what I’ve seen in other math courses. For example, many of the homework problems had unstated assumptions you needed to use in your solution. This made it feel like solving a research problem, in that all the contraints weren’t clear from the start.
  • MAT1841: Mathematics of Massive Data Analysis (Yun William Yu)
    • This was a small seminar class I took. It covered a bunch of different disciplines that have cool math as a foundation for methods they used to process large amounts of data. This course was a lot of fun, and very challenging. We covered such a wide breadth of mathematical areas, many of which I was surprised had practical applications.
  • MAT1850: Linear Algebra and Optimization (Mary Pugh)
    • This course taught me a lot of math I’ve seen in ML papers, but hadn’t deeply understood until now. It goes beyond what you learn in standard undergraduate linear algebra courses, and gives you a basic foundation in optimization.
  • CSC495: Research Project in Computer Science (Roger Grosse)
    • This course allowed me to do a research project for course credit. I worked with Guodong Zhang, Vardan Papyan, and Roger Grosse on a project related to KFAC. This was a fun project because it tied math and code together very closely. There were many times we had to do some math to properly understand the result of an experiment, or develop a new hypothesis.
  • CSC2321: Matrix Calculations (Christina Christara)
    • This was a numerical methods course. I wrote more MATLAB code for this course than I ever wrote before. I learned that you can precisely test the correctness of a numerical method implementation. It’s very easy to write buggy numerical code that still converges most of the time, and this course taught me how to find those subtle bugs. The professor listed a bunch of numerical methods textbooks for this course, and it was really cool reading through them and finding cool and very useful tricks that you really wouldn’t be able to find anywhere else online.
  • CSC369: Operating Systems (Angela Demke Brown)
    • I really enjoyed this course. It was fascinating to hear about all the engineering tricks that go into making various parts of the OS work. The assignments were essentially just large C-programming assignments; it was a lot of fun writing a lot of code, and making it as clean as possible so that it was easy to debug. We used OSTEP for this course, which is the most engaging textbook I’ve ever read.
  • CSC317: Computer Graphics (David Levin)
    • This was the best organized course I’ve taken. The assignments were a lot of fun because they involved writing code to make a pretty picture at the end. The assignments taught me to break down a large task into manageable parts, each of which could be tested on its own.
  • MAT363: Curves and Surfaces (Alexander Nabutovsky)
    • I took this course purely for fun. I hadn’t done any pure math courses in a while, so this was a nice change of pace.
  • STA261: Probability and Statistics II (Mohammad Kaviul Anam Khan)
    • This course was extremely useful, and I wish I’d found the time to take it sooner. We learned about hypothesis testing, and frequentist statistics more broadly, which is something that had been sorely lacking in my toolkit until this course.

Third Year

  • STA347: Probability (David Brenner)
    • In this course we proved that you can uniformly sample a real number on an interval by uniformly sampling the bits of that number (or a digit in whichever base you like), to whatever precision you like. In other words, we constructed the continuous uniform distribution from the discrete uniform distribution.
    • Besides this result being beautiful in its own right, it suggests an implementation of uniform sampling on a computer (though I’m not sure if it’s practical).
    • In general the theme of the course was constructing complex distributions from simpler ones and proving things “structurally” (instead of manually calculating expectations by integrating).
  • STA447/2006: Stochastic Processes (Jeffrey Rosenthal)
    • The course focused on Markov chains. Many of the results about convergence are subtle and hard to understand intuitively without a grasp of real analysis which I did not have.
    • We briefly talked about Brownian motion and other continuous time stochastic processes, but once again, these were hard to get a handle of without the proper background in analysis.
    • I need to take real analysis to understand these things!
  • CSC258: Computer Organization (Maziar Goudarzi)
    • This course is an ECE course that CS students are required to take, and most dread it. While it has a heavy workload, I found the course fascinating.
    • Each week we would learn about the implementation of a circuit component, and the next week that circuit component would become a black box which we would use to construct the next circuit component. For example, we started with transistors and eventually learned about flip-flop circuits.
    • Programming in Verilog was unintuitive. It’s a language that’s basically HTML for circuits, but designed to have an imperative feel like C or Python. We also learned some Assembly which was cool in the way that all low-level programming languages are, but also not fun for the same reasons. Luckily we only wrote code snippets in this course so we just did the fun bits.
  • CSC473: Advanced Algorithm Design (Aleksandar Nikolov)
    • One of the best courses I’ve taken. The focus is on randomized and approximation algorithms (course website). Such a breadth of topics is covered that it’s hard to summarize.
    • One random cool thing I learned about was reservoir sampling, though we didn’t do much streaming algorithms in general. Tim Vieira has a few posts about it.
    • Locality sensitive hashing is cool.
    • We learned some cool techniques like Chebyshev’s inequality, Chernoff bounds, and complementary slackness in linear programming.
    • The algorithms we covered solve foundational problems in a general way. We understand how these algorithms work and their tradeoffs. They have at most a handful of parameters that need to be tuned according to the tradeoffs the user wants. Contrast this with machine learning, where often we want to solve a specific problem better than a general algorithm could by leveraging data. We don’t understand a lot of machine learning algorithms nearly as well or their tradeoffs with different parameters. I wonder how much this has to do with the fields being fundamentally different versus one simply having better developed theory.
  • APM462: Nonlinear Optimization (Jonathan Korman)
    • We learned some basics about convexity (zeroth, first, and second order conditions). I wish we’d done more, since it seems like it has the right tradeoff between being tractable and becoming useful (at least according to Boyd and Vandenberghe).
    • We learned about variational optimization, which usually means minimizing an integral over a space of functions instead of over vectors. It seems cool but probably only useful for physics.
  • BIO130: Molecular and Cell Biology (Melody Neumann and Daphne Goring)
    • My first course in biology since the 10th grade. I went to Con. Hall for the first time for lectures for this class.
    • It was so much fun diving into the details and learning about biology. Surprisingly, I found the labs very useful. They gave me a taste of how knowledge is acquired in biology, which makes it much easier to understand what is known in biology.
  • LIN101: Introduction to Linguistics: Sound Structure (Peter Jurgec)
    • Peter Jurgec is a very engaging lecturer. This course was full of moments where we would learn a concept that formalized something we already had an intuitive feel for. One very simple example was that the only difference between the “s” and “z” sounds is that we engage our vocal chords to make the “z” sound.
  • LIN102: Introduction to Linguistics: Sentence Structure and Meaning (Susana Bejar)
    • This course focused on mathematizing language, which I found not very exciting as the concepts were things that I’d already learned in my math and CS courses, whereas I was looking to learn things radically different from my normal coursework. But most people I know seemed to really enjoy this course!
  • PHL271: Law and Morality (Sophia Moreau)
    • These lectures were amazing. I learned some new words in this course. It’s also the first time I heard someone refer to “law” as “The Law”, which makes it sound way cooler.
    • One thing I learned about was the difference between positive freedom and negative freedom.
  • CSC494: Research Project in Computer Science (David Duvenaud)
    • This was a chance for me to do research for course credit. It gave me the extra time I needed to build a lot of necessary fundamental technical skills for running experiments. Eventually the work for this project turned into the paper Learning Differential Equations that are Easy to Solve.

Second Year

  • MAT257: Analysis II (Edward Bierstone)
    • Closely follows Michael Spivak’s Calculus on Manifolds. Topics included topology, the implicit function theorem, measure theory, partitions of unity, differential forms, culminating in Stokes’ Theorem on manifolds.
  • MAT267: Advanced Ordinary Differential Equations (Mary Pugh)
    • Covered some analysis to show existence and uniqueness theorems for ODEs, then switched to a dynamical systems perspective including phase plots, Lyapunov functions, stability of solutions, and bifurcations.
  • STA257: Probability and Statistics I (Mark Ebden)
    • I learned how to compute covariance. I also learned the difference between mutually-independent and conditionally-independent. I also learned about moment generating functions.
  • CSC209: C & Systems Programming (Michelle Craig)
    • I had a lot of fun in this course. It was my first chance to do some low-level programming. It can be very stressful and frustrating, but also rewarding.
    • I also learned to be comfortable in shell. I can’t understate how useful this skill was.
  • CSC265: Enriched Data Structures and Analysis (Aleksandar Nikolov)
    • In addition to standard data structures and algorithms, this course covered adversary arguments to prove lower bounds on problem complexity, and the potential method for analyzing amortized complexity.
  • CSC373: Algorithm Design, Analysis & Complexity (François Pitt)
    • A great lecturer. This was another instance where I learned much better than when I had tried to teach myself. Preparing for tests in this course felt more useful than other courses, since in many ways it’s similar to preparing for technical interviews.
    • We spent some time learning about P and NP. I feel like it’s only worthwhile to learn that content if you spend an entire semester digging into the details. Instead, I wish we’d learned about something else like FFT.
  • CSC411/2515: Machine Learning and Data Mining (Roger Grosse)
    • Focus on using a mathematical framework to understand classical algorithms leading to principled generalizations (e.g. k-means to EM algorithm, regularization as MAP estimation).
  • CSC412/2506: Probabilistic Learning and Reasoning (Jesse Bettencourt)
    • Independence relationships in Bayesian networks via d-separation, as well as inference and learning in other probabilistic graphical models. Focus on variational inference in latent variable models, in particular implementing a VAE from scratch.
  • CSC421/2516: Neural Networks and Deep Learning (Roger Grosse)
    • Modern deep learning research, in particular implementing attention mechanisms in a Transformer, and implementing a CycleGAN.
  • CSC2541: Machine Learning for Health (Marzyeh Ghassemi)
    • A graduate seminar course looking at research into applying machine learning in the clinic, with major project and problem set components.

First Year

  • MAT240: Algebra I (Eckhard Meinrenken)
    • We used the book Linear Algebra by Insel, Spence, and Friedberg.
    • Proofs in linear algebra are all so clean. This was a great way to be introduced to proofs.
  • MAT247: Algebra II (Stephen Kudla)
    • We used the book Linear Algebra by Insel, Spence, and Friedberg.
    • We learned about the Jordan Canonical Form, which was super confusing and hard to compute. But then it came up later in my ODEs class which was cool.
    • We also learned the Cayley-Hamilton theorem, which was super weird. I think it has a lot of interesting applications but I haven’t encountered one myself outside this class.
  • MAT157: Analysis I (Joe Repka)
    • Closely follows Michael Spivak’s Calculus. This course was my first introduction to pure math, and is particularly known for rigorously constructing the real numbers using dedekind cuts in the first month.
  • CSC148: Introduction to Computer Science (David Liu)
    • I had tried and failed to teach myself about recursion and binary trees before taking this course. This course taught me those concepts really well, and moreover I was surprised how easy it felt to learn them.
    • I meta-learned that learning new things is much more efficient when you can find a good resource to learn it from rather than just trying think really hard about it for a long time and getting frustrated.
  • CSC165: Mathematical Expression and Reasoning for Computer Science (Danny Heap)
    • One cool thing we learned was connecting number theory concepts to applications to RSA in cryptography.
  • CSC207: Software Design (Lindsey Shorser and Jaisie Sin)
    • One random thing I learned in this course was about underflow and overflow in floating point.
    • Besides this, I think the course would have been more interesting if there was a larger project component.
  • CSC240: Enriched Introduction to Theory of Computation (Faith Ellen)
    • The most challenging course I’ve taken. Heavy emphasis on problem-solving techniques and thinking deeply combined with rigorous proofs (including formal proofs.)
    • For one problem set we were given the Boyer-Moore majority voting algorithm and had to come up with and prove our own invariants to show correctness.
  • CCR199: Common Humanity (John Noyes)
    • A small seminar course looking at the idea of common humanity throughout history, with a particular focus on Apartheid in South Africa.
  • LTE199: Biotechnology and Society (John Coleman)
    • A small seminar course looking at the potential impact of various biotechnologies such as CRISPR-Cas9 and paradigms such as personalized medicine.