My first thought upon receiving a review copy of “Processing for Visual Artists” by Andrew Glassner was “hey, yet another Processing book?” Glassner is well aware of the ubiquity of Processing literature, however, and targets a specific gap, following his philosophy “that artists and designers are not interested in programming for its own sake, but only as a means to an end: creating expressive work”. This book is made for people who have never written a program before or don’t feel very comfortable in the world of code. Glassner invites the reader to peek over his shoulder to learn about his programming process using a friendly and informal style, which is motivating and makes the book easy and fun to read. And if you like to cook or play the piano (I do!), you’ll feel right at home with Glassner’s many real-world analogies.
The beginning of the book is basically a casual conversation between the author and the reader – master and apprentice –, showing the reader around, introducing computer science terminology, and most of all, taking away the fear of the seemingly steep learning curve. Glassner shows a lot of empathy towards someone new to programming, acknowledging that it will look overwhelmingly complex at first and be hard work, but that, just like learning to ride a bike or playing chords on a piano, the complexity will soon fade away, allowing even a novice programmer to create exciting work. He has three pieces of advice: there is no way you can break your computer with your program, type every code listing by hand (so it’ll sink in), and don’t be afraid of errors. In fact, Glassner left the errors he made when creating the example code right there in the book, so that, as the reader follows him along, he will see where and why an error was made and how it was fixed.
I think that this is a valuable way to teach, because Glassner confronts the reader with the reality of programming all the time: the errors and points of failure, the syntax quirks, using code that is not wholly understood, the refactoring, and so on, everything step-by-step with guidance from the master.
This rootedness in the real world also shows in the way the reader is introduced to his first program: it’s a half page listing. If you’ve never programmed before, there is no way you can understand this, and this is the point Glassner makes over and over again in the book: don’t try to understand everything from the beginning, it’s too complex. Instead, dive right in. Type the code, run it, see what happens and you’ll learn the syntax soon enough. This way of teaching reminded me of my first steps at programming with a tiny BASIC book: I didn’t understand what the words meant, but hey, things moved and made sounds!
Between throwing long code listings at the reader, Glassner takes care to explain the building blocks of the programming language: variables, functions, tests, etc. But he goes deeper than you would expect from a beginner’s book and shows you the shortcuts and edge cases like the ternary operator. I was surprised by this at first, but soon recognized the value of showing it, because you will inevitably encounter it in the wild, be it in forum posts or other peoples’ code, and then you’ll have a really hard time understanding what happens there or finding anything about it on Google if you don’t know what it’s called.
The book has three main downsides. First, it is written in an informal, conversational style that might not be for everyone (I liked it, though). Second, the visual quality of the example sketches is not as good as I’m used to from other Processing books or online resources, but this also leaves room for the reader to create more interesting visuals.
The main pain point, though, is the book’s size: 900 pages is quite a lot to go through if you’re new to programming. Of course, you’ll get a lot out of this, from writing your first program to organizing a large project, with a lot of interesting examples in between, be it 3D objects, image manipulation, Bézier curves, recursion, etc. Still, I feel that shorter would have been better, maybe not as short as the above-mentioned BASIC book, which was about 50 pages long, but not as elaborate and exhausting as an encyclopedia, either.
To conclude this review, I can say, that I like this book and think it has a lot of value for people new to programming. There’s also code in there that’s interesting for more experienced programmers, but they really aren’t the target audience and might be under challenged. I think that Processing is a great language for people starting out with programming, because it has a simple development environment, really good documentation, a lot of example code and great performance – and Glassners book is a good guide and companion.
If, like me, you like the concept, but don’t like the Java syntax roots of Processing too much, I can recommend two further projects to program away with: Ruby Processing and Nodebox (OS X only). And if you want a fun and geeky way to learn programming that is different from all others, you should know about _why’s Poignant Guide to Ruby. Just sayin’.
The book's author, Dr. Andrew Glassner, is a writer-director, and a consultant in story structure, interactive fiction, and computer graphics. He started working in 3D computer graphics in 1978, and has carried out research at many respected labs.