The Missing Semester of Your CS Education

The premise is a complaint, and it's a fair one. Computer science degrees teach algorithms and type theory and then hand graduates a terminal they've never been taught to use. Anish, Jon and Jose built this at MIT to fill that gap — the shell, a real text editor, the parts of version control nobody explains, debugging, profiling, and the general craft of using your tools well.

It's freely available, self-paced, and has been running in January sessions since 2019. What most people don't realise is that the lecture list has changed.

The current lecture list

• Course Overview and Introduction to the Shell
• Command-line Environment
• Development Environment and Tools
• Debugging and Profiling
• Version Control and Git
• Packaging and Shipping Code
• Agentic Coding
• Beyond the Code
• Code Quality

Compare that with the version most people bookmarked years ago and the shift is obvious: the shell-tools, vim and metaprogramming lectures have given way to packaging, code quality, and a lecture on agentic coding. Whether that's an improvement depends on what you wanted from the course, and it's worth knowing before you arrive expecting the old lineup.

The Git lecture is the reason to be here

Most Git teaching is a list of commands to memorise. This one starts from the data model — objects, trees, commits, references — and derives the commands from it. Half an hour in, rebase stops being frightening, because you can finally picture what it's doing to the graph. If you take one thing from the whole course, take that lecture.

The honest weakness is depth versus breadth. Each topic gets roughly an hour, which is enough to know a tool exists and not enough to be good at it. The shell lectures will not make you competent at shell scripting; they'll make you aware of what's possible. And the exercises, while good, are unmarked and easy to skip, which most people do.

Who it's for — and who should skip it

Aimed squarely at CS students and self-taught developers who write decent code and feel slow at everything around it. If you've ever copied a Git command off Stack Overflow without knowing what it did, this is for you.

Skip it if you've been in the industry a decade — much of it will be familiar, though the newer lectures may not be. Skip it too if you want a deep dive on any one tool; this is a map, not a manual.

Our take

The highest value-per-hour course on this entire list, and one that keeps changing under people who recommend it from memory. Just don't mistake the map for the territory — an hour on debugging makes you aware of debuggers, not good with one.