1024 points by saikatsg 1101 days ago | 336 comments on HN
| Strong positive
Contested
Landing Page · v3.7· 2026-02-28 08:48:58 0
Summary Education Access Advocates
The Missing Semester of Your CS Education is a free, MIT-developed course teaching practical computer science tools and techniques (shell, version control, debugging, AI tools, code quality), made available globally via YouTube and translated into 14+ languages under a CC BY-NC-SA license. The resource advocates for Article 26 (education rights) and Article 27 (cultural/scientific knowledge sharing) through deliberate commitment to open access, multilingual availability, no registration barriers, and explicit invitation for global community participation. No human rights concerns or violations are evident on the page; the resource's structure and distribution model uniformly support education and knowledge access principles.
The content taught here is the highest payout thing you can learn, in my opinion. Certainly more important than actually writing code or learning algos.
What this content covers should unlock iteration speed, which is the single greatest lever in learning and growing faster (on a computer). Thus it gives you more cycles to go back to improving your code, experimenting with algos, etc. Probably also highly correlated with upwards mobility in the software job market.
Great seeing this under a common umbrella I can hand to students and new grads.
I love vim, it's great to know how to navigate it, but I have met very few people who use it professionally. I'd love to hear others' experiences, there.
As far as cryptography is concerned, I think one of the best options these days is to teach the libsodium API. It's very rationally structured and well documented, and also available on every platform and in every language. Most importantly of all, there's nothing in there that you shouldn't use, which is one of the biggest problems with real world cryptography.
It's amazing how many CS programs fail to teach you even the basic tools of being a software developer. Yes, yes, CS is not programming, but there is a non-trivial amount of CS that is indeed programming, and that is generally what people do with their CS degrees, so it'd make sense for a CS program to teach the basics. Maybe even more than the basics.
We're teaching a course at ETH Zurich [1] where --besides the actual payload of solving partial differential equations (PDEs) on GPUs-- we put a lot of emphasis on "tools". Thus students learn how to use git and submit their homework via pushing to a repo of theirs on github, we teach testing and continuous integration, writing documentation, running code on a cluster, etc. In their final project, again submitted as a GitHub repo, they need to make use of all of theses skills (and of course solve some PDEs).
Note that excellent work in this space is done by the Software Carpentry project which exists since 1998 [2].
Lots of laudatory comments here about this being essential but missing teaching but I have a different take. The content looks good, nothing wrong with teaching these things. But these things can be and are learned on the job fairly quickly for anyone interested enough in the field and with enough aptitude. In fact, I would say these things can be learned on your own time as a side effect of being interested in computers.
So I would say it's good content, but not essential for a CS program.
Always think we should do this at uni and even for our PhDs. Some students are actually much better in control of those tools than their advisors, but it is still a minority. Always lacking the time to teach this. German system lacks incentives for actual sensible courses IMHO (applied universities might be a bit different)
BTW: Pops up every year seemingly. E.g. 3yrs ago with more than 1000 comments:
What's has only a single, passing mention in the article, and none here, is how this fits in to MIT's curriculum. The content is supremely useful, but does not properly fit into a traditional college semester 10-week course schedule. MIT has this weird 'half semester' in which to fit this, and similar shaped content, for all disciplines. It is largely student run, as we see here.
> Independent Activities Period (IAP) is a four-week period in January during which faculty and students are freed from the rigors of regularly scheduled classes for flexible teaching and learning and for independent study and research. IAP is part of the academic program of the Institute—the "1" month in MIT's "4-1-4" academic calendar. Students are encouraged to explore the educational resources of the Institute by taking specially designed subjects, arranging individual projects with faculty members, or organizing and participating in IAP activities. They may also pursue interests independently either on or off campus.
I personally don't like the undertone of the class (tho very grateful that this material exists!!!) - this idea that universities are failing their students by not teaching them necessary material. I think a better phrasing is that students are failing themselves by not learning the material. I've personally never considered it the responsibility of my university to educate me - some of the classes are certainly useful for learning, but the ultimate onus falls on me to gain the skills that will lead me to success. I find it kind of distasteful how classes encourage a sort of passive victim mentality when it comes to learning - as if students need to be bribed with credits and cudgeled with a gpa to be forced to learn genuinely useful things.
I started college in 1993 and my school had a mandatory "Introduction to Unix Computing Environment" class for all incoming engineering freshmen.
We learned the basics of the shell, file system, file editing, AFS ACL's for group projects, and more. It looks very similar to this MIT course which makes sense as our school's computing environment was based on MIT's Project Athena and AFS (Andrew File System)
I looked and the same course is still mandatory for incoming engineering students.
I'm in the semiconductor industry and everything runs on Unix / Linux. Back in 2000 we would get new grads that knew very little about Unix, command lines, or scripting. That kind of stuff is half my job. These days Linux is so popular that most of the new grads know this stuff.
I have tried in vain to get this implemented at our uni. I can say a few things I find interesting:
- Students used to get this stuff but no longer do, for example all workstations used to be unix, so when you left, you "knew" "unix" (shell, vim, etc)
- Due to things like ABET, classes are crammed with need-to-know-for-accreditation info so, well, some items need to go by the wayside (many are in the MIT list)
- There is a huge push, even by ABET, for security and crypto to be somehow integrated into nearly every class.
- Professors seem aware that we need this "missing class", but it is hard for administrators to implement, because: Universities were pressured into lowering credits to grad, so some courses were removed, so there is no room left for another course.
I am not pushing one way or another, and I only have the vision of working at two universities, but I think unis need to take a real hard look at their courses from a holistic point of view. I recall stumbling across that MIT course at least 5 years ago. I do not know many others who implemented something like that.
Excellent guide! Lol at title though, I just realized how spoiled I was with my CS degree from Drexel.
We had a UNIX tools and an Advanced Programming Techniques course. Both gold. Taught from the sausage dog book and the Unix Programming Environment book iirc. Totally standard texts I thought?
Instead of smashing tools into a single class, they should be incorporated early and throughout the curriculum so they can aid students as they progress.
For example we have a sophomore fall class called Linux/Unix Programming that covers about half of these topics and a sophomore spring class called Open Source Software Development that covers the rest (and philosophy, history, etc.). We have an advantage for this sort of work, though, in that we’re not a prestigious research university, but instead a small teaching college that calls ourselves “professionally focused.” Meaning while we have a CS degree, we acknowledge that 90% of our graduates will become software developers. That approach means that while theory is still important, tools for software development are very intentionally incorporated as part of the core of what we teach. Think of it as a blend of CS and software engineering (which is also one of our concentrations for a deeper dive).
I'm torn on this. As somebody who is too stupid to goto MIT, I chuckle thinking of spoon-feeding how to use Git or a terminal to MIT students. It's useful information but not everything useful needs a sit-down, by-the-numbers, "this is how you branch" discussion. I also wonder if it does more harm than good teaching these topics so matter-of-factly since it's only the current programming zeitgeist anyway. It only further entrenches the "way things are". Like depriving children of that impactful exploratory phase and sticking them into a rigid box. In any case- won't these topics propagate natually from good professors using them themselves? What do I know, I'm too stupid to attend MIT.
My university had Dijkstra's quote "Computer science is no more about computers than astronomy is about telescopes". They made us aware of tools and we were free to use them as little or as much as possible to do the science. I always assumed that software engineering degrees focused on tools more than computer science degrees (among other differences).
A thought occurred to me when I read this bit. Two thoughts, actually. But they're related.
We’ve also shared this class beyond MIT in the hopes that others may benefit from these resources.
Thought one: they should make this an official OCW thing
Thought two: OCW class resources should be a two way street, like open source development, not just a "throw it over the wall" model.
Not that I'm criticizing MIT for making any content freely available, mind you. Any free, high quality, educational content makes the world an overall better place IMO. No, it's just that I saw this bit:
Editors (Vim)
and couldn't help but think "Great, but what about Emacs?" Which got me thinking something like "Well, why couldn't I, or somebody else (preferably somebody actually qualified) create a corresponding 'Editors (Emacs)' section and contribute it back?"
I dunno, maybe it's a nutty idea. And certainly for the stuff that is released by OCW under corresponding open licenses, I suppose one could "fork" the class somewhere else and run it on a model where outside contributions are accepted. Anyway, this just got me thinking about this concept.
EDIT: never mind, I actually just noticed that this particular course actually is on Github[1], and they do accept pull requests! Very cool.
Would still be cool to see that approach become even more widespread for OCW courses (both from MIT and elsewhere).
The content similar to this is being taught at Indian Institute of Technology Kanpur for well over a decade. It runs as 3 different courses seperated in different semesters depending on complexity and prerequisites:
I think they should add a lecture on test driven development and CI/CD pipelines (e.g. Github actions). And I think after such a course people should be capable of using Github, but for that it also lacks a discussion of issues (or ticket systems in general) and pull requests.
Instead of a whole lecture on Vim they should rather teach a modern editor like VS Code or how to use a real IDE like IntelliJ. With these modern editors you also get refactoring and a Gui for Git, which makes it much less painful to use.
So all in all its a good start, but already outdated on several topics.
Lots of people at my work use it, but I don't know if I'd consider it essential. If you can use any editor/IDE very fluently that's good; probably doesn't hurt to learn with vim if you don't already have that.
I use (Neo)vim as my daily driver, professionally (for the past 4 years, coming from Goland). I've found every other editor to be too heavy/slow (VScode/Jetbrains), or too noisy (regarding features).
Neovim allows me to specify the precise minimum I desire to have a fully functional IDE-like experience (basically treesitter + LSP + DAP + minimal extra plugins).
It's super fast, I'm already in my shell, and my memory usage gets to stay super low :)
I went to Purdue over a decade ago and we had a 1 credit hour lab that taught this stuff. Unix command line, git, bash, and finally some python.
Like you said, it's been a complete game changer. I feel these skills continue to differentiate me from my peers in terms of how I can attack arbitrary problems bravely to this day.
I use Vim infrequently. I know it and if it was the only option I'd be efficient with it. I've even started with Vi as the only option. However I prefer Emacs because I feel way more efficient and comfortable with it. As a bonus main key bindings are consistent with Bash and others GNU tools. The course should introduce Emacs as well so that students can choose on their own. Whatever your preferred editor is IMHO it is up to an IDE to integrate with it.
CS programs prepare you first and foremost for a PhD in CS. They're great for learning the theory and fundamentals, but teach practical Software Engineering skills as a side effect.
I sat with a talented developer whilst we wrestled with a threading issue this past week. I wanted to inspect the value of a variable within a method during execution and asked him to set a breakpoint. He didn't know how to do that in the IDE, which he'd been using for over a year. Debugging is indeed a skill which needs learning.
I use neovim with Ale plugin for LSP and linters. Somehow it maps into my brain better than anything else. Its fast, on cli, feature rich, usable without a mouse...
The only thing where vim/neovim really sucks against other tools is the project specific configuration.
I was on the CS faculty at a Canadian university in the 1980s. I proposed a course with almost exactly this outline, only to be told it wasn't university-level material. MIT seems not to have got this message; good on them!
I'm not fond of Vim, have been an Emacs user for going on 40 years, starting with Gosmacs. That said, I'd rather that students learn one editor really well, rather than the smattering of editor/IDE usage most of them seem to acquire. So, fine, teach them enough Vim that they can use it well, afterwards, they can use whatever editor they choose.
As an alumni, thanks a lot for doing this. Looking back, all the things that I've learned in just the first few weeks in the industry made writing code so much more productive - if only someone had shown some of it already during some early semester, even just during some assistant teaching hour, it would have saved so many hours.
I remember specifically when one of the exercises for some compiler lecture contained unit tests the code had to satisfy, and I was like, wow, why didn't I already knew about this during algorithm classes earlier where I was fumbling around with some diff-tools to check my output. Let alone proper version control, now that would have been a blessing.
In hindsight, it's a bit embarrassing that I didn't bother to, well, just google for it, but neither did my colleagues - I guess we were so busy with exercises and preparing for exams that we just didn't have the time to think further than that.
I don't think you're wrong that you can learn this stuff on the job, but a "primer" kind of class like this which surveys several useful tools helps new engineers develop pattern matching skills around how to continue self-teaching these kinds of things. Shell/scripty/vim-ey,linux-ey stuff can be really challenging to learn how to learn for some people.
a) Universities are places of higher learning that do not need to cater to industry
b) There is an implicit social contract whereby universities should produce industry-ready graduates
c) Something in-between
… the skills taught in this course are as useful for the PhD candidate as for the junior software engineer.
Why leave these out or up to the student, then?
Furthermore, in many other academic disciplines, it’s very common to teach applied technique (eg, on writing essays or structuring research), is this any different?
I think it’s dependent on the person learning the material. My college had a similar course and it was also highly regarded as useful by students. However, while I found the course fun I already knew most of the basics from my research job, and the advanced stuff hasn’t really come up again even in work (e.g. fancy git or gdb commands), so I’ve entirely forgotten it; my biggest takeaway is probably ctrl r for searching in shell. But I can see why a guided intro would be really helpful to someone who had no experience or some trouble getting started learning this kind of material (which is very different from programming or computer science).
There’s probably an aptitude threshold past which the course’s value diminishes - don’t mean any disrespect to anyone, just trying to expand on your point. The top students either have already figured it out or will do so easily, so they might be better off doing something else with the time they would’ve invested in this. But for a lot of students learning about these tools and concepts can be a real force multiplier, more so than a random upper level course.
I think it can be useful to distinguish between the "known and unknown unknowns" here. For example, everyone will quickly realise that that they need to know git, and they will learn what they need to know (a known unknown). A university course would maybe save them time, but it would not really change what you know after 2 years in industry. Compared to e.g awk or shell scripting which can be incredible usefull, but maybe not something people realise by themselves that they need (a unknown unknown). A university should make people at least aware of these latter tools.
Any reason why you would use jq over Python? Certainly this can be attributed to my lack of knowledge in jq, but anything beyond a simple query is going to be done with Python for me. Beyond not having to look up query syntax, doing it in Python (or any script) is easier to read (both during and after writing it) due to auto formatting in an editor.
I think this is mostly a US thing, or countries based on similar education systems.
In Portugal our computing degrees are Informatics Engineering to use a literal translation, a mix of CS stuff and Engineering. And validated by the Engineering Order as fulfilling certain requirements, for anyone that at end of the degree also wants to do the admission exam for the professional title.
Those that only care about the theory part of CS take a mathematics degree with major in computing.
I have this feeling that the kids who appear better at uni are the ones who happened to pick up certain not-quite-programming skills before they started. Basics of networking, how installation of programs happens, how to use the command line, that kind of thing.
I looked over her shoulder as my wife was doing a CS degree, and I realised there's a bunch of these little things that make life a lot easier if you know them.
You don't consider paying tens of thousands of dollars as creating responsibility to educate?
Of course, students need to be active in the learning process. But in my experience, it is more likely that professors and departments are terrible at educating than it is for students to not be motivated to learn.
I'm surprised anyone would object to this. Universities have a responsibility to prepare their students.
When I saw the title I figured it was another "computer science" class. But the curriculum was a significant portion of what I lacked when I graduated, which prevented me from finding work for a year.
Had someone at university told me before I graduated that I'd have no chance of finding work if I didn't know Git, Linux, REST, how to use the command-line, how to use an IDE, how to use an editor on the command line, and bash, I would have prepared myself for those things.
Indeed. While I think learning algorithms and ds is a non-negotiable thing, in 90% of the companies out there in 90% of the situations one will never have to write a binary search from scratch or implement a queue from scratch. On the other hand, profiling, debugging, glueing things together via bash, etc., that’s what distinguishes you from the colleges who only write passable code.
> The class is being run during MIT’s “Independent Activities Period” in January 2020 — a one-month semester that features shorter student-run classes. While the lectures themselves are only available to MIT students, we will provide all lecture materials along with video recordings of lectures to the public.
It seems that the course is only 1 month and runs alongside some student-run classes. So this is from the get go not an essential course of a CS program.
I think you’re conflating two different things: universities selecting and presenting a syllabus needed to earn a certain degree, and students actually learning the material.
The latter is the solely the responsibility of each student, but I don’t understand why the former would be. Some of the content in this course strikes me as unknown unknowns for new programmers. Why would they be to blame if no one told them to learn a particular skill?
Even though a lot of incoming students would have had PCs by that time, they'd mostly have been running Windows. As you suggest, as I understand it MIT really focused on Project Athena clusters for engineering work and people used PCs more for word processing, etc.
> the ultimate onus falls on me to gain the skills that will lead me to success
I see where you're coming from, but sometimes you don't even know what the necessary skills are. Even if you're very self-motivated and enthusiastic, you can still benefit by being pointed in the right direction. That's part of what a good school or teacher should do for you. (And while they're at it, they can provide materials that smooth out the path to get there.)
You should never expect them to cover 100% of that, but if they're aware of a way that they can get closer to 100% than they currently are, then it's a good thing for them to do it.
Note that this is not part of the CS curriculum at MIT. It's a series of classes during Independent Activities Period in January which is mostly unstructured time when students can do or not do any activities that catch their fancy. It works well for this sort of thing but students also do a ton of stuff that isn't especially academically-related.
> I do not know many others who implemented something like that.
the school I did in france, ENSEIRB-MATMECA, started with three weeks where you only learn shell commands, emacs, LaTeX etc before doing anything else. Here are the slides (in french sorry, although they all have useful reference cards at the end):
This “MIT Course” was taught by grad students because they felt the actual course work left this out.
So when you say it’s a shame your uni doesn’t teach this, well, that’s what these grad students were saying as well. Perhaps the students could seize the initiative at your institution as well?
Page explicitly defines course as educational: 'Classes teach you all about advanced topics' and 'We'll teach you how to master the command-line, use a powerful text editor...and much more.' Course is framed as addressing documented educational gap: 'there's one critical subject that's rarely covered...is instead left to students to figure out on their own.'
FW Ratio: 71%
Observable Facts
Page states: 'Classes teach you all about advanced topics within CS' and lists 8 structured lectures with dates.
Videos are published on YouTube, a free public platform with global accessibility.
Page explicitly identifies an educational gap: 'there's one critical subject that's rarely covered, and is instead left to students to figure out on their own.'
Course is licensed under CC BY-NC-SA, explicitly permitting educational use and redistribution.
Page mentions institutional support from 'MIT Open Learning' and 'SIPB' and invitation to contribute translations via pull requests.
Inferences
The systematic curriculum design (8 lectures covering shell, environment, tools, debugging, version control, packaging, code quality, and AI) demonstrates deliberate educational architecture addressing a documented gap in CS pedagogy.
Institutional investment combined with global free distribution, multilingual availability, and explicit invitation for community participation indicate structural commitment to making education broadly accessible beyond institutional boundaries.
Page frames technical tools as enabling scientific advancement: 'Mastering these tools...lets you solve problems that would previously seem impossibly complex.' Explicitly integrates current scientific advancement: 'many aspects of software engineering are in flux through the introduction of AI-enabled and AI-enhanced tools...we've folded the use of the latest applicable AI tools and techniques into each lecture directly.'
FW Ratio: 67%
Observable Facts
Page states course teaches 'how to master' tools and 'solve problems that would previously seem impossibly complex,' framing as scientific/technical capability building.
Explicitly mentions integrating 'latest applicable AI tools and techniques into each lecture directly,' reflecting engagement with current scientific advancement.
Page states: 'Have you created a translation of the course notes from this class? Submit a pull request so we can add it to the list!' — explicit invitation for global community knowledge contribution.
Source code is published openly with 'CC BY-NC-SA' license, permitting sharing and modification for educational purposes.
Inferences
By teaching tools for participation in scientific and technical communities and explicitly integrating current AI/scientific advances, the course enables Article 27's principle to 'share in scientific advancement and its benefits.'
The structured invitation for global community translation and open-source publication combined with CC licensing demonstrates commitment to participatory knowledge creation across national and institutional boundaries.
Course is described as shared 'beyond MIT' with implicit inclusivity, but does not explicitly address discrimination or equal access principles.
FW Ratio: 67%
Observable Facts
Page states the course is 'shared beyond MIT in hopes that others may benefit.'
Explicitly lists translations in Arabic, Bengali, Chinese (Simplified and Traditional), German, Italian, Japanese, Kannada, Korean, Persian, Portuguese, Russian, Serbian, Spanish, Thai, Turkish, and Vietnamese.
Content is licensed under CC BY-NC-SA, permitting use and modification by anyone.
No login, registration, or payment barrier visible; materials accessible to anyone with internet access.
Inferences
The deliberate provision of 14+ language translations and invitation for community translations suggests structural commitment to making educational content accessible across linguistic and cultural boundaries.
Free, open-access distribution combined with lack of enrollment restrictions indicates efforts to prevent discrimination based on geography, income, or institutional affiliation.
Preamble principles (dignity, equality, inalienable rights) are not explicitly engaged in course description, though education supports these implicitly.
Course teaches tools (shell, text editor, version control) that enable expression and communication, but does not explicitly engage with free expression rights.
Strong structural support: completely free access with no registration barrier; videos freely available on YouTube globally; 14+ language translations; CC BY-NC-SA licensing permits educational redistribution; MIT institutional support (Open Learning, SIPB) demonstrates educational infrastructure investment; page explicitly invites 'Beyond MIT' participation and global collaboration.
Open source publication ('Source code' linked), CC BY-NC-SA licensing, global distribution, 14+ language translations, and invitation for community contributions (translation pull requests) all provide structural evidence of knowledge sharing and cultural participation across borders.
Free access, no registration barriers, CC BY-NC-SA licensing, translations in 14 languages, and links to global discussion platforms (Discord, HN, Reddit, X, Bluesky, Mastodon) all provide structural evidence of non-discriminatory access.
build 1ad9551+j7zs · deployed 2026-03-02 09:09 UTC · evaluated 2026-03-02 11:31:12 UTC
Support HN HRCB
Each evaluation uses real API credits. HN HRCB runs on donations — no ads, no paywalls.
If you find it useful, please consider helping keep it running.