One of my favourite reads ever is Philip Guo’s Helping my students overcome command-line bullshittery. In the article he rails against the need for students to learn lower-level command-line tools in order to conduct the higher-level work necessary for HCI research:
“Throughout this entire ordeal where I’m uttering ridiculous epithets like ‘git pipe fork pipe stdout pipe stderr apt-get revert rollback pipe pipe grep pipe to less make install redirect rm rm ls ls -l ls tar -zxvf rm rm rm ssh mv ssh curl wget pip,'” – Philip Guo
That line in-particular made me laugh out loud the first time I read it… I can relate. But whether we like it or not though, these tools that operate at a low “to the metal” level have a power and flexibility that higher-level tools like in-browser editors do not, so they’re here to stay and we need to learn them (and teach them).
“With the right set of tools, one can be 10x or even 100x more productive than peers who don’t know how to set up those tools.” – Philip Guo
Over the last decade the learn to code movement, of which I’ve been an active member, has done a great job hiding the harsh realities of computing. We’ve created and promoted tools like Scratch and Hour of Code that remove problems like conforming to precise instruction syntax by substituting instructions for draggable blocks. We’ve moved introductory post-secondary programming courses from less forgiving languages like C and C++, to more forgiving languages like Python, using easier in-browser sandbox tools like Jupyter Notebook.
As a result, we’ve collectively become much better at teaching the basics of computational thinking and programming… variables, decisions (if-statements), repetition (loops), etc. This is by and large is a good thing… while they are by no means easy courses today, introductory computer programming courses were once considered notoriously difficult with bimodal grade distributions and high failure rates considered normal, and they were generally avoided by anyone but those intending to major or minor in CS/SE. But now they’re starting to even become the cool, interesting elective, and the timing couldn’t be better given how important computing is to society.
One big reason these introductory courses used to be considered so difficult is that students were being given so many things to learn at the same time… in addition to basic computational thinking and programming, students would need to learn a harsh and unforgiving syntax, using lower-level programming constructs (e.g. C++ strings and arrays vs. Python strings or lists), with a command-line operated compiler instead of sandbox browser tools, etc. With better tools, students are able to focus in on a desired difficulty rather than confronting multiple difficulties at once.
The flip side though is that we’ve hidden away the harsher realities of computing in the process. Though there are jobs where it’s not required, generally speaking the expectation is that computing professionals can use these low level tools and technologies. As a result, students who have experienced what we now call learning to code as part of outreach programs or “programming 101” courses now hit what must feel like a brick wall when they all of a sudden have to deal with the command-line bullshittery side of computing for the first time. And it’s not just the command-line bullshittery, it’s the higher end stuff as well…. data structures and algorithms, sets, functions, formal methods and all the stuff “above” basic programming too.
“There is simply no substitute for sitting down with them one-on-one on their laptop and walking them through all of the arcane commands to type, what they each mean, and how to interpret the bullshit output that’s barfed out to the drab terminal.” – Philip Guo
And this stuff is hard. For years computing was relegated to computer people that liked computers a lot and those who couldn’t get it were just not computer people. And yet, when we changed the way we taught it, we were able to teach a generation of students basic computational thinking and computer programming. So let’s collectively drop that attitude and line of thinking. Anyone can learn this stuff, it just takes time and effort, for the student and teacher, but we can and should also put time and effort into creating better teaching technologies, tools and techniques.
I think what happened here is that all of those involved in the learn to code movement came to the same correct conclusion that computational thinking and basic programing (variables, decisions, iteration) was the most central problem to solve and all of us solved the same problem as a result. The thing is that we’ve solved that problem now… we’re beating a dead horse at this point, do we really need another game that teaches block-programming?
While teaching a course with a curriculum that includes bash shell interactivity and scripting I came across Terminus in a similar course taught in prior years, it’s an in-browser game made by two MIT students that teaches command-line interactivity. I love this. We need so much more of this.
We need sandboxed learning tools like this that hone in on a desired difficulty and do it in a fun way, but for all the other topics within introductory computing.
What I think we need is the learn to code movement to take a divide and conquer approach to solve all these problems. Imagine things like an in-browser interactive simulation of using OpenSSH with visualization showing a connection to other computers, or a game for dynamic memory allocation in C that incorporates visualization of memory. Or on the other side… the concepts that are higher-level and more abstract than basic programming… imagine first-order logic proofs turned into a fun in-browser puzzle game with drag-and-drop chains of logical equivalences (perhaps with a penalty for learners just adhoc trying different possibilities, and rewards for correctly applying proof strategies and a game design that teaches them).
Anyways. Talk is really cheap. 🙂 But after thinking about this a lot this week, I suspect I’ve got a slew of student project ideas now…