Processing: Designing and Releasing a Visual Programming Environment, 2001–2008

Casey Reas and Ben Fry developed Processing together, originating in John Maeda’s Aesthetics and Computation Group at the MIT Media Lab. They wanted artists and designers to try drawing, make changes and inspect results through code, treating programming as a method of visual creation. An early 2001 distribution already contained the development environment, Java runtime components and editable graphical examples. The project was still in an early trial phase.

The authors then expanded its use through teaching. Their 2007 handbook recalls workshops in 2001–2002 at Musashino Art University in Tokyo, ENSCI–Les Ateliers in Paris, HyperWerk in Basel and the Royal Conservatory in The Hague. Classroom difficulties and emerging needs fed back into design.

References: [1] [2] [3]

Reas and Fry had both maintained Maeda’s Design By Numbers teaching system. It let beginners enter code and click Run in a simple interface, but users wanted colour, larger images, fonts and distribution over the internet. Drawing on that experience, Processing adopted the more capable Java language while retaining a lightweight interface.

Fry’s 2004 dissertation explains how the early system organized learning through progressively more complex modes. Beginners could write static drawing statements, move into functions and interaction, and eventually use fuller Java programming. Window initialization and mouse handling, otherwise repeated in each graphics program, were placed in a common base program. Simple drawing interfaces reduced the preparation required for lines, images and animation.

References: [1]

The dbn.pde example in the 0001 prerelease contained only two functions. In setup(), size(100,100) created a 100-by-100-pixel surface and colorScale(100) set the numerical colour scale. The loop() function contained only background(mouseX), passing the horizontal mouse position to the background drawing function. Initialization and continuously updated drawing were separated.

The example let learners understand program input through visible mouse movement: moving the pointer changed mouseX, and the same drawing statement recalculated the background with the new value. Input and images could be explored without first creating buttons or writing an event loop. The distribution’s run.bat launched Java with pde.jar and kjc.jar, showing how the early environment provided runtime and compiler components together.

References: [3]

In the version described by the 2007 handbook, the Processing Development Environment, or PDE, included a text editor, message area, console and buttons for running, stopping, saving and exporting. Programs were called sketches. Each had its own folder, with a main source file using the .pde extension and a data directory for assets such as images and fonts.

The Run button combined compilation with displaying the result, making repeated changes easy. Exporting passed the sketch through a preprocessor into Java, compiled and packaged it with required classes and assets as a Java applet, and produced an HTML file embedding it. This enabled working examples to be displayed on the web and made source sharing and comparison of modifications convenient.

References: [2]

In their 2010 preface, Reas and Fry recalled the public beta phase beginning in April 2005, with continuing changes to language, environment and teaching. The early 0001 version used loop() for repeated drawing; by the 2007 handbook the corresponding function was draw(). Calling noLoop() within setup() produced a single drawing. The early example and later handbook together record changes to the drawing interface.

The official revision record lists revision 0162 as Processing 1.0 on 24 November 2008; the authors’ 2010 preface dates its public launch to the 29th of that month. The revision record still listed known OpenGL display and platform-specific startup issues. The formal release emerged through compatibility adjustments and continuing corrections.

References: [5] [4] [2] [3]

Processing soon spread beyond the first workshops. A week-long 2003 course at Hongik University in Seoul brought design and computer-science students together. At UCLA, courses connected programming with discussion of interaction, producing small games and camera-based interactive installations. Fry’s own information-visualization research also relied extensively on the tool.

The software offered ways to modify and extend it. Users shared sketches, experienced programmers supplied libraries for sound synthesis and input devices, and teachers published tutorials and student assignments. A project developed by two people gradually became a mutually supporting combination of programming language, simple development environment, teaching materials and collaborative community.

References: [1] [2]