The negative motivational potential of programming textbooks and tutorials is second only to the motivational potential of how we teach math. And while visual “learning by doing” systems like Khan Academy’s Computer Programming online course seem like progress, they’re sugarcoating the problem instead of providing a solution.
Bret Victor, two years ago, in his eye-opening essay “Learnable Programming”:
We often think of a programming environment or language in terms of its features—this one “has code folding”, that one “has type inference”. This is like thinking about a book in terms of its words—this book has a “fortuitous”, that one has a “munificent”. What matters is not individual words, but how the words together convey a message.
Everything else—a must-read—follows from there toward building a mental model. The concept of building a mental model is based on an interesting premise: “A programming system has two parts. The programming ‘environment’ is the part that’s installed on the computer. The programming “language” is the part that’s installed in the programmer’s head.” The inspiration to build on this premise, as Victor remarks, came from Will Wright’s thoughts on interactive design in “Sims, BattleBots, Cellular Automata God and Go: A Conversation with Will Wright” by Celia Pearce:
So what we’re trying to as designers is build up these mental models in the player. The computer is just an incremental step, an intermediate model to the model in the player’s head. The player has to be able to bootstrap themselves into understanding that model. You’ve got this elaborate system with thousands of variables, and you can’t just dump it on the user or else they’re totally lost. So we usually try to think in terms of, what’s a simpler metaphor that somebody can approach this with? What’s the simplest mental model that you can walk up to one of these games and start playing it, and at least understand the basics? Now it might be the wrong model, but it still has to bootstrap into your learning process. So for most of our games, there’s some overt metaphor that allows you approach the simulation. (Game Studies: The International Journal of Computer Game Research Vol.2 Issue 1, July 2002)
That, of course, holds important implications for game-based learning design—not just for teaching programming, but that’s a particularly obvious example. In game-based learning design, bootstrapping must take place both at the system level and the content level: the GBL model must be designed in such a way that you “can walk up to it and start playing,” and the same thing applies to how the learning content is designed so that the player ”can walk up to it and start learning.” (A fine example of Hayden White’s The Content of the Form principle at work, incidentally.)
As of now, there is no shortage of games that try to teach programming to kids, but just browsing the blurbs opens jar after jar crawling with inadequacies, to put it mildly. Games aimed at teens tend to float belly up the next time you check (yes I’m looking at you, CodeHero), or remain perpetually promising but unfinished like Dre’s Detox. And you won’t find anything remotely suitable for adults or seniors.
Obviously, if we managed to create games that teach how to code along the lines imagined by Bret Victor, we’d create new generations of coders who could put to good use not only the principles they’ve learned, but the principles with which they’ve learned what they’ve learned, to create great game-based learning designs and experiences for the future.