Self-studying Classes

To be honest, the content in most CS classes (especially after you get through the intro sequences and have a solid foundation) at Brown isn't beyond the realm of self-studying, but most people don't do it, because self-learning an entire course worth of content is hard:

• There's no imposed structure
• There's maybe less motivation
• Less help (e.g. from TAs) when you run into problems

I first started thinking about this concept when a guy who I look up to told me he has done this for core CS classes traditionally considered difficult and "must-takes", like networks, OS, and distributed systems, where the primary challenge is building a semester-long project (i.e. TCP/Weenix).

Why Self-Study?

Having given this idea some thought recently, I've come up with some arguments for why self-studying is situationally worth doing to streamline the process of learning something — you might even save time and effort by self-studying the thing as opposed to spending a semester taking the actual class. Here's why:

• Most classes move at a relatively pretty slow pace. The assumption is that you will work on the thing intermittently as you deal with everything else going on at college. There's a fixed cost associated with context switching like this — the learning process will be more streamlined if you work on it straight for one/two weeks and get the thing done (which in hindsight, seems very possible for some classes, e.g. IP/TCP). tldr; you can move at your own pace and get things done faster.
• There's no stress on a grade. Not like there's that much stress on a grade anyways at Brown, but there's really no stress if you just self-study the course. If you are self-learning the thing anyways, a grade probably isn't likely to keep motivation.
• You can take what you want from the course and ignore the rest. Self-studying lets you selectively pick out what you want to learn from the course's syllabus. This might be ill-advised for certain courses, but can work to your advantage — for example, you can skip content that you already are familiar with or breeze through assignments that are stupid.

Especially True for Disorganized Classes

This is especially true for classes that are disorganized and don't have their shit together, like classes that are being taught for the first time. In these kinds of classes, you might see these kinds of problems:

• The stencil code is bad or not well-thought out
• The autograder (if there is one) is broken
• There's a ton of environment setup issues
• The assignments are either too easy or too hard
• The expectations are very ambiguous

All of these reasons have the potential to make taking a class really annoying, where in contrast, a well-taught class usually has assignments that are very well thought out and abstract away everything else except the core concepts being taught and present challenges at an appropriate difficulty to encourage learning.

When to Consider Self-Study

tldr; if the course materials for a class are readily accessible (e.g. via the website of a past iteration of the course), the topic is not too niche (so that there will be plenty of resources to look at online), you haven't heard raving reviews about the course (but you still want to take the class), it might be worth just learning yourself. (Note: This might be applicable mostly for project-based classes).

Inspired by aforementioned dude, I'm going to try this for distributed systems.