Computer Science Educators Stack Exchange is a question and answer site for those involved in the field of teaching Computer Science. It only takes a minute to sign up.
Sign up to join this community
We have two entry points for programming students here: one is web-oriented and features HTML5/CSS3/ECMA6, and the other is in a robotics environment using LabView. Both classes address the "big 5": variables, objects, functions, conditional logic, and iteration.
We are thinking about a new entry point for a new audience. What features of the Processing language lend themselves to an introductory course?
I am currently designing an intro to programming course for middle school students using Processing. In particular, I am using these two resources to focus the curriculum:
Make's Getting Started with Processing: A Hands-On Introduction to Making Interactive Graphics
Raspberry Pi Foundation's "Introduction to Processing" Resource
Make's resource moves all the way from simple, one-line programs like ellipse(50, 50, 80, 80); to OOP, file IO, JSON, data visualization, etc.
To supplement these resources, I am using videos from Daniel Shiffman's YouTube channel The Coding Train. Of particular value are his short coding challenges where he completes a programming task in the allotted time while talking through the design process.
I find that Processing's power comes from its scale combined with its ease of entry. I can confidently say that students will be writing "real" code on day zero and getting instant results on something other than the command line. Plus, there's the satisfaction of starting to learn programming with a text-based language instead of something like Scratch which can feel restricting and elementary to some students. And, as Daniel Shiffman's videos show, there's really no stopping how far you can go with it.
What features of the Processing language lend themselves to an introductory course?
In a nutshell: Processing makes it easy to create visual, animated, interactive (read: fun and engaging) programs without all of the boilerplate code that other languages require.
For example, here's a full executable Processing program:
ellipse(50, 50, 25, 25);
This program will show a window that displays a circle. Students can very easily change the parameters to see what happens. Can they draw a smaller circle? Can they move it left or right? This allows you to pretty easily talk about functions and parameters, as well as pointing them to other functions in the reference. In pretty much no time at all, you can have them looking stuff up in the reference to draw a scene or a character.
Here's a slightly more advanced program:
void setup(){
size(500, 500);
}
void draw(){
ellipse(mouseX, mouseY, 25, 25);
}
This program shows a 500x500 window, and 60 times per second it draws a circle wherever the mouse is. This allows users to "draw" with the trail left by the circles. This leads you to pretty easily talk about stuff like if statements and user input.
These programs are much more engaging than the typical hello world programs of other languages. Think about all the boilerplate code that you'd need in Java or JavaScript to get a window with a 60 fps draw loop and user input.
Processing also lends itself to "graduating" to other languages pretty easily. It's built on top of Java, so it leads to developing "pure Java" or even using Processing as a Java library. And it can be deployed as JavaScript using Processing.js, which leads to developing HTML and JavaScript (which circles back to developing P5.js).
Other than that, I love the community built around Processing: it's geared more towards artistic and creative coding, and makes an effort to be inclusive and welcoming to novices.
Shameless self-promotion: I've written a series of tutorials on Processing available at HappyCoding.io.
My team and I have used Processing for an intro experience a couple of times. The first was for rising ninth graders when I designed Google CAPE 2010.
There were a number of reasons for the decision to use processing but the bottom line is, at the end of the day, it worked very well.
We have since used processing for the intro experience for the CSTUY SHIP summer program and again, it works well.
As with any platform / language, you have to make some choices - Processing lends itself to graphics without GUI support so if you want to really be text or GUI based that could be an issue. We also had some compatibility issues with either the sound or video library (I forget which) but that said, the fact that on supported platforms, it was easy to access these features was a plus.
Some of the reasons we chose processing:
On the other hand, I've never used Processing for a school year class intro experience but there's no reason why it couldn't be used.
The CSP course at UW uses processing The instructor has reported mixed feelings about it.
Stanford is trying out a new course based around Javascript: (but it hasn't run yet...)
According to a semi-recent survey paper by Pears et al.1,
During the last four decades, many languages have been used for teaching introductory programming. The language choice is usually made locally, based on factors such as faculty preference, industry relevance, technical aspects of the language, and the availability of useful tools and materials.
On these criteria, Processing doesn't look too bad.
What can I say to you about your own preference? I would just advise thinking about what you hope to achieve with the course. As I've said elsewhere on this site, a traditional computer science program, a zero-to-job-ready boot camp, and a short-track for non-majors might have intro courses with very different objectives, and that's as it should be.
Relevance is kind of a hidden benefit here. I've never heard of any big companies writing serious enterprise projects in Processing. However, it is based on plain old Java, which remains one of the most widely used languages today. In fact, it's sort of a best-of-both worlds situation.
Pears et al. tell the story of RIT dropping Eiffel because students didn't want to learn a language that they couldn't use after graduation, but also note that one big downside of Java is that it come with a lot of syntactic baggage that gets in the way of learning actual computer science (algorithmic thinking, how data structures work, etc.). Processing strips away a bit of the syntax that Java beginners find overwrought while still being basically the popular language that they will be able to use in the real world.
Not much to say here beyond what was in the previous section. Processing is very graphics-oriented. It'll be up to you to design a curriculum that teaches CS concepts using graphics-oriented tools.
There's plenty here. A solid official website at processing.org with documentation and tutorials, a relatively small but respectable community on Stack Overflow, a subreddit, and a FOSS culture that has ported Processing to other languages/platforms.
Simon Fraser University recently ran an intro course using Processing. I have no special insight there, I found it by a simple web search. But if you're interested, maybe you could reach out.
1: Pears, A., Seidman, S., Malmi, L., Mannila, L., Adams, E., Bennedsen, J., ... & Paterson, J. (2007). A survey of literature on the teaching of introductory programming. ACM SIGCSE Bulletin, 39(4), 204-223.
Bret Victor offers some excellent criticism of specifically Processing (and Javascript) as a language/environment for learning to program, in his wonderful (like almost everything he produces) Learnable Programming essay, with respect to things like readability, making computation visible, decomposition and recomposition and more. It's a must-read!
JavaScript and Processing are poorly-designed languages that support weak ways of thinking, and ignore decades of learning about learning.
