Over the years, we (@anishathalye, @jjgo, @jonhoo) have helped teach several classes at MIT, and over and over we have seen that many students have limited knowledge of the tools available to them. Computers were built to automate manual tasks, yet students often perform repetitive tasks by hand or fail to take full advantage of powerful tools such as version control and text editors. Common examples include holding the down arrow key for 30 seconds to scroll to the bottom of a large file in Vim, or using the nuclear approach to fix a Git repository (https://xkcd.com/1597/).
At least at MIT, these topics are not taught as part of the university curriculum: students are never shown how to use these tools, or at least not how to use them efficiently, and thus waste time and effort on tasks that should be simple. The standard CS curriculum is missing critical topics about the computing ecosystem that could make students’ lives significantly easier.
To help mitigate this, we ran a short lecture series during MIT’s Independent Activities Period (IAP) that covered all the topics we consider crucial to be an effective computer scientist and programmer. We’ve published lecture notes and videos in the hopes that people outside MIT find these resources useful.
To offer a bit of historical perspective on the class: we taught this class for the first time last year, when we called it “Hacker Tools” (there was some good discussion about last year’s class here: https://lobste.rs/s/h6157x/mit_hacker_tools_lecture_series_on). We found the feedback from here and elsewhere incredibly helpful. Taking that into account, we changed the lecture topics a bit, spent more lecture time on some of the core topics, wrote better exercises, and recorded high-quality lecture videos using a fancy lecture capture system (and this hacky DSL for editing multi-track lecture videos, which we thought some of you would find amusing: https://github.com/missing-semester/videos).
We’d love to hear any insights or feedback you may have, so that we can run an even better class next year!
– Anish, Jose, and Jon
I think this is great! At the University of Notre Dame, we believe that some of these topics are important enough that we actually have a required course for it: https://www3.nd.edu/~pbui/teaching/cse.20289.sp20/ . It used to be called “Basic Unix for Engineers”, but it has evolved into a very introductory systems programming course (hence the name change).
Either way, I think it’s great that you are empowering your students. I have shared your website with my current students this semester!
Every slide is password protected, I guess the files are not public?
First lesson is to find out how to crack the passwords, that way you know you’re
1337.Edit or it’s because the link is 9 months old…
At Carnegie Mellon University there is a similar course called Great Practical Ideas for Computer Scientists. It started as a student-taught course, but was adopted by the university after they saw how useful it was. You can find it here: https://www.cs.cmu.edu/~15131/f17/
Great stuff. These are forever skills to me. You’ll learn them once and use them for life. It’d be cool to have a super, really basic overview of networking in here too. DNS, what routing is. Going into SQL might be too rabbit-hole-y. OP: Great topic! Great idea! :)
Very cool. Thanks for making the course contents open and accessible 👍
I think this is a great effort. I definitely missed this during undergrad and I distinctly remember a classmate showing me CVS in my senior year! (yes a long time ago)
Now that I have these practical skills, I find it hard to watch others do these things the hard way.
It’s unfortunate that our software does not facilitate this. Most software in common use actively undermines the entire purpose of the computer; web browsers are a particularly heinous example. Good on you for teaching these skills.
So cool, I’m instantly recommending this to all my friends who have expressed interest in learning to program :)
This is great. I would make an even stronger argument that teaching these skills is a matter of justice and equity. Making this material part of the core curriculum helps to level the playing field and lower the barriers to entry for all students. (It would also be great to see some of these skills taught in K-12!)
Interesting! At Google we have an 8 week program that teaches new grad hires about stuff they typically don’t learn in a CS degree but are valuable for a successful career as a software engineer (e.g. how to read existing codebases, version control, peer code review, writing design docs & unit tests, how to ask questions effectively, giving & soliciting feedback, etc).
Do they ever release those materials to the public?
Some of them. But none of those materials are hard to find on the Internet. The value inside an org comes from facilitating the dissemination of them via live sessions in groups.
Unfortunately because it’s the “missing semester”, instructors that know of these practices end up having to take weeks to months out of their semester to teach how to use Git or Bash and the course ends up suffering for it. Other times, these fine optimizations are instead shunned because doing it the hard/long way is somehow supposed to be a better teacher than actually teaching the material. This ends up rubbing off onto students since they’ll be busy enough trying to stay afloat that they don’t have time, energy, or patience to figure out how to do things besides the way they were told since it’s “good enough”.
Noble goal, but it may end up falling flat in the face of a curriculum that insists on their One True Way™.
Brilliant. Learning these things should be mandatory.
Reading this gave me an epiphany. Back when I studied CS at Georgia Tech in ‘98, we learned these tools along the way as we wrote our code. Why? Because there was no alternate. There simply wasn’t a way other than the shell and vi and make and rcs when your dev environment was a pair of aging SunOS servers named Oscar and Felix that were shared by a few hundred people. My last two decades of hiring junior engineers have been marked by the frustration of having to weigh the balance of a candidate’s code and design and architecture skills against their decreasing knowledge of practical systems skill. I always assumed it was a decline in the competence of universities, but now I suspect that as computing professionals we have done ourself a disservice by not being more self-aware about the actual process of software stewardship.
Thanks for sharing this course - That‘s some knowledge that should be spread way more and even earlier!