How can artists and graphic designers approach programming? The steep learning curve of working with a general-purpose programming language can be a real passion killer. Processing is an open-source programming language and environment that solves this problem in a pragmatic, yet elegant way.
The Processing language is built as an extension of Java. Therefore, it benefits from Java’s mature design and large supporting ecosystem. Processing differs from Java in that one can write statements without having to enclose them in a method and a class. With a stroke, this small simplification removes two big stumbling blocks for the budding artist who just wants to experiment with drawing on a computer screen. Additional features that make life easier are a preallocated canvas and simple methods tailored for drawing, sensible defaults for all values, intuitive ways for specifying colors, a simple animation model, painless array expansion and contraction, and some nifty functions for normalizing, mapping, and transforming values and shapes. Furthermore, the available facilities are tailored for graphic designers. for instance, loading an image is a matter of a simple function call, while the program’s output can be easily saved as a high-quality portable document format (PDF) file. Not all elements of Processing are optimally designed: the representation of two-dimensional (2D) images as one-dimensional arrays and the handling of fonts through bitmap are two sore points. On balance, however, the power of Processing is exactly the right level for an artist.
The Processing environment supports rapid prototyping (just like the interactive Basic, Smalltalk, Turbo Pascal, and Visual Basic environments). This brings back the long-lost joy of serendipitous creative programming. The environment features a window where one writes code, a console for printed output, and the canvas. Syntax highlighting and intuitive error messages help nonexperts, but won’t get in the way of a seasoned programmer. Interestingly, the code one writes in the Processing environment can then be readily exported as a regular Java applet, which can be run locally or over the Web.
This book covers the language, the programming environment, and much more. It is structured like a programming textbook for beginners. However, instead of the traditional dry “Hello World” and calculate-the-average examples, each chapter uses the graphics capabilities of Processing to create visually interesting pictures. The text is easy to understand, but definitely not simplistic: it addresses clever people who want to experiment, and who crave creative power. The approach is unapologetically pragmatic. The first concepts discussed are the most interesting and useful for a designer, with loops, branches, and objects introduced as late as possible. The authors clearly put a lot of thought into organizing their material in a way that would fit the needs of their students, rather than slavishly following some abstract theoretical structure. For example, the humble functions floor, ceil, min, and max are discussed together as methods for constraining numbers. Chapters introducing new concepts often begin with a broad overview of the underlying technology. For instance, strings give rise to a discussion of natural language processing, fonts to digital typesetting, and video to computer vision. After reading the book, and experimenting with the environment, I was intrigued by the possibility of adopting Processing as a general-purpose introduction to programming.
Interspersed with the tutorial text are larger examples, which are also available for downloading from the Web site (http://processing.org/). Even more interesting are chapters presenting the work of, and interviews with, computer-graphic artists. The associated art pieces are deep and pioneering, yet the text is easy to follow and a rich source of creative ideas. The breadth of the book’s coverage is impressive. Processing covers all areas convincingly, including: drawing with vectors and pixels, fonts, colors, keyboard and mouse input, motion and animation, image processing, file handling, simulation of biological and physical systems, three-dimensional (3D) graphics, vision, network access, sound processing, printing, mobile devices, and interfacing with the physical world.
As one might expect, the design of the book and the associated Web site are both beautiful and functional. In fact, one can easily imagine the book leading a double life: by an artist’s keyboard in the morning, and on the coffee table in the afternoon.
The technical sophistication of Processing is modest; one versed in Java can readily understand what goes on behind the scenes. Yet Processing, by removing the tedium of programming with Java’s exacting encapsulation mechanisms and application programming interfaces, liberates artistic creativity. This large difference between effort and effect is the beauty of many great ideas.
