Summary:
Processing is an open source programming language and development environment initiated by Ben Fry and Casey Reas of the Broad Institute and UCLA Design | Media Arts, respectively. The processing language and environment strives to simplify programming for the beginner, such that someone with little or no programming experience can easily experiment and immediately see their results. While processing is capable of simple results quickly, it is robustly integrated with Java and streamlines many tasks that advanced users might expect. Processing runs on any machine with Java, is free and open source, and boasts a very active online community.

Such an easy-to-use platform for coding, particularly web-based applications, has made the investigation of information design and visualization accessible to a whole range of users who might have not had the coding skills, or time, to participate in the practice previously. Even from processing’s inception in 2001 a progression can be seen as web graphics, made possible by such projects as processing, have become increasingly refined both aesthetically and in the depth and clarity of information display.

Description:
Processing was initiated by Ben Fry, of the Broad Institute, and Casey Reas, at UCLA’s Design | Media Arts program, having evolved from ideas explored in the Aesthetics and Computation Group at the MIT Media Lab; the beta version was released in April of 2005, with unscheduled updates occurring regularly. Processing is primarily a programming language and software development environment, but owing to the backgrounds of processing’s founders much of the project’s emphasis is on digital art and information design. This is reflected in the language and focus of the code itself, but also in the tone of the processing forums. Alongside a forum for Simulation and Artificial Life are forums on Tangible Computing and Information Visualization — topics that are on the forefront of computer interaction research.

Running the processing application opens up a window with a file menu along the top, some familiar stereo style play and stop buttons, and a blank text area in which to write your code — this is the development environment. The file menu has a “sketchbook” wherein your programs will be saved, and the sketchbook comes with a sizable list of example programs. The sample programs are particularly helpful for people new to coding or new to the processing platform as they highlight the capabilities of processing and make the code easy to manipulate. With no experience coding, one can start making changes in the sample code “just to see what happens.”

At some point a question or problem will arise, and this is where processing’s devoted community becomes apparent. Posting a question on the processing forum is likely to elicit a response within hours, if not minutes, from a distributed array of volunteer processing experts. This is truly one of the most notable aspects of processing — that somehow this open source software project has inspired a great number of people to become invested in refining the software as well as helping novice programmers with their learning. While processing is ostensibly a programming language and development environment, the community of people involved in its continued development and promulgation should not be overlooked, as they are integral to this project called processing. Casey and Ben did not design processing but rather, in their words, initiated it.

Processing programs are referred to as “sketches” to highlight their capacity to be completed quickly, and in an impromptu manner. While some sketches may be finished projects, some sketches are only steps in a refinement process that may be completed within processing or in another language. Thus processing becomes a valuable tool not only to the teacher and student of programming, but to more advanced programmers looking for an easy way to prototype new ideas.

Once a sketch is complete and running smoothly within the processing environment, there are several options for outputting the sketch. Under the file menu are two notable options: export and export applications. Export produces a folder with an html page that has your sketch placed within it along with links to the code and to the processing site; this folder can be moved to a website and the sketch becomes web applet. Export application outputs three folders into the sketch folder; each folder contains a standalone version of your sketch as an application — one folder each for Linux, macosx, and windows.

The processing site also has an exhibition area where exceptional projects are displayed, and while it may be some time before a beginner shows up in the exhibitions, the community routinely posts more modest sketch examples to the forum for feedback. Generally the posted sketches, and often even the exhibition pieces, are shown alongside the original code to facilitate the learning process and promote an atmosphere of open-source programming.

Research Context: Processing is a very good pedagogical tool for programming in general and in particular, interactive information design and digital art. In this capacity it works quite well, and is actively used in many universities, particularly on several campuses of the University of California, and in its short life has dramatically increased in internet distribution. Notably it is a free and open source project and another example of the effectiveness, importance, and support for such models.

While it is difficult to say that processing is responsible for any increase in the number of students interested in programming overall it is certainly responsible for an increase in programming by non-programmer students, and contributes to interdisciplinary communication and the cross-pollination of visualization ideas and needs. Processing holds a prominent position as a tool in the growing fields of information design and visualization, internet-based and digital art, winning the 2005 Prix Ars Electronica Golden Nica award for Net Vision / Net Excellence.

Technical Analysis: Processing is a Java application that facilitates writing processing code which eventually becomes Java code itself. This is primarily a benefit that builds upon java’s cross-platform usability, but begs the question, why not just learn Java or Flash. This question was posed to Ben Fry and he responded with a telling list of what he saw as the primary innovations and motivations behind processing. This interview was conducted in February of 2003 while Processing was still Alpha and known as proce55ing; the following is quoted from http://since1968.com/article/11/benjamin-fry-interview:

• proce55ing is free to use, and the code (will be)[it is now] open. Better for an educational environment as it makes no constraints and doesn’t require expensive lab licenses.
• It is a 3d environment, something not (yet) possible in Flash. *You can work in both 2d/3d and then have direct access to manipulating individual pixels by hand.
• It is based on a ‘real’ programming language, java, so the skills are more transferable to learning full-fledged java programming or moving on to c++. Also, ActionScript was tacked on to Flash, and it shows as each layer they add seems to complicate things more. Languages that evolve in such a way often wind up being a mess or have major rewrites (look at what Director went through).
• It has built-in support for serial port access, so that it’s easy to build sensors, and other physical interfaces. [This has become dramatically more true as processing has matured, especially as the processing-based Arduino physical computing platform progresses]It has beginner/intermediate/advanced modes of programming, where beginner is simply one-line commands to draw shapes and advanced is all that in the setting of a full-fledged java program. Moving between this modes is simple, and is designed to grow with the user as they get more advanced.
• I can’t build my work in Flash. We wanted a sketchbook for our own work as much as we wanted a teaching tool. We build things in Java as prototypes and then often move them to c++ if we need more speed. The prototypes all have a similar couple pages of code that are the same, we took that and abstracted it out as part of the library in proce55ing.

Evaluation of opportunities / limitations for Transliteracies: Processing brings up many points for the Transliteracies project, most obviously the processing project is an indicator of the rapid development of online visualization — applications that parse text into detailed yet easily readable graphics. The relatively young discipline of information design is developing alongside the internet and investigates efficient, intuitive, visual interfaces in an online context — something certainly relevant to the Transliteracies project.

While it may be obvious that information design is integral to our goals of improving online reading, it is also important to consider that projects like processing contribute to a population becoming increasingly visually literate — regular internet users who expect intelligent, thoughtful, and alternative methods of interacting with online information and who are sensitive to design as an indicator of the reliability or datedness of information. Indeed, with the popularization of algorithmic visualizations of online texts, online reading seems to be increasingly more graphic than the printed-page.

Processing’s development environment is also a good example of another tangent to consider regarding online reading. As a programmer types up their program a page of text evolves, routinely during the texts developments, the play button — in the context of processing — is pressed. In programming practice the code or text is transformed into an object that perhaps moves, or thinks, but to some degree creates a life of its own. The programmer writes the code and runs the code, but then observes the new objects behavior, is it doing what the coder expected, or do further changes need to be made? This is a novel relationship between text and online behavior, something that is somewhat familiar when we happen across some uninterpreted html script — underneath well-ordered websites are sprawling pages of coded text. The processing environment makes this relationship especially obvious, with the lingering play button above the text area.

When processing outputs an applet for the web it automatically includes a link in the html to the processing code that is producing the visualization. Thus the activity of watching the program perform and reading its instructions become entwined. Just as there is an appreciation of the style or aesthetic associated with a short story or a sketch, the text of code can similarly be appreciated for its aesthetic or stylistic choices. Processing is certainly responsible for furthering the development of “beautiful” code within the contemporary art world by giving it such a prominent place on their website and encouraging users to do the same — post the visualization, but also post the code that produced it.

Resources for further study:

• artificial.dk “Code. Conversation with Casey Reas.” 01 Sept 2006.
• Greenberg, Ira. “Foundational Processing (Foundation)” published by Friends of ED
• InfoDesign: Understanding by Design
• Processing 1.0
• since 1968.com “Benjamin Fry Interview.” 01 Sept 2006.