18 ms·

The missing semester of CS education

• Jonhoo 7y ago
  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/ 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 great discussion about last year’s class here: https://news.ycombinator.com/item?id=19078281 https://news.ycombinator.com/item?id=19078281). 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 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
  • floatrock 7y ago
    Love this. I remember it wasn't until junior year when I was reading about the theoretical underpinnings of the unix kernel that I learned what the pipe operator I'd been copy-pasting on psets really did. I mean, it's great to learn those underpinnings, but most course 6 classes assumed you already knew all these tools... if it wasn't theory, it wasn't their responsibility to teach it. "Missing Semester" describes it perfectly. Wish there had been something like this back in my day... I remember I felt as if I had learned all the theory behind fluid mechanics but didn't know the first thing about fixing a leaky faucet in my kitchen. Keep up the good work!
  • ericd 7y ago
    Ha some MIT alum friends and I were just talking about how great it would be if something like this existed, rather than having it be left to one’s first years as a junior engineer in a company. Thanks for doing this, it’s sorely needed.
  • foobarian 7y ago
    Since you mention scrolling using key repeat - it truly is painful to watch someone do it on default settings. And there are usually better ways to do that sort of thing. But sometimes, there is no substitute: going to the right spot in the middle of a word/line, moving around a page, browser title bars, etc. Here's the kicker though: most keyboard repeat rate settings around have a maximum that is pretty much unusable! But you can fix it thusly: xset r rate 180 60 When I work on my computer it's like driving a Porsche. When I sit at someone else's it's like I tripped over a door threshold. There are ways to adjust this on OSX too but it's a lot more touchy. Haven't attempted on Windows.
    • aspaceman 7y ago
      Personally this is what I choose to use the mouse for - even in Vim. A scroll wheel is nicely intuitive for descending a buffer.
    • robterrell 7y ago
      > There are ways to adjust this on OSX too but it's a lot more touchy System preferences > Keyboard > Key repeat rate Adjust the slider to your liking. Works in every app. It's been there since 1984, but to the topic, not many users poke around in system settings anymore. If you want faster than the slider allows, try this from the command line: defaults write -g KeyRepeat -int 1
      • foobarian 7y ago
        That's what I mean by more touchy. I think you also can't do this without messing with system integrity protection. And, "1" is the lowest it can go which is not that low IMO. :)
    • arendtio 7y ago
      Well, I think the point was a different one... more like press G
  • msaharia 7y ago
    Hi, how are you getting the keystrokes you type in to overlay on the video? Is there a tool you're using for this? Would be very helpful if you could make it.
    • anishathalye 7y ago
      On macOS, we used this excellent open-source software called KeyCastr: https://github.com/keycastr/keycastr https://github.com/keycastr/keycastr (we used this e.g. in the text editors lecture)
  • brlewis 7y ago
    My feedback is to keep doing what you're doing. Some people will talk about how this kind of mundane training might not be relevant some years later. By the same reasoning students shouldn't learn the layout of their campus or how to add and drop courses, because those skills won't be relevant after they graduate. Keep helping students not waste time now on tasks that should be simple.
  • kamaal 7y ago
    Learning to use the editor macros well, could save anyone lots of effort typing. And should definitely be in your course.
  • ip26 7y ago
    "I choose a lazy person to do a hard job. Because a lazy person will find an easy way to do it." -- Bill Gates Some people just accept absurd drudgery interacting with computers; it never even occurs to them to seek an easier way. But if you can teach the students to be "lazy" when it comes to that kind of repetitive drudgery, they'll be set for life.
    • BurningFrog 7y ago
      I think the problem is more a lack of imagination. They just keep doing things the way they always have. I seem to have a surplus both of "there has to be a better way"-itis, and some skill in finding such ways.
      • honestoHeminway 7y ago
        It starts with the self-perception of ones work as pure drugery. From there it moves into all fields. Monotonous drugery is preferable to attentionneeding drudgery.
      • onei 7y ago
        I call it a lack of curiosity instead of a lack of imagination. Both are useful, but to me imagination is more about coming up with new solutions than understanding how something that already exists can be bent to your will.
        • nkrisc 7y ago
          I think they go hand-in-hand. You have to have some imagination about how something must work (however off-base) to be curious enough to find out how it really works. It often seems to me that people who aren't curious lack it because they can't even imagine something different than what is in front of them. They don't wonder how a car works because they can't even begin to deduce how it might work, from the observable outside in, because they lack the imagination to make those deductions. Someone who's curious might see a car and think, "How does this work? I can see the wheels spin and propel it forward, but something must be making those wheels turn. How do they all spin at the same time? What turns the push of the pedal into making the wheels turn?" etc. I see curiosity and imagination as two sides of the same personality trait expressed in different ways.
  • choppaface 7y ago
    I’d recommend Docker / virtual machines as its own top-level module. There’s essentially no better way than containers to make projects portable and reproducible, and containers are now essential for pretty much any production system. I’ve taught docker to a few dozen people and while they hate it at first (the learning curve can be steep) they love it in the end. Also wish this course covered bazel, maybe in potpourri. Make is important and bazel isn’t standard but bazel is pretty important for large C++ projects. Docker and bazel both have fairly complicated interfaces and the time set aside for a course like this is the perfect time to play with them.
  • inson 7y ago
    I'd recommend making a course on how to create a proper Makefile, from the beginning to the advanced level.
    • joatmon-snoo 7y ago
      Makefiles are worse shell scripts. /religion I do agree with the spirit of this though. There's a big difference between "click a button in your IDE" to compile and learning about all the code-ish things that go into a real software project: * choosing a build system (and package system too, I guess?) * setting up CI * static analysis * setting up CD * config-as-code for managing the state of prod * staging environments? * production monitoring * production alerting
  • dybber 7y ago
    We previously had the same problem at University of Copenhagen, it was called "the hidden curriculum" among students. When the undergraduate programme was reformed a few years ago these subjects where integrated into various courses, so they could be taught in a learning-by-doing fashion. As part of the first programming and problem-solving class (F#), we also teach LaTeX, Emacs and basic use of the command line, as part of a project-based software engineering course (second semester) Git is used extensively, and so on.
    • omarhaneef 7y ago
      Um, quick question: so should one use Emacs as the University of Copenhagen, or VIM as MIT is teaching? (Just kidding)
      • Anthony-G 7y ago
        That question has already been answered: https://missing.csail.mit.edu/2020/qa/#vim-vs-emacs https://missing.csail.mit.edu/2020/qa/#vim-vs-emacs :)
  • huijzer 7y ago
    I think this is an amazing course and indeed missing. I learned the things presented in the course only after graduating CS and working at a company! They (rightly so) thought I was somewhat of a fool because I preferred to use Windows. One thing on the data wrangling. I do think that the Linux tools are powerful, but would like to give some credits to R here. For example, merging tables (similar to SQL joins) is available in the standard library. This in combination with R Markdown for visualization makes it much more easy to use than Linux CLI tools.
  • fuzzy2 7y ago
    That’s cool. Now, on to my possibly unpopular opinion: This isn’t what computer science is about. In fact, you don’t even need to use a computer to do computer science. Sure, some stuff you learn in CS can make you a better software engineer. CS cannot make you a software engineer. CS can definitely not make you adept at using computers and neither should it. That’s something earlier education institutions must tackle. It’s always good to have optional courses for various topics of interest. _Requiring_ students to learn, say, MS Office (I had to), is just plain ridiculous.
    • Nitramp 7y ago
      Science doesn't abstractly drop from the heavens, fully formed. Every science has practical enablers that are required to get stuff done. Astronomers use telescopes, physicists/chemists/etc use lab equipment, Mathematicians use various notations and other tricks (and nowadays proof assistants) to make their job easier. MS Office might not be practical for computer science (also note how the OP doesn't list that), but learning how to write your papers in latex might, and knowing how to use a shell certainly is. E.g. if you'd like students to learn about type theory, they will need to experiment with your compiler. You cannot expect students to miraculously be proficient in this, and explicitly teaching them (and requiring it as a prerequisite course to signal that yes, it's important) can turn weeks of frustration followed by a huge dropout rate into a productive course.
      • swiley 7y ago
        They should be writing them in asciidoc (or even markdown) and using style sheets if they really need complex formatting!!! (although at least latex is decent at typesetting and has nice defaults.)
        • Nitramp 7y ago
          Yes. I intended that more as an abstract example for a tool that's useful to do science, but clearly not a science in of itself[1]. Though latex might still come in handy once you actually want to submit papers to journals, or for a thesis. YMMV. [1] then again, if I remember my feeble attempts to write latex macros, maybe the emergent behaviour of common latex packages would be a good research subject? ;-)
  • slumdev 7y ago
    You use Vim in your example. Get your students out of it and into something like IntelliJ IDEA or VS Code or (at a bare minimum) Eclipse.
    • 0x445442 7y ago
      I think it's valuable to start with Vim, especially for non JVM or CLR languages. Learning Vim as a first step will allow the students to easily navigate and edit code on remote servers. Then, when working on a code base like Java or C#, they can install the Vim plugin for their IDE and have the advantage of a superior editing tool to go along with the tooling the IDE provides.
    • AstralStorm 7y ago
      Or preferably all of the above and Vim, and also CodeBlocks and KEIL just in case. Really? There's a point where you get to learn your IDE...
    • swiley 7y ago
      Why? What’s wrong with vim, gdb, and some static analysis tools like cscope and a linter? IDEs confuse people, a lot of them start to think you can’t have the compiler/debugger/build automations without the editor and start doing stupid things because of that.
    • missjellyfish 7y ago
      Unpopular Opinion: IDEs suck when teaching people programming. A simple Text editor, the simpler the better, is all we need, combined with a compiler. Modern IDEs introduce a boatload of completely irrelevant concepts and complexity that just adds to the confusion. Doesn't matter which one you use. If I was to design a CS101 course, I'd do away with Java (which is the language of choice at my university) as well. I don't know what would be the replacement; vala looks nice but the resources are lacking. My main points in choosing a language to teach would be that I can do OO in it while not needing everything to be encapsulated in classes. Also, the language shouldn't care about whitespace, because if I'm teaching a few hundred students, I'm not going to debug a boatload of mixed tabs and spaces issues. Also, my CS101 course would be about debugging as much as about programming. Including stuff like "here is some source code, that's the observed bug, submit a corrected version by midnight x-y-zzzz and describe how you debugged it in bullet points". Unfortunately, plagiarism on these types of assignments makes them very much useless in the real world where grades depend on that.
  • tikiman163 7y ago
    I read through the article, and a lot of what you've got looks really useful. Your explanation of GIT and source control is especially valuable. These are all pretty much skills a good programmer should have, but I would make one exception. Personally, I like and have frequently used VIM. It's a useful tool to know how to use if you need to edit text files on a GUI-less system. However, I have yet to meet a single programmer with any ability to work as a team member that chooses to use VIM while using an OS with a desktop environment. VIM does have an interesting and valuable ideology, but that ideology isn't perfect and I worry that exposing new programmers to only one command line text editor and itss specific ideology might provide too narrow of a perspective. It might be a good idea to alsi present the ideologies behind other command line text editing approaches such as perl scripting and regex in order to update many files in order to widen their perspective and consider what they need to do while selecting the tool to use.
    • lwb 7y ago
      Lots of people use Vim in a desktop environment. At Facebook I would guess that something like 20% of software engineers use it on a daily basis. It’s still an incredibly powerful editor with lots of practical application and it’s constantly being updated. If you have the right plugins it can be an order of magnitude more productive than an IDE.
  • dirtydroog 7y ago
    We shouldn't really be encouraging people to program in vim. I mean, an 80 char line length limit is very 1995. People have massive monitors now.
    • godshatter 7y ago
      Your entire file can be one line in vim, regardless of it's size.
  • godshatter 7y ago
    I would go one step even more basic and teach touch typing. It amazes me when I watch someone code by laboriously copying some other code from somewhere else, from a full code snippet to a single variable name, paste it in and begrudgingly type what needs to be typed, slowly. The thought that always goes through my mind when I see this is "this is your interface to code, people, shouldn't you spend a little bit of time at least trying to master it?" Forget vim, if people just learned to type they could be twice as productive in simple notepad. Vim (which I use) raises this to another level still.
• trillic 7y ago
  Here's a link to a similar course offered by UMich EECS. I really enjoyed it when I took it as an undergrad. https://github.com/c4cs/c4cs.github.io https://github.com/c4cs/c4cs.github.io
• lkbm 7y ago
  In the lab for my second or third CS course, the professor was walking us through intro Unix usage, but he didn't take attendance so it ended up being just 2-4 of us showing up. After a few weeks, he cancelled the lectures and told us he'd just be around to answer questions, help with homework, etc. The last lecture before he cancelled things was an intro to Vim. The next would've been Emacs. And that's the story of how I became a life-long Vim user. :-)
  • emilecantin 7y ago
    (Life-long vimmer here) At the bootcamp I teach at, one of our students almost became a life-long VIM user today, too: he had accidentally opened it and didn't know how to exit ;-) . Unfortunately, my co-worker helped him before I could introduce him to our dark ways.
  • hinkley 7y ago
    When I started at school we all got unix shell accounts mostly for email. Later years got bumped out into multiple machines but for that one year almost all of us were on the same 8 core box (and seriously clamped down quotas) Within a few weeks, a friend of a friend of a friend had figured out how to pull pranks, and that opened the floodgates. Soon we all knew about man pages, about commands to query utmp and wtmp (to deduce who just did what to you or a friend), grep, file permissions, tty write permissions, quotas, nntp. The most fun was when someone did something to you without figuring out how to stop it from being done right back to them. Many a kernel was cat'ed to someone else's terminal. Even today when I'm trying to troubleshoot, half of the stuff I'm using was first used trying to seek revenge on a prankster. Once in a while I wonder if this would be a good way to teach a class on Unix.
  • Aperocky 7y ago
    Life long vim user that was initiated by the terminal here, vim has a special place in my heart, not because the amount of customization that I was able to add, but because it enabled me to write actual diary. Here's the script. https://github.com/Aperocky/termlife/blob/master/diaryman.sh https://github.com/Aperocky/termlife/blob/master/diaryman.sh All I had to do was to type $diary in the terminal and I'm writing my diary in vim. I had never had more extensive record of my life. My distracted ass would never have managed this without that kind of access.
• wes1350 7y ago
  This course is wonderful! I've read through all the material and watched all the lectures and I can say it has helped me tremendously thus far. I'm still trying to master all the tools they've mentioned but I already feel much more proficient with e.g. version control, vim, using the command line, etc. If you're an experienced dev then you might already know all of these things, but if you feel that you have some gaps in your knowledge with some of these tools, this course will likely point you in the right direction.
  • floatrock 7y ago
    If you're an experienced dev, you use all these every single day. God save me if I'm asked to implement quicksort though... theory is nice, but for me, academia largely forgot about this practical stuff.
    • pfranz 7y ago
      I missed out on a formal CS education. I found my way, but I always saw it as all of those things you never had time to research deeply. Otherwise, it's just a trade school. For example, you've implemented a few basic sorting algorithms so you feel confident in choosing one or kicking the tires on a new one you've never heard of. Knowing how an OS is put together gives you an idea where things should go.
• dahfizz 7y ago
  I really wish this practical stuff was more emphasized. I graduated with a lot of very smart people who could write great code - but they could not compile, run, test, or check it into VCS to save their lives. It made group projects hell.
  • sf_rob 7y ago
    I graduated high in my CS class from a top school, but it turns out that I'm just good at tests/abstract thinking/hacking things together with duct tape. I'm terrible at software engineering, and really glad to see this kind of stuff being emphasized at the university level.
    • gen220 7y ago
      Depends on your point of view, but it sounds like you’re great at software engineering. :) Abstract thinking and duct tape are the tools of the trade! The tools they’re teaching in this course are just fantastic abstractions held together with duct tape, after all.
• sumoboy 7y ago
  It's sad to see freshman CS students getting thrown into this unknown world of programming with zero understanding of basic programming principle such at simple logic, tools, and even a book. I just witnessed this last semester where the students first class was basically 'intro was a C++'. No books or resources supplied or referenced. So it even gets better when the instructor implies don't get help from the internet or examples for assignments, in his eyes everything on the internet is bad or wrong. I gathered he basically wanted the students to fail, what a super hero. Glad to see the effort here to help CS students, great job.
  • leetcrew 7y ago
    it's even worse at the school I graduated from. the intro level course for cs majors is in python, but calculus I is a prereq. so the students who are catching up in math and/or don't quite feel ready for the real intro course have to take the remedial course, which is in c. I was a TA/grader for that course and what a shitshow it was. I don't think the professor ever explained the concept of undefined behavior. the highlight for me as a grader was the assignment where they first had to define functions outside of main. many of the students didn't understand that you need to actually return values from (non-void) functions. but in a lot of cases, the value they were supposed to return happened to be sitting in $rax, so they would end up producing the correct output. I was never sure what to do in those cases; they lacked the conceptual tools to even understand what they had done wrong.
    • sumoboy 7y ago
      Definitely more value in taking a udemy type instruction prior just to get introduced to the concepts at your own pace. Nothing has really changed after decades, incredible.
    • vonmoltke 7y ago
      > the intro level course for cs majors is in python, but calculus I is a prereq. so the students who are catching up in math and/or don't quite feel ready for the real intro course have to take the remedial course, which is in c. I don't understand, why would students who need to take Calc 1 not just take the normal course the following semester?
• daniel_rh 7y ago
  2 words: bash reduce (eg using cut, sort, split -l, nohup, ssh to orchestrate a massive job with only bare unix tools available)
• saboot 7y ago
  This is not only useful for CS people, but to us hard science members. Coding is a mandatory prereq.. which is usually one class on C or C++. Then we're expected to collaborate on a project with hundreds of developers. This is a great resource for those of us who are a bit lost, thank you.
• jedberg 7y ago
  It's funny, when I was in school, I was always told the difference between a good CS school and an ok school was that the good school only taught you theory and left the practical application to the reader. The ok school had courses on tools and language syntax. It's kind of awesome to see this coming out of MIT.
  • sombremesa 7y ago
    The world's best CS school is an internet connection.
    • xkemp 7y ago
      I'm entirely self-taught and can entirely understand wanting that belief to be true, but it just isn't. A university can give you so much more than just learning some programming language. At the very least, it's going to force you to dabble in some languages you wouldn't ordinarily touch. The same obviously goes for theory. Assuming there are at least some things that require a minimum effort that is uncomfortable before allowing you to see their benefits, you will discover more guided by qualified people and well-designed curricula than on your own. Then, there are the people: from my experience especially with Ivy-League faculty, these schools seem to do something right. Remember that one teacher from school that really got you into (reading shakespeare/track/organic chemistry)? Yeah, they aren't all like that, but a rather significant number seems to be.
      • deleted 7y ago
        [deleted]
      • theLotusGambit 7y ago
        > Assuming there are at least some things that require a minimum effort that is uncomfortable before allowing you to see their benefits, you will discover more guided by qualified people and well-designed curricula than on your own. Perhaps, but sitting in the lecture hall isn't the only way you can get thorough instruction from professionals. Books exist, and they don't suffer from the same monetary, timing, and pacing issues that classrooms do. The primary historical disadvantage of books- that they weren't interactive and you therefore couldn't get help if stuck- is no longer an issue with the internet. It's possible that the internet is too disorganized and low-quality to be one's primary teacher, but its amazing supplementary value makes other media tenable. Those are my anecdotal opinions, anyway. But I'm curious, what do you think physical teachers have to offer that Books/Online Courses/Podcasts/Whatever + The Internet don't?
• arman_ashrafian 7y ago
  At my school there is a 2 unit class that you must take along with the intro DS&A course that teaches bash, vim, git, testing, etc. It was definitely the class that helped me the most in my internship and also made me a Vim user. http://ieng6.ucsd.edu/~cs15x/ http://ieng6.ucsd.edu/~cs15x/
  • 0az 7y ago
    I too use (Mac)Vim. In my experience, most CS majors at UCSD that I've met complain about the course. On the other hand, DSC doesn't have an equivalent, which I find disappointing but understandable. Maybe it'll get one in the future.
  • y2bd 7y ago
    Oof, the main memory I associate with this class was not realizing there was a midterm and therefore not showing up for the midterm. Still passed though, and with an A somehow. Thank you, guardian angel TA!
• jsd1982 7y ago
  I think the reason you don't see this kind of course offered is because it is primarily concerning training and not education. Imagine if your training course 25 years ago focused on the Turbo C IDE and that's all the University offered. You would be amazingly proficient at Turbo C and know all its keyboard shortcuts but that wouldn't be too relevant in today's market. Keeping such training material up to date with the latest trends is exhausting work and not worth maintaining, especially given how difficult it is to predict what may be the next tool de jure. Contrast this with more timeless educational topics and it starts to be clearer why this sort of thing is explicitly not taught.
  • mandelbrotwurst 7y ago
    Sure, or it could have focused on bash, terminal, Unix, vim, etc and still be relevant today.
    • jsd1982 7y ago
      Sure, but 25 years ago that'd still be placing a bet that those tools would be relevant today. That was my point.
  • tcbasche 7y ago
    Presumably though there's change in a lot of different fields (not just CS), and it would just be up to whoever is maintaining a course to keep the tools up to date with what's used in industry. But also, how long has it been since vim/emacs were first used? Or a vcs? I think a lot of this stuff would remain pretty well the same year on year.
  • phlakaton 7y ago
    As someone whose intro to programming class WAS built on Turbo C almost thirty years ago, let me tell you how it was: One day's worth of handouts told you about the IDE. Another handout was tips for debugging, including common compiler errors and what they meant. That was it! The rest you learned in the computer cluster, with the help of your dormmate, TA, or computer cluster tutor. The course itself, from then on out, focused (quite rightly IMO) on programming concepts, structures, abstractions, and basic algorithms. The main computer clusters on campus also had a whole panoply of brochures on how to use Unix, as well as various editors/tools. They were for use by all students, not just the CS students. In short: it should not take a massive investment of class prep and time to teach students the practicalia they will need to know. Save it for the labs. Don't make a semester course out of it. Include the whole student body as your audience by publishing self-help materials for all.
• cosmotic 7y ago
  Learning about a command-line debugger and command-line profiling tools would be helpful for those that find themselves in the past. IDEA and Visual Studio have had these things integrated for decades. I find the likelihood of knowing how to use a debugger or profiler is inversely proportional to the amount of time someone spends in the terminal. It's astonishing how many developers rely on logging/print statements for debugging. The learning curve of using a tool like PDB or GDB is just too steep for most people.
  • bachmeier 7y ago
    > It's astonishing how many developers rely on logging/print statements for debugging. One reason is that you don't switch contexts if you insert a print statement in your code. I personally find that to be the least distracting way to debug.
    • porknubbins 7y ago
      I’ve tried using GDB and respect those who can, but when I am debugging my short term memory is generally full trying to understand the program code and trying to remember GDB commands clobbers that.
    • jakear 7y ago
      In something like VSCode (/any other IDE) you can just hit a keybinding or click the little button just to the left of the line to add a breakpoint; all the runtime info is shown in the sidebar and the debug console is shown where your terminal normally is; and the process to run is often the same as the process to debug. So context switching isn't as big of a deal. But still, print statements definitely have their place. (Disclaimer: I work on VSCode)
  • pvg 7y ago
    The browser dev tools of various browsers are debuggers and are very widely used - I'd guess completely independently of amount of time spent in a terminal. Other factors, post-C, are probably things lots of languages don't have good debuggers or good debuggers take a while to materialize, debuggers are less necessary in managed-runtime languages, etc.
• Aperocky 7y ago
  Non CS graduate here, funny how my learning curve has been basically what y'all are saying. I had one java class before I officially kick started my programming career by wiping windows off my laptop and installing ubuntu. Then proceeded to force myself to do everything from the command line, not that there were many other options. It escalated quickly from there. Starting from the terminal is much more intuitive than writing 'int main/ public static void main' in an IDE.
  • woodrowbarlow 7y ago
    > Starting from the terminal is much more intuitive than writing 'int main/ public static void main' in an IDE. i would take this a step further: starting from _any_ REPL is an advantage in learning programming. the tight feedback loop fosters experimentation. python is another good starting point in this regard.
• xrd 7y ago
  My book about the GitHub API from O'Reilly had a similar idea: thinking in and about tools is an important concept. O'Reilly permitted me to release it under creative commons so you can find it here for free: https://buildingtoolswithgithub.teddyhyde.io/ https://buildingtoolswithgithub.teddyhyde.io/
• fao_ 7y ago
  To be honest, I was kind of disappointed with this, because most of it I already knew! (That's not a criticism of your course c:) In the vim section, you might want to cover `*` - go to next match of current word and `#` - go to previous match of current word
• gen220 7y ago
  I graduated a top 50 school, that gave us an “engineering” degree but had no such similar course. There were no more than 20 students, out of 300ish, who understood the material of this course well enough to teach it. From my perspective, this knowledge was generally inversely correlated to GPA and strongly correlated to postgrad performance. Take my anecdata for what it is, but I think these skills are strongly underrated by universities and students alike. Kudos to MIT for publishing this online; I know I would have benefitted from exposure to these topics in my first couple of years.
  • starpilot 7y ago
    I have those skills, no one in my data science team does. The people with better communication skills, who can gain buy-in from colleagues and raise disagreements without making anyone angry, are doing far better than me despite their lower level of technical competence.
    • zhdc1 7y ago
      This doesn't mean they aren't important though. In academia (not CS), but we use a lot of what's covered in the op MIT guide. I don't know if this gives an edge at all, and it's certainly 100x less important than soft skills, but there has to be some advantage to knowing how to pull a git repository or how to extract text matches from the command line without having to download or use an external application.
  • foobarian 7y ago
    I think what's happening is that motivated individuals learn these things by doing, sometimes starting at an early age. Teaching these topics explicitly will probably not automatically turn students into 10x hackers; however it might help some. I know I cry a little on the inside any time I have to explain grep to an engineer that has been around for more than a year.
  • jldugger 7y ago
    > these skills are strongly underrated by universities and students alike. Universities believe their focus should be on timeless principles, and expect that students will supplement their instruction as needed. For example, teaching students the Bourne Again shell isn't useful on Windows, and declining in importance in macOS. Same logic applies to editors, but even more wildly varied. Rather than build 20 courses, one for every IDE, and then revisit the pedagogy every year as software changes, they basically lean heavily on 'you're smart enough to figure this out on your own.' Some of this is obviously motivated post-hoc reasoning but still makes a modicum of sense -- anyone with 5 years exp could probably teach undergrads bash and git (with maybe 40 hours of prep), so university instructors with PhDs should be focusing on knowledge gained from research findings that wouldn't find their way into industry via other means.
• pgcj_poster 7y ago
  All of this seems like stuff I would expect someone studying CS to pick up on their own. I learned to use git in college, but not because anyone taught me: I just figured it out because I had group projects and needed version control. On the other hand, there's no way I could have possibly learned how something like ray-tracing worked without learning it in school or doing some really intense self-study. I feel like it's a waste of class-time to teach stuff like git, shell scripting, etc. If you're smart enough to understand graphics or compilers, you should be able to learn those tools on your own without any trouble.
• jacques_chester 7y ago
  In other engineering disciplines this used to be called "shop class" or similar. In his day my dad was taught as much about carpentry, metal work, plumbing etc as he was taught about radios and circuits. As an educational technique, "sink or swim" is about as efficient as spinning a wheel and handing out degrees.
• xzel 7y ago
  I took a Unix half credit course randomly where you basically did bash scripting, a huge bunch of command line tools and then eventually use all that to build your own linux distribution. I swear I learned more in the half credit class, and way more if you try to count it as useful information, than 90% of my other CS courses. Edit: And since this got some traction, here is the current version of the class: https://www.cis.upenn.edu/~cis191/ https://www.cis.upenn.edu/~cis191/ it looks pretty similar to what I took but they added a little bit of Python.
  • kbenson 7y ago
    Going through Linux From Scratch[1] manually and reading each component, while allowing yourself the time to look into interesting bits of each, is essentially this. I did it back in the early 2000's, and view it as one of the most useful educations I've ever gotten on how a Unix-like system functions (even if a lot of the knowledge is somewhat obsoleted now for many Linux distros with the introduction of systemd). I was doing it as research for how to ship a custom distro for a small purpose-built device, and while that never panned out, I've never once regretted spending the time to go through the process. 1: http://www.linuxfromscratch.org/ http://www.linuxfromscratch.org/
    • HPsquared 7y ago
      This - it methodically takes you through all the little details inside the system that are usually taken for granted and hugely improved my confidence working with Linux. It also taught me a lot of what's in this class (e.g. editors, shell scripting, even a fair bit of troubleshooting)
    • kevstev 7y ago
      I never successfully made it through LFS, maybe this is the year :)
  • aquaticsunset 7y ago
    We had a very similar course at Penn State, as well. It's among three courses that I learned the absolute most from, and have had a huge amount of applicability to my life and career. https://bulletins.psu.edu/search/?P=CMPSC%20311 https://bulletins.psu.edu/search/?P=CMPSC%20311
• daxfohl 7y ago
  I wonder how different things would be if cs departments had a special lab without mice.
• joerickard 7y ago
  I just graduated from University of Colorado Boulder this last semester with a CS degree, and am glad to say that this was a required course. It was a 3000 level course called Software Development that also incorporated a long form group project for team cooperation skills. It definitely helped me to improve my efficiency and organization when working on projects. Teaching thoughtfulness in designing not only a solution, but a work environment, is an important lesson.
• mhh__ 7y ago
  Probably at less depth but I ended up learning quite a lot of these topics at GCSE (16ish), with the exception of proper version control although I taught myself git and C++ instead of actually working. Probably quite lucky in retrospect
• lala26in 7y ago
  The missing topic in missing semester: how to design and build frameworks
• tombert 7y ago
  I can't speak for any other schools, but before I dropped out of Florida State, they had a class called "Intro to Unix", which was only worth one credit. We all were given login credentials to a server and our assignments were typically Bash scripts; there was one class spent on Vi, and the professor combined the Nano and Emacs class together. We also learned how to do Makefiles and how to run GCC... I had assumed that this was standard in most CS majors...was I wrong?
  • vaughnegut 7y ago
    Very wrong, unfortunately. At my school there are students halfway through their degree who can't switch a git branch without using a drop-down menu in their IDE (and even then with difficulty) or have ever used the CLI for anything. The place students tend to learn these things is their internship. The first one is typically a turning point in their programming and tools ability
  • BlueTemplar 7y ago
    Me too... except it's a somewhat simpler, but required course for ALL students, not just those in CS ! (A bit understaffed - or maybe not - inter-student cooperation worked well enough!)
• terminaljunkid 7y ago
  Thank you a lot for posting this link. I am majoring in CSE in India and I think you guys have it still better. India's engineering education (maybe except IITs) is completely screwed up by people who don't know what they are doing. The average student here doesn't come out of interest but for sake of getting some job. There are lot of people who don't understand difference between text editor and word processor till end of the 4 year program, but still get an 'S' grade (>90% score) because of rote learning system. Leave alone mastering the tools, they expect to open a PDF/docx in their phones and copy it to the computer. Having said that, the college I study is one of "top" colleges of the state. They foolishly waste 1 year in our life by teaching "common" subjects like chemistry, physics, elements of {electronics,mechanical,civil} engineering etc.. I mean, they may be somewhat marginally useful, but they waste time and money for that while there's lot of stuff to learn in CS itself; just because some baldhead decided it would be good to teach all subjects to engineering students in first year. I really wish I could study in US.
• sn41 7y ago
  When someone comes to me these days for knowledge about basic Unix/MacOS/Linux CLI tools, I direct them to the GNU core utilities documentation - it is very nicely organised according to task. I also demonstrate how CLI can do read-based operations as fast as SQL on medium size databases (just take an SQL dump and pipe) - https://www.gnu.org/software/coreutils/manual/html_node/index.html https://www.gnu.org/software/coreutils/manual/html_node/inde... For various sorting and filtering followed by report generation in latex etc., a knowledge of awk also helps. I use the mawk interpreter since I have found it to be slightly faster with ASCII format files.
• whateveracct 7y ago
  Purdue CompE has a required 1 credit hour lab that covered Unix command line, bash, git, and a little Python. It's been the most useful credit hour I've ever earned.
• yodsanklai 7y ago
  I still remember my first week of engineering school (1997). Before the actual classes started, we had an intensive UNIX week. I loved it. It seemed like the real deal to me. I was already using linux at the time, but for the first time I was properly taught things by experts, and not computer magazines. What was my hobby was suddenly becoming something serious and respected. So much has changed since then but I'm glad that to this day I'm still using the same commands and tools.
• ameixaseca 7y ago
  Metaprogramming has an actual meaning and it means something completely different from what it is used for on this website: "Metaprogramming is a programming technique in which computer programs have the ability to treat other programs as their data." [1] i.e.: it's a programming technique and not something related to any process related to building code. I understand the idea of giving some more practical side of using computers in a "missing semester", but please pay attention to the nomenclature. It can be really confusing for someone studying CS that does not yet grasp the concepts that well. [1] https://en.wikipedia.org/wiki/Metaprogramming https://en.wikipedia.org/wiki/Metaprogramming
  • Galanwe 7y ago
    “Meta” means “one level of abstraction above”. I find it perfectly okay to use it in this context.
    • MereInterest 7y ago
      The point isn't whether a word fits a definition, but whether that word already has a definition with which the new definition will be confused.
      • rudedogg 7y ago
        And the word is specific to programming! The usage in the course seems incorrect to me too. Everything else looks great though!
  • ptx 7y ago
    Students will presumably learn about actual metaprogramming in one of the non-missing semesters, so maybe it's meant as a pun?
• peter303 7y ago
  I have a MIT degree and learned these when I encountered them in my work. An important thing is to learn how to learn for the rest of your life.
• rawoke083600 7y ago
  I could add, one course or two about "communications" the one with people in. Most of us will spend our times in teams, with highly opinionated and sometimes conflicting individuals. Computer programmers don't know how to listen or to respond, we mostly just react.
• chatmasta 7y ago
  When I was in college, we also followed a "traditional" CS curriculum. The introductory language was Scheme. The language in core courses was C. Advanced courses used whatever was best for the course, usually C or C++. Many of the courses have had the same problem sets since 1985. At the time, students had problems with it because "how are we supposed to build apps with this knowledge?!" There were even student efforts to "modernize" the curriculum by supplementing it with student run workshops on app building (which actually did really well). Personally, I really appreciated the curriculum. I was a self taught programmer going into CS, having done lots of web dev and automation stuff with PHP / Python. And I was really cocky about it. But as my adviser told me on my first day, "yes, you're a programmer, but you are not yet a computer scientist." I knew nothing about Computer Science, and had never touched a low level language, because I had no practical reason to. The next four years were valuable for me because they forced me to learn about topics that I will never teach myself. And you know what? By the time I graduated I was fully proficient with git, python, Javascript, bash, and a whole bunch of other tools and concepts, despite the fact that no class forced me to learn them. I picked them up from working with others, scripting tests for my assignments, and my internships. It also helped to have the foundation of lower level knowledge. It's a lot easier to understand the "magic" of your scripting language when you have an appreciation of what it's actually doing underneath the hood. It's easier to understand bash when you've written a shell in C. Etc. For me, this approach worked well. School taught me the fundamental concepts that haven't changed since 1985, which means they probably won't change much by 2054, either. Who knows what industry will be using in 2054? I appreciate that the school curriculum prioritized core, fundamental concepts over tooling trends and the language du jour. Yes, it's important to learn those practical skills, but they'll come with practice and experience in industry (especially if you have 3 internships); there's no need to take a class on them. And when the next one comes along, you can learn it in a week. Your knowledge of the fundamentals will help.
  • s_trumpet 7y ago
    Honestly, this course would have been a game-changer for those of us who went to terrible colleges with minimal opportunities for internships. The disconnect between theoretical classes and practical ones was simply too vast to grasp for the majority. You sound like one of the top tier of students, being a programmer before entering college (which I assume was a good one). There are colleges out there where the faculty have only a theoretical relation to any actual useful knowledge. E.g. my semester-long networking class actually had less content than just watching a few YouTube videos. My operating systems class had a prof who was so completely clueless about so many things I can't list them. On the first day of class, he said "There are 3 OS (sic) - Windows, Mac and Unix" and refused to believe a student who told him that OSX is a unix. My CS education is entirely self-taught as a result.
• beefhash 7y ago
  https://missing.csail.mit.edu/2020/security/ https://missing.csail.mit.edu/2020/security/ > An example of a hash function is SHA1, which is used in Git. It maps arbitrary-sized inputs to 160-bit outputs (which can be represented as 40 hexadecimal characters). We can try out the SHA1 hash on an input using the sha1sum command: Can we please stop presenting SHA1 as a valid choice for a hash function anytime now? Especially in a security context? This passage is probably just a holdover from the 2008 version of this page, but it's still frustrating to see.
• Nikaoto 7y ago
  There are two sides to this kind of teaching. If you're MIT, you can afford to hire great lecturers who know to teach the students fundamental and deep truths about the tools they're using and not trivia. That way, they can generalize onto other tools, so anyone who studied git can quickly adapt to using cvs or svn. My university (in a developing country) is on the other side. Last semester was a disaster. We had an AWS course, half of which was memorizing information about pricing and S3 tiers. If I were going into a job as an AWS guy, I'd definitely have to know that, but this is just third year of undergrad in CS :-/ and not a training course. The quizzes also had deliberately deceiving questions, which is the worst type of trivia! Even better example. The Windows Server course was also compulsory (just like the AWS course) and mainly consisted of memorizing trivial information about context menus, which buttons to click and the licensing terms/durations/prices for different Windows Server versions. I'm jaded from the experience. Got my first two Cs in both since I spent time learning stuff described in the post instead of that nonsense.
  • kabes 7y ago
    I find it very weird to see something like an AWS course in a university-level CS curriculum.
    • slumdev 7y ago
      AWS and Windows Server courses are definitely not university-level CS courses.
      • Nikaoto 7y ago
        Yep. And the sad part is that some of the students I met here don't realize what they're learning is not CS. I only applied to avoid the compulsory military service, I was already learning a bunch on my job. On the bright side, the local job market demands match what they teach here very well. According to my anecdata, lots of students who had no knowledge or experience working as programmers now have full-time jobs mostly as web developers. Looks like the university's doing its job and I'm just a whiny C student.
  • 7y ago
• tester89 7y ago
  We have a class like this at my uni and it’s the most hated class for the CS course.
• deadgrey19 7y ago
  This is a standard second year CS course at UNSW: https://cgi.cse.unsw.edu.au/~cs2041/19T2/index.html https://cgi.cse.unsw.edu.au/~cs2041/19T2/index.html Topcis included: Shell Perl Git Javascript Webservers Make Performance tuning
• mannykoum 7y ago
  We had a similar course at Columbia (half semester, 1 credit). The professor was good and the information pretty useful; very similar material to this one. The paradox was that for the ones who knew the significance of such a course, well, we had already learned most of these things the hard way. Maybe our other CS profs should have advertised the course as an optional requirement to get people interested early instead of their junior/senior year.
• tgbugs 7y ago
  In my graduate program (Neurosciences) the students with a computational background usually realize after about two years that all of our colleagues desperately need a basic orientation for how to actually use a computer to do real work. The only institutions that I know of that teach the kinds of courses we need are community colleges. The curriculum presented here is an enormous community resource and I hope the other institutions recognize the desperate need for a course like this and allocate the resources to teach it.
• cnees 7y ago
  University of Michigan had this as an elective three or four years back, and it's served me well to understand things like piping, output redirection, and reflog. I'm glad MIT's making this public. It seems like it could fill a big gap for people who don't have the mentorship to know what they don't know.
• nandkeypull 7y ago
  CMU has a similar course called "Great Practical Ideas for Computer Scientists" (a play off of the infamous "Great Theoretical Ideas in Computer Science") at https://www.cs.cmu.edu/~15131/f17/ https://www.cs.cmu.edu/~15131/f17/.
• haileris 7y ago
  Good as a primer for those that aren't naturally hackers but decided to become computer science majors and have little to no experience with a unix-like operating system. I learned Linux, the shell, basic scripting, and the terminal environment in high school out of necessity and then began to thoroughly enjoy it. Planning to enter university as a CS student I took the time to learn Vim, though I didn't start using it regularly until much later. I can't exactly articulate why, but I'm fairly upset these sorts of things comprise an entire course. What happened to RTFM? Where is the general curiosity? Even if you have no prior experience with a majority of these things, these are the kinds of things you figure out over the weekend while doing your regular courseload.
  • HPsquared 7y ago
    It's kind of like a special class to teach engineering students about all the features on their graphing calculator.
  • gowld 7y ago
    Why is Compilers an entire course? Databases? Operation Systems? All of these topics are covered in books you can read.
• robomartin 7y ago
  > Vim avoids the use of the mouse, because it’s too slow; Vim even avoids using the arrow keys because it requires too much movement. I'm sorry, it isn't my intent to start an editor war. Use whatever you want, I don't care. Just don't lie about it. I expect far more from MIT than this nonsense. VI and VIM are what they are because keyboards of the era --and the entire UI-- looked like this: https://retrocomputingforum.com/uploads/default/original/1X/d4ee796ce7397d62b975d7ab03a8e0975146b330.jpeg https://retrocomputingforum.com/uploads/default/original/1X/... Notice the location of the Ctrl key. It used to be where the Caps-Lock key is today, making it FAR more convenient and comfortable for entering Ctrl sequences. This is from a Tektronix terminal, which I used in the early 80's. Here it is: https://www.computerhistory.org/revolution/input-output/14/349/1826?position=0 https://www.computerhistory.org/revolution/input-output/14/3... The VT-100, if I remember correctly, introduced four cursor keys: https://www.computerhistory.org/revolution/input-output/14/349/1849?position=0 https://www.computerhistory.org/revolution/input-output/14/3... I also used VT-100's and clones during the '80's. https://www.computerhistory.org/revolution/input-output/14/349/1697?position=0 https://www.computerhistory.org/revolution/input-output/14/3... Notice the total absence of anything even resembling much more than a simple typewriter. No mouse, function keys and other modern facilities. So, yeah, if you were writing a text editor at the time, you would be well served to do such things as implement modal view/insert operation for more reasons than just the archaic keyboards. These terminals were used to connect with remote systems at VERY LOW BAUD RATES. It's hard to imagine that BAUD 300 or 1200 was great speed at some point in history. In that context, cursor keys or grabbing a scroll bar with a mouse to yank it around with abandon made no sense. You were literally only able to receive from 30 to 120 characters per second...and a screen with 80 characters by 25 lines had 2,000! This is another reason for which escape control commands had to be invented. You had to be able to address you 80x25 canvas and place text where needed rather than to refresh the entire 2,000 character screen. This is why, quite frankly, I hate the "cult of vi". Cult members are, for the most part, people who have no historical connection to where this tool came from and why. We, at the time, would have KILLED for a graphical UI with a mouse. Yet that was impossible at the time due to both machine and connection speed limitations. You literally could not have used it even if you had it. So, yes, at the time, if you had to write a text/code editor (I wrote a few) you had no choice but to use a bunch of Ctrl-<something> codes and perhaps even implement a distinction between reading and inserting code. I still remember sequences like Wordstar's "Ctrl-k-x" running on an 8080 S-100 system with, yes, a VT-100 terminal attached. Yes, the VT-100 introduced four cursor keys, but if you were writing software at the time you could not make the assumption that the user had access to cursor keys, most keyboards did not have them until much later. That assumption was not safe when VI was created. Like I said above, use whatever you like, I truly don't care. Just don't lie to yourself about it, particularly when the truth is a matter of history. I think most people who came up through that era of computing laugh at the vi/vim cult because from our perspective --not yours-- it is complete nonsense. This text editor had NO CHOICE but to be as it is due to being written for crappy computing hardware and environments of the time. If you had to use one of those systems today you would be horrified. If you had to write a text editor back then you would write it exactly this way. And the minute a decent an ubiquitous GUI showed up you would drop it like a hot potato and try to forget the nightmares. MIT Computer Scientists ought to know history and not print nonsense like that. That entire paragraph about VI is basically wrong, historically wrong. You can leave it like that and perpetuate a fantasy or correct it and at least show some respect for history. And then do everyone a favor and explain that the speed of text entry is of no consequence whatsoever. MIT should not propagate that cultist belief. The time devoted to things having nothing to do with text entry is, in some cases, orders of magnitude greater than text entry. Not everyone is a PHP script kiddie. Some of us are writing real and complex software, some of it with life/death potential, and code entry is so ridiculously low in the scale of where time is spent and what things are important that it is absolutely laughable to talk to someone who has become religious about text editors because of stuff like this out of a respected university. Do you really think code entry speed and efficiency is important at all when working on the code for an MRI machine, a space capsule or an implantable insulin pump? Exactly! If coding is factory work, then, sure, mechanize as much as possible and count strokes. That would be the day I become a gardener.
• amai 7y ago
  Vim? Why not teach a real IDE like Eclipse or Intelij Community Edition? It has much better auto-completion, has a GUI for Git, debugging and profiling etc. Also I'm missing test driven development or at least unit tests in the curriculum. Reproducible results are important, even at university.
• alienlike 7y ago
  In my observation (at a major research institution), some grad-level CS students lack an even more fundamental skill: touch typing.
• adultSwim 7y ago
  I thought it was going to be communication or active listening.