CS 300 — Programming II

CS 300 covers a variety of concepts, ranging from the basics of object-oriented programming and algorithm analysis to data structures like linked lists, stacks, queues, and priority queues. These concepts are important for tackling algorithmic problems, whether on LeetCode or in competitive programming more generally.

I had Jim Williams as my instructor. Lecture time was split roughly 75% TopHat questions and 25% concept explanation. Since I'd already learned most of the material before, I found myself wishing he'd spend more time explaining concepts — digging into algorithms like insertion and removal for binary search trees, or heapify and percolateUp/percolateDown for priority queues — and moved the TopHat questions to post-lecture exercises instead.

Outside of lecture, there are weekly programming assignments spanning multiple files and classes, usually implementing a particular data structure in practice. These can be time-consuming, especially when writing robust test cases — it usually took me 4 to 6 hours to finish one.

ECE 210 — Introductory Electrical Engineering

ECE 210 builds the foundation for hands-on electrical engineering. Most of the content needed is covered in AP Physics C: Electricity and Magnetism, and the rest is building circuits on a breadboard to perform a particular function using an Arduino UNO R3 during the 2-hour weekly lab. Beyond the weekly labs, there's one exam on building circuits from a schematic and a final custom project.

The most useful skill I picked up was designing my own PCB in EasyEDA and soldering it together.

My TA, Qingyi Zhou, was really patient and generous with his time during labs — he'd spend a lot of time looking over my circuits to help identify bugs, suggest fixes to try, and explain why something wasn't working.

MATH 234 — Calculus: Functions of Several Variables

MATH 234 is the third course in the calculus series — Calculus: Functions of Several Variables. It covers chapters 12 through 16 of Stewart's Calculus (9th ed.), across two 75-minute lectures a week for 15 weeks.

The first three chapters — vector basics, vector functions, partial derivatives, and gradients — are fairly straightforward (chapter 12 is actually covered in the Taiwanese public high school curriculum). Things get trickier starting with chapter 15's multiple integration, which requires understanding the Jacobian and integrating in cylindrical and spherical coordinates in 3D space. Chapter 16, on vector calculus, is even more abstract, and the pace picks up considerably — line integrals, surface integrals, Green's theorem, Stokes' theorem, and the Divergence theorem all require connecting the math to physics concepts and thinking in three dimensions.

Exams are fair — just work through past exams and the review packets the TAs provide.

Dr. Matt DeLong is genuinely amazing at teaching, giving vivid intuition for different concepts (he'll literally explain how curl works by dancing at the front of the class). That said, because the course isn't proof-based, some details get glossed over in order to keep the theorems approachable. For anyone who wants to understand the material more thoroughly, I found Dr. Trefor Bazett's Vector Calculus series really helpful.

CS/ECE 252 — Introduction to Computer Engineering

CS/ECE 252 covers the basics of computer engineering — different number representations, two's complement, truth tables, and LC-3 instructions (Little Computer 3, a simulation of assembly language). The first few weeks are relatively easy if you've taken AP CSP before. The real focus of the class is the later part, on assembly: how registers communicate with memory at a low level through operate, load, and store instructions, plus things like context save and restore, subroutines, and branches — none of which I'd done before, having only programmed in high-level languages. The concepts themselves are straightforward, but there are subtleties in the wording of problems, so read the descriptions carefully.

The class is known for its flipped-classroom format, which I don't enjoy that much — I have to carve out my own time to learn the material a week ahead through videos, and actual lecture time is spent on timed, graded exercises covering what those videos taught. Most of the time I can learn the content fine on my own, but when I misunderstand something, I'm still required to finish all the questions in the timed exercise before I can clarify it with an instructor or TA. The graded exercises don't weigh much in the overall grade, but I still prefer learning during lecture and practicing on my own.

MATH 341 — Linear Algebra

Madison offers several different linear algebra classes, and MATH 341 is the proof-based one. If you didn't take the 375–376 series but still want to learn linear algebra more deeply, this is a good option — just keep in mind the class structure varies a lot by instructor, since it's a small class taught differently by each, with different exams and textbooks.

I took it with Dr. Williams. She puts a lot of effort into class prep — each lecture comes with a printed copy of lecture notes with blank spaces to fill out, which helped me a lot in understanding definitions and applying abstract ideas. She also sets aside lecture time for small-group activities, which helped the material land a lot better.

ECE 203 — Signals, Information, and Computation

This is where you learn about the Fourier Transform and the Discrete Transform — ways of turning a signal from the time domain into the frequency domain.

Like CS/ECE 252, this class is taught in the flipped-classroom format: you watch lectures on your own and do exercises during lecture time. I personally found the videos a little confusing at times, since the professor who recorded them didn't always carefully derive every step needed to arrive at a formula — he'd often just show all the steps at once and briefly go through them, so I had to pause frequently to work through the concept myself.

ECE 352 — Digital System Fundamentals

This class is pretty much a continuation of CS/ECE 252 with an identical class structure, just going deeper into everything. And you also get to learn Verilog and HDL!

ECE 353 — Introduction to Microprocessor Systems

I personally didn't enjoy this class that much — it's designed to be self-taught. I'd spend about 1.5 hours on average before every lecture watching pre-recorded videos about different ways to interact with microcontrollers, and lecture time itself was spent on in-class exercises applying what the videos covered. Exams make up 75% of the grade, so read the online course material very carefully — the exams are online, and you can only answer each question once.

CS 400 — Programming III

CS 400 covers a mix of tools, data structures, and algorithms — each week pairs one data structure or algorithm with a specific tool. Data structures range through self-balancing trees like red-black trees, AVL trees, and B-trees; algorithms cover the basic graph algorithms (BFS, DFS, Kruskal's and Prim's for MSTs) and linear sorts. Tools covered include Git, Makefiles, and JUnit. Overall, it's a very practical course that bridges basic CS knowledge into upper-level courses, and it'll get you a lot more familiar with working on large-scale software, since projects rely heavily on Git.

I took Connor's section. He's a very patient, articulate PhD student who's generous about taking questions after class, and he carefully designed his lecture slides to walk through each topic in detail — motivation, definitions, and visualizations, plus occasional TopHat questions to reinforce learning. That's extremely helpful for both learning and review. On top of that, weekly assignments, quizzes, and activities effectively helped me get familiar with the tools and algorithms in practice.

MATH 431 — Introduction to the Theory of Probability

I took this class in the summer session, and I liked the content a lot — it's both very theoretical and practical. It covers all sorts of distributions for random variables, from discrete to continuous (normal, Poisson, exponential, negative binomial, etc.), and it's important to understand how each distribution applies to different situations rather than just memorizing the formulas.

CS 354 — Machine Organization and Programming

I think this is the most important foundational CS class — it's a prerequisite for upper-level classes like OS and compilers. I took it in the summer session, and it was pretty fast-paced: within 8 weeks of lecture, we covered both C programming and a lot of low-level concepts, like the memory hierarchy, caching, the heap, and loaders. I kind of regret taking it in the summer, along with my other fast-paced summer classes — I could've spent more time with the material during a regular fall or spring semester. But it does let you get into upper-level classes earlier, so consider taking it as soon as you can!

CS 532 — Matrix Methods in Machine Learning

I took this class in the summer session; it's pretty much a linear algebra class with applications to machine learning. It covers several classical machine learning models for most of the class, along with training methods and ways to avoid overfitting through techniques like cross-validation. I enjoyed the last part of the class the most, which teaches how backprop works — essentially the chain rule in disguise.