At a Glance
Jan Vantomme’s Processing Cookbook bills itself as “Quick answers to common problems.” In this regard, the author nicely succeeds in accomplishing that goal. The book is well organized, quite readable, and filled with many useful entry points for coders looking to jumpstart their projects. While it should not be the first book on Processing in your library (nor is it intended as such), it is a worthy addition for anyone wanting handy recipes that help serve up tasty procedural dishes.
Those who are new to both Processing and programming in general are probably advised to look elsewhere. However, it would be unfair to say that the book is beginner-hostile, as the first few chapters are a nice orientation in the Processing environment. Intermediate to advanced coders would probably have no difficulty using this as a suitable guide to getting started in the Processing language. Still, the main audience for this book is likely to be those who are already familiar with Processing, and can benefit from having a good set and a wide variety of starting points. This book would be at home in both the classroom and the individual bookshelf.
Chapters progress gradually from beginning topics to more advanced ones. Each chapter follows a set structure and format which fosters a feeling of familiarity even for new topics. Readers move easily through a “Getting ready” section to the more detailed “How to do it…” section. Afterward, there is a review section “How it works…,” and occasionally a “There’s more…” or “See also” section for additional areas to explore. When encountering new material, it’s nice to have these guideposts so the terrain never feels totally foreign.
These are not in-depth tutorials. Like most recipe books, the idea is not to teach you how to cook, but to give you the ingredients and steps necessary to make something happen. You could choose to follow the instructions exactly, and get the same exact results, but the expectation is that you’ll use these recipes to breeze through the tedium in order to focus on concocting your own special sauce.
For my review, I used the digital version of the book. I installed a copy on my desktop setup (.pdf) and my iPad (eBook). While I generally prefer books in a physical format, programming and technical manuals can be unwieldy. With the digital version, I could easily switch between coding and reading on my desktop, and reading on the go with my tablet. In both environments, the layout is clear and legible, with the added benefit of being able to change document and content size as needed. The book design is easy on the eye, and avoids much of the ponderous density that plagues so many technical books.
All the code examples in the book are available for download. The book is written for Processing version 2.0, which as of this writing (late 2012) is still in beta. This means the examples are forward-looking, and should remain valid and useful for some time to come. The extra good news is that I tested the code in Processing 1.5.1, and found it to be mostly backward compatible as well. A very few sketches required slight modifications to run in the older version of Processing, but these tended to be obvious for the moderately experienced user. Exceptions to this were in the chapters on video, Android development, and writing libraries. For these, the user will need the more recent version of Processing.
The code itself is generally easy to follow and nicely organized. Comments are minimal and unobtrusive, but present when you need them. There is nothing particularly flashy or clever — the author seems much more interested in giving you a good set of workaday tools than showing off artsy syntax.
The output as well is nothing fancy, just enough to make sure the sketch is working as intended, and not be completely without interest. Here again, there seems to be just the right balance in keeping you motivated while encouraging you to add your own creativity.
There’s not a lot to fault with this book. There are a few typos here and there, but these are not terribly distracting. Besides, there’s a link in the preface for how and where to submit errata.
Although the book generally flows nicely, the illustrations of the output come after the explanations. I found myself wanting to visually know ahead of time what the goal of a particular piece of code was. Of course, part of learning to program involves being able to look at code and visualize what is supposed to be happening, so in this regard the reader is being respected by not being spoon-fed.
Sooner or later, everyone develops their own coding style and preference. I like variable names that are semantic even if they take longer to type and take up more space on the page. I have grown to dislike variable name choices that cause me to look around in other parts of the code to remind me what their meaning is supposed to be. In other words, the author’s coding style is not an exact fit for my own, but of course there’s nothing to keep me from editing any code I would use to conform to my own way of doing things.
I also wish the downloaded code chapters were named as well as numbered, according to their chapter headings (sub-headings are, by the way). When needing to grab code quickly to start a new project, I’d rather not have dig randomly through the top level directory, or open the book just to find a pointer to what I already know I want. Again, I can easily rename these folders myself, but it would be nice not to have to.
Am I being nit-picky? Yes, simply because the author and publisher left me no major targets to shoot at.
When I read a book on programming or any technical manual, I always have several questions in mind. Can I read it in a linear fashion? Can I easily find the part I need as a reference? Is the experience pleasurable, or at a minimum, painless? Is it well organized and non-intimidating to look at? Is the content useful? Am I learning something new, but still accessible? Does the author seem more interested in helping me than in showing off? Is this something I will want to pick up again and keep finding value?
To all of these, I can answer “yes” for Processing 2: Creative Programming Cookbook. Much of the code will be helpful for current projects, and much of the rest served to help me know what to look forward to when I step up to Processing version 2.0. Several of the chapters covered areas that I have not yet spent much attention on… this book has definitely lowered the bar for entrance into these topics, while raising my enthusiasm the same time.
Processing is a rapidly maturing technology, and we’ve arrived at the point where there are a number of good books on the subject. We are lucky to have the comprehensive reference books, the thorough-going text books, and the gorgeous gallery books. Now we also have a cookbook, exactly the sort of thing you want when you need more than the standard online reference, and less than the ponderous textbooks.
Processing 2: Creative Programming Cookbook is not the only book on the subject you will want to own. But once you have it, I wouldn’t be surprised if it’s the one you wind up turning to first, and most often.