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 great discussion about last year’s class here: 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).
We’d love to hear any insights or feedback you may have, so that we can run an even better class next year!
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.
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.
> That’s cool. Now, on to my possibly unpopular opinion: This isn’t what computer science is about.
This is not an unpopular opinion at all, CS degrees do not typically cover what's in this class which is precisely why they called it "the missing semester".
It's not computer science. It is computer literacy.
Most people who come out of a CS course will go on to become developers, not academics. The course topics are standard domain knowledge for anyone who builds software - not because of specific tools, but because of the concept that scripting and automation tools exist to make development easier.
There is no sense in which being aware of these topics will make you less effective as an academic computer scientist, if that's what you want to be.
Astronomers do stop to study how to build telescopes, chemists do stop to study how to create glassware, and biologists do stop to study culture media.
Why do you expect CS students to thrive without learning how to use a computer?
While theoretical computer science doesn't need to use computers for many problems, and the experts do not need to be extremely proficient, that does not mean that a general BSc program should not teach fundamental computer architecture and programming skills -- indeed, it would be irresponsible of them not to.
The other aspect is that CS can be experimental -- the experiments are computational ones. Large computing systems are analysed using the standard techniques of experimental science, and that needs good bench skills -- except the bench is being able to program, reason about programs, etc.
However, does a BSc program need to teach large scale software development, topics like version control and tools like git, CI, etc? No. They are more properly in a BE(Software) course or its equivalent.
Should universities teach Flash/Javascript/Python/C#/nginx/Active Directory as an end in itself? No. That is almost a technical trade qualification.
But you should be able to leave university, learn language X, program in it efficiently, and know how to learn about some system.
It isn't at the core of the CS curriculum, and neither are general requirements, but it is highly relevant to the course work and I am willing to bet it does not only help people interested in software engineering, but also people who want to be CS academics.
Making sure students are familiar with a full featured text editor, document preparation system, a version control system, the command line, etc. will go a long way. I don't think those are topics regularly covered in earlier education institutions.
I think that's reasonable. I really wish they offered more applicable classes at lower levels of education... I did like 2 days of programmable Legos in 5th(?) grade and then had to take a basic typing / MS Office course in 9th grade (required like you). In 11th grade I took CISCO Networking, Computer Manufacturing, and an intro programming course in C++.
After high school, I did a 4 year degree in Computer Science and while I learned a lot about algorithms, proofs, FSMs, design-patterns, etc. We got very little practical experience building software.
It'd be nice if they covered version control, more *nix and text editors, extending an existing codebase, refactoring, debugging, APIs, common libraries, multiple languages, and the web in general.
I think most CS students learn to become software engineers either on the job or on their own and there's room for school to help ease that transition.
The college I went to attempted to balance these - covering both abstract concepts and concrete tools and practical skills in roughly equal measure.
I think that's fair. Some people will go on to use both to work as a programmer, some may focus much more heavily on the theory end to focus on the science part of CS.
MS Office definitely doesn't seem to have a place. Maybe for a general "computer competency" course for college students, but not as part of a CS program.
"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.
Three great programmer virtues, according to Larry Wall:
1. Laziness (figure a smart way to do it that is less work)
2. Impatience (figure how to do it faster)
3. Hubris (figure that what you're doing is important)
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.
> 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
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.
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!
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.
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.
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.
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.
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.
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?)
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.
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.
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.
On macOS, we used this excellent open-source software called KeyCastr: https://github.com/keycastr/keycastr (we used this e.g. in the text editors lecture)
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.
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.
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.
I personally can't stand IDEs, and use them as sparingly as I can get away with. I don't want the build process abstracted away from me, I want to know exactly what it's doing. Whenever I'm trying to figure something out in an IDE to fix a problem with why something didn't build correctly, I want to throw up my hands and go back to a simple text editor and the make command or some bash scripts. I dislike programs that try to anticipate me, or that fix things after I've typed them. And the part of me that grew up learning to program with 4K of memory available cries when I see how many resources are being used by it.
There are a lot of things I like about them from an editing standpoint, though. Nice for refactoring, easy to find out what arguments a function takes, easy to jump around between files. Vim with multiple buffers isn't too far behind this, though, and it doesn't bring my system to it's knees just opening it up.
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/ it looks pretty similar to what I took but they added a little bit of Python.
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.
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)
I did a similar Unix course. It was on quarter based system so it only lasted 3 months. We learned Unix from first principles. There were programming assignments that started off as shell scripts. We wrote manpages for our shell scripts. Then we learned C with the expectation you figure out the hard parts really really quickly (we were a Java school). We implemented various different C and Unix programs. We even reimplemented some of our shell scripts. We implemented a custom version of ls(1) with built-in sorting features.
In the last 3 weeks we built a full-blown Bourne shell in C including background jobs, shell/environment variables, pipelines, i/o redirection, lex/yacc parsing, etc. A lot of the features were extra credit (e.g. single pipeline a | b, versus infinite pipeline a | b | ...).
The class is unforgettable in my mind. I now mentally parse everything I do in the shell and imagine system call tracing every program I run.
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.
I took this class as well and agree that it was the most useful course I took at Penn. I still use all of the things that I learned in this class every day (especially emacs). Luckily, I took it early in school and it made subsequent classes so much easier. Thank you Perry Metzger!
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. :-)
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.
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.
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.
I’ve had something like this for about three years now, except it doesn’t open vim, I just use a single read command and it appends whatever I type with a time stamp. One file per quarter. And there’s a cron job to pop up a window each hour to remind me to type what I’m working on.
I’ve used this to figure out how much time I spent on certain tasks by sampling it Monte Carlo style. And sometimes when I run into some weird non-googleable problem, it happens again a few months later and the solution is in those files.
It’s like my own real-life syslog. Or like a scientist’s lab notebook.
(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.
My wife and I took a month long honeymoon. Really hoped it'd be as close as possible to one of those Tim Ferris-esque "mini retirements." The first morning I awoke early with some serious jet lag and couldn't really figure out what to do while she was still sleeping. So of course I rewrote my whole vim config from scratch and had a blast doing it.
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.
That's because each university caters to some business needs.
Top universities form students towards engineering careers because that's what the market requires and expects them to be.
Low rank universities train students to be button pushers in a world of increasingly automated systems. Because that's also what the market needs : people to keep the systems running and run applications updates.
The good thing ? Developing is one of the fairest trade : if you are good, you will manage to find good job and decent money without much struggle.
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.
> 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.
In general, I agree with you; I’m not suggesting that the whole degree be built around these tools, just that they should be taught, preferably early on, alongside the traditional intro to CS course.
But it’s not just about the tools, there are some seriously timeless concepts and skills under the surface: regexp, environment variables, users and user groups, documentation comprehension, piping, filesystems, streams, processes, to name a handful. These apply to any Operating System or programming environment, and give some concrete foundation to the theories you learn elsewhere.
Plus, some of these tools really do merit a “timeless” label at this point. VIM, git, bash (and bash-inspired shells), and most of GNU utilities have been around for a very long time and have not been conclusively supplanted by more powerful tools.
It takes no great skill to teach any undergraduate CS class. If you’re talking about skills that are still going to be useful in 50 years, Unix scripting is probably one of the strongest competitors. More critically, the basic model of piping commands through a set of simple programs is extremely powerful and widely applicable.
> Universities believe their focus should be on timeless principles, and expect that students will supplement their instruction as needed.
Why the arbitrary distinction?
Why have teachers at all? Surely the students can learn the timeless principles on their own as well.
What matters is where teachers can add value. Sure, you don't need a tenured prof walking students through
Intro to Vim and Bash and By The Way GDB Exists", but you do very well to have a TA run a practical lab to teach these things.
I don't think it's really coming from any sort of high priesthood dedicated to the noble, timeless principles. It's just boring human stuff.
Professors aren't typically trained educators, many of them at best tolerate their teaching duties. They muddled through, why doesn't everyone else?
In sports there's a truism that "good athletes make bad coaches". Brilliant former PhD students often make bad teachers. Whatever the timeless principles might be, they're useless without some craft.
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.
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.
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.
Interesting that you think it's inversely correlated with GPA. At my school, I feel like the people who are experts with the terminal and *nix stuff are the ones who have high GPAs because they are at the top of all the CS classes.
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.
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.
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.
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.
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.
Readit News
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). 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
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.
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.
This is not an unpopular opinion at all, CS degrees do not typically cover what's in this class which is precisely why they called it "the missing semester".
Most people who come out of a CS course will go on to become developers, not academics. The course topics are standard domain knowledge for anyone who builds software - not because of specific tools, but because of the concept that scripting and automation tools exist to make development easier.
There is no sense in which being aware of these topics will make you less effective as an academic computer scientist, if that's what you want to be.
Why do you expect CS students to thrive without learning how to use a computer?
The other aspect is that CS can be experimental -- the experiments are computational ones. Large computing systems are analysed using the standard techniques of experimental science, and that needs good bench skills -- except the bench is being able to program, reason about programs, etc.
However, does a BSc program need to teach large scale software development, topics like version control and tools like git, CI, etc? No. They are more properly in a BE(Software) course or its equivalent.
Should universities teach Flash/Javascript/Python/C#/nginx/Active Directory as an end in itself? No. That is almost a technical trade qualification.
But you should be able to leave university, learn language X, program in it efficiently, and know how to learn about some system.
(I'm sorry you had to learn about Office.)
I also remember taking a "Software Engineering" class and it bore little to no resemblance to any part of my 20+ year career.
Making sure students are familiar with a full featured text editor, document preparation system, a version control system, the command line, etc. will go a long way. I don't think those are topics regularly covered in earlier education institutions.
After high school, I did a 4 year degree in Computer Science and while I learned a lot about algorithms, proofs, FSMs, design-patterns, etc. We got very little practical experience building software.
It'd be nice if they covered version control, more *nix and text editors, extending an existing codebase, refactoring, debugging, APIs, common libraries, multiple languages, and the web in general.
I think most CS students learn to become software engineers either on the job or on their own and there's room for school to help ease that transition.
I think that's fair. Some people will go on to use both to work as a programmer, some may focus much more heavily on the theory end to focus on the science part of CS.
MS Office definitely doesn't seem to have a place. Maybe for a general "computer competency" course for college students, but not as part of a CS program.
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.
I seem to have a surplus both of "there has to be a better way"-itis, and some skill in finding such ways.
But you can quote Larry Wall on the three virtues of a programmer. http://threevirtues.com/
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.
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
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.
(Just kidding)
"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!
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.
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.
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
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.
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.
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.
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.
There are a lot of things I like about them from an editing standpoint, though. Nice for refactoring, easy to find out what arguments a function takes, easy to jump around between files. Vim with multiple buffers isn't too far behind this, though, and it doesn't bring my system to it's knees just opening it up.
I guess I'm getting old.
Really? There's a point where you get to learn your IDE...
Edit: And since this got some traction, here is the current version of the class: https://www.cis.upenn.edu/~cis191/ it looks pretty similar to what I took but they added a little bit of Python.
1: http://www.linuxfromscratch.org/
In the last 3 weeks we built a full-blown Bourne shell in C including background jobs, shell/environment variables, pipelines, i/o redirection, lex/yacc parsing, etc. A lot of the features were extra credit (e.g. single pipeline a | b, versus infinite pipeline a | b | ...).
The class is unforgettable in my mind. I now mentally parse everything I do in the shell and imagine system call tracing every program I run.
https://bulletins.psu.edu/search/?P=CMPSC%20311
[1] https://youtu.be/KYcY7CcS7nc
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. :-)
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.
Here's the script.
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.
I’ve used this to figure out how much time I spent on certain tasks by sampling it Monte Carlo style. And sometimes when I run into some weird non-googleable problem, it happens again a few months later and the solution is in those files.
It’s like my own real-life syslog. Or like a scientist’s lab notebook.
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.
Low rank universities train students to be button pushers in a world of increasingly automated systems. Because that's also what the market needs : people to keep the systems running and run applications updates.
The good thing ? Developing is one of the fairest trade : if you are good, you will manage to find good job and decent money without much struggle.
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.
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.
But it’s not just about the tools, there are some seriously timeless concepts and skills under the surface: regexp, environment variables, users and user groups, documentation comprehension, piping, filesystems, streams, processes, to name a handful. These apply to any Operating System or programming environment, and give some concrete foundation to the theories you learn elsewhere.
Plus, some of these tools really do merit a “timeless” label at this point. VIM, git, bash (and bash-inspired shells), and most of GNU utilities have been around for a very long time and have not been conclusively supplanted by more powerful tools.
Why the arbitrary distinction? Why have teachers at all? Surely the students can learn the timeless principles on their own as well.
What matters is where teachers can add value. Sure, you don't need a tenured prof walking students through Intro to Vim and Bash and By The Way GDB Exists", but you do very well to have a TA run a practical lab to teach these things.
Professors aren't typically trained educators, many of them at best tolerate their teaching duties. They muddled through, why doesn't everyone else?
In sports there's a truism that "good athletes make bad coaches". Brilliant former PhD students often make bad teachers. Whatever the timeless principles might be, they're useless without some craft.
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.
"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
God save me if I'm asked to implement quicksort though... theory is nice, but for me, academia largely forgot about this practical stuff.
http://ieng6.ucsd.edu/~cs15x/
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.
Still passed though, and with an A somehow. Thank you, guardian angel TA!