6
$\begingroup$

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?

$\endgroup$
  • 4
    $\begingroup$ I'm voting to close this question because “is anyone out there doing this?” invites a long list of “me too” answers, which Stack Exchange isn't a good place for. There are surely good questions to ask about how to devise a course around Processing, about how to teach this and that subject using Processing, about what audiences it's suitable for... but this question isn't it. $\endgroup$ – Gilles 'SO- stop being evil' May 23 '17 at 20:59
  • 1
    $\begingroup$ This is a new site and this is the basis for useful discussion. We need to get some of those started. $\endgroup$ – ncmathsadist May 24 '17 at 0:34
  • 3
    $\begingroup$ No, this is not a discussion site, it's a question and answer site. We do not need overly broad questions to get started, in fact they're a bad idea because they start the site with poor content that is inferior to other, more established resources. The ideal way to start the site is with focused, expert questions. $\endgroup$ – Gilles 'SO- stop being evil' May 24 '17 at 8:40
  • $\begingroup$ I have a vested interest in this topic and would love for substantive, experiential responses, so I suggested an edit that might address the issue of it being "too broad." $\endgroup$ – Peter May 27 '17 at 1:53
  • $\begingroup$ @Peter:I have (hopefully) narrowed the question by asking for whether this meets "minimum requirements"/entry point as opposed to "best practices," and wonder if the question can be reopened in its current form. $\endgroup$ – Tom Au Jun 12 '17 at 2:46
4
$\begingroup$

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.

$\endgroup$
3
$\begingroup$

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.

$\endgroup$
2
$\begingroup$

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:

  1. The community (not as important now as it was then since there are more alternatives)
  2. Java as the core language (this meant that we bought into the oop idea but we could also say "the language used in APCS-A which for a summer program was a selling point)
  3. A number of interesting libraries to use.

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.

$\endgroup$
1
$\begingroup$

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...)

$\endgroup$
0
$\begingroup$

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.

Faculty preference

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.

Industry relevance

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.

Technical aspects

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.

Tools and materials

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.

$\endgroup$
-1
$\begingroup$

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.

$\endgroup$
  • 1
    $\begingroup$ Can you elaborate here on some of those criticisms? It's helpful for us to have answers here rather than on a site linked out to. Thanks! $\endgroup$ – Peter Jun 14 '17 at 17:25
  • $\begingroup$ @Peter it's a large, well-thought-out piece building on especially Papert's constructionism research, with the sections following on each other. It will take away from the impact of everything he says to quote smaller sections. Which is why I only mentioned the types of things he criticizes in Processing (and other systems), such as poor readability, not making computation visible, etc., as I mention in my answer. $\endgroup$ – Abraham Jun 14 '17 at 17:30
  • 1
    $\begingroup$ The criticisms, in my opinion are more applicable to the Khan academy system rather than the tool. It's easy to poke holes in all of those self guided learning environments. All programming languages / teaching tools have their ups and downs. You can design wonderful educational experiences with processing and horrible ones as well. $\endgroup$ – Mike Zamansky Jun 14 '17 at 17:32
  • $\begingroup$ @MikeZamansky I don't agree re applicability. Although some of the criticisms could be said to only be applicable to a system with higher levels of liveness (liveness itself being a good thing, which Processing does not have), most are not -- such as the criticism of the [design decisions that were made when creating the] Processing language/environment itself in the Language section of the essay, touching on Identity and Metaphor, Decomposition, Recomposition (global state, modes that alter the meaning / consequence of code), and Readability (context-sensitive, memorisation, ambiguity). $\endgroup$ – Abraham Jun 14 '17 at 17:56
  • $\begingroup$ @Peter if you've read the essay, you (and everyone else of course) are very welcome to share suggestions for which criticisms to put in this answer like you asked -- I can't actually think of any that won't reduce the impact of reading the essay in its entirety. If I agree with the suggestions I'm more than happy to edit my answer for the sake of everyone reading it. Thanks! $\endgroup$ – Abraham Jun 14 '17 at 18:20

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.