Brett Victor recently posted an intriguing essay entitled Learnable Programming. I’ve been a fan of many of his essays (e.g.,  and ). Victor is quite a pioneer of what we might refer to as design-based computing pedagogy as opposed to a programming or assessment driven pedagogy. And this essay surely lives up to his previous work; I think I could write fifty blog posts reacting to this single essay. T-49 …
- Processing allows artists and designers to write real code with relatively little pain.
- Processing balances developing powerful programmed artifacts with a relatively simple programming interface.
- Processing has a welcoming, productive open-source community.
- A ton of libraries and examples help students write relevant, meaningful sketches (e.g. with video, images, sounds, etc.)
- to support and encourage powerful ways of thinking
- to enable programmers to see and understand the execution of their programs
These two goals are important. But they aren’t the whole story. If that were the case, his cited cases of smalltalk, hypercard and logo would still be popular. Sadly computing is not only driven by pedagogy, but also pragmatic concerns. Our students want to write real programs. Programs that run in browsers, run at 60 frames per second, and connect to webcams. And although we should always strive to develop new pedagogical environments that do all of these things, reality is reality.
And within these pragmatic concerns, I would argue that Processing can indeed meet Victor’s two stated goals, if used properly from a pedagogical point of view.
- Processing, especially when compared to Photoshop, Gimp, iMovie, and Illustrator supports and encourages powerful ways of thinking
- The graphical elements available in Processing enable programmers to see and understand the execution of their programs
Although certain Processing programs aren’t easily understood using its graphical elements, such programs will always exists. There will always be programs that defy 2D, 3D, or 4D visualization. That said, we can use Processing’s graphical approach as a powerful way to make a program less opaque. For example by avoiding loops in the first four or fives weeks, I’ve found Processing’s graphical elements capable of visualizing variables, expressions, function calls, and conditionals. The following sketchpad.cc example is an example:
It is our job as computing educators to discover or invent programs that elucidate the underlying programming concepts in the most effective way. Some programming environments make this difficult, others make this a joy. I’ve found Processing to be mostly a joy. This is not to say we shouldn’t invent better programming environments, of course we should (and I am). Visualizing the internal states of our programs is important, but it is not the silver bullet.