I’m pleased to announce I’ve published a first draft of a tutorial about using Box2D in Processing.

Tutorial: http://www.shiffman.net/teaching/nature/box2d-processing/
Google code repository: http://code.google.com/p/pbox2d/

I’m struggling here to figure out whether I’m (a) creating a Processing Box2D library or (b) simply creating a tutorial and set of examples piggybacking off of JBox2D. For now, I’m doing a little bit of both. The library is just a few helper functions, but the examples require you to dig into actual Box2D code. These examples aren’t nearly as comprehensive as what you’ll find in the JBox2D demos. It’s my goal, however, to make the material accessible and easy to use. Hopefully, with some feedback and more time, I’ll be able to publish a more sophisticated library and thorough suite of example. Who knows, maybe no one will ever need any of my previous Nature of Code tutorials any more!

Next up, I’m planning on creating a few simple examples that use the fantastic and awe-inspiring toxiclibs.

For anyone who missed it, here’s a video of the 2009 Big Screens show at IAC. Thanks to Lina Giraldo for editing it together, and a great group of student volunteers who did the shooting.

It seems like every day I hear about another Processing book being published (or soon to be published). Joshua Noble’s recent book includes Processing along with openFrameworks and Arduino: Programming Interactivity: A Designer’s Guide to Processing, Arduino, and Openframeworks. Processing for Visual Artists is another new book I know little about, but am excited to check out. And I’m particularly thrilled for the upcoming Getting Started with Processing. An inexpensive, short beginner’s guide is a big gaping hole in the landscape of Processing books and this book should fill it nicely. It’s really what I imagined Learning Processing: A Beginner’s Guide to be, but the book ballooned a bit into a more comprehensive beginner textbook. Hopefully Casey and Ben’s new book can introduce a lot of new people to Processing.

Finally, Ira Greenberg’s new book The Essential Guide to Processing for Flash Developers recently came out. And if you didn’t notice, I wrote the forward! Which, strangely enough, means that my name is somehow on the cover along with Ira’s. Which is pretty crazy considering that I only wrote a few short paragraphs.

Oh and I still am working on a The Nature of Code book, with more PDF chapters to be available soon!

Please RSVP to: itp.rsvp@nyu.edu

More info here: http://itp.nyu.edu/bigscreens2009/

ITP recently celebrated its 30th anniversary with a weekend of events and activities compressing the entire ITP experience into 3 days. Saturday culminated with a gala event at IAC, celebrating the launch of the Red Burns Scholarship Fund. I worked with a group of ITP students and staff to develop content displayed on IAC’s 120 by 12 foot video wall. Everything you see below was made with Processing and the most pixels ever library.

Thanks to amazing and dedicated group who pulled all of this off (under an incredibly tight and stressful timetable): Xiaoyang Feng, Meredith Hasson, Juri Imamura, Brian Kim, Matt Parker, Jeremy Rotsztain, Tim Szetela, Carolina Vallejo, Elie Zananiri.

The videos are just slices of the original 8160×768 pixel design (as seen in the flickr screenshots). Hopefully I can find some nice images or video from the actual event to post here soon as well.

ITP 30th Anniversary Timeline Documentation from shiffman on Vimeo.

ITP 30th Anniversary Timeline Documentation from shiffman on Vimeo.

ITP 30th Anniversary Floorplan Documentation from shiffman on Vimeo.

ITP 30th Anniversary Tweets Documentation from shiffman on Vimeo.

Yesterday, Rhizome published a short interview I conducted with Casey Reas and Ben Fry about the past, present, and future of Processing.

I recently had two projects (Swarm and Voronoi in a show at the Peninsula School of Art, entitled “Flickers of Recognition.”

June 5, 2009 to July 16, 2009

Location: Guenzel Gallery @ Peninsula School of Art

Recording our everyday lives has gone from the privacy and simplicity of writing in a diary to real-time, digital exposure on the internet. This exhibit reveals the many ways we see ourselves in the 21st century. Watch your portrait quickly emerge from lively patterns on a flat screen TV, view an artist’s 70lb weight loss via video in a matter of minutes, or experience a decade of an artist’s life through daily Polaroids. These works and more showcase the art of today’s self-portrait. Free and open to the public. 920-868-3455 www.peninsulaartschool.com; e-mail: staff@peninsulaartschool.com.

Let’s take a moment to go over some of the finer points as to why I am doing this.

Dollars and cents

Learning Processing retails for $49.95 (amazon’s discount is 10%: $44.95). When the publisher sells a copy of the book, I get some money (yay for me!). Based on my first royalty statement, this works out to approximately $3.73 per copy. Sure, I’m not writing books about programming with Processing to get rich, but I did spend a couple years working hard on the project and every little bit counts.

Let’s assume for the moment that I could sell the same exact book via lulu.com. The actual cost for printing the book would be ~$14.00. Ok, so let’s say I choose to sell the book at $25.00 (half the actual current cost.) That’s $11 of profit for every book sold, lulu takes 20%, leaving me with ~$8.80 per book sold. The book costs half as much and I get more than double the revenue! Now, this is just one scenario. I haven’t decided what service to use, how much of a mark-up is appropriate, etc. But you get the idea. There’s no reason a no color, no frills, beginner programming text needs to be $50.00.

Release early, Release often

As an author, it’s just nice to have a lot of flexibility with the process. With self-publishing, I can do things like release early drafts of PDFs online for feedback (see below). This is not something I could have easily done with a traditional publishing house. Instead of spending months or years writing a book before anyone sees anything, the idea is that I can just put stuff out there (for cheap) as I type and then iterate. And there are no limits of how I choose to distribute the book (excerpts published as tutorials on Processing.org? Free on my site? PDF for a million dollars? Audio book? It’s all fair game.).

Once the book is done, I can easily continue to make changes and update. Now, Processing has a fairly stable API, one that is not going to undergo massive changes anytime soon. And sure, how gravity works, the formula for the mandelbrot set, these aren’t concepts that are going to change that often. Nevertheless, anytime you write a technical book, technology changes faster than you can write, and no matter how careful you are, there’s no way to avoid making a serious amount of mistakes. With self-publishing and print-on-demand, I don’t have to wait (possibly years) for a print run to finish selling in order to make changes. I could make them daily if I wanted to. And that Chapter on PHP that I realized I really should have included in Learning Processing, well, I could just add it whenever I so choose.

Downfalls

There are certainly some pitfalls to self-publishing. One major issue, of course, is deadlines. Without a publisher I’ve got very little pushing me forward other than myself. In fact, getting this first chapter done took me twice as long as I intended. And other projects are getting in the way, I’m not sure how fast I will actually get to chapter #2.

The other main issue is distribution. I don’t care if I don’t get my book in Barnes and Noble, I mean who is really buying Processing books at Barnes and Noble?! I do need Amazon.com, but looks like there are plenty of print-on-demand options that can be distributed via Amazon. The major question for me is university bookstores. I don’t have any numbers, but it does seem to me that Learning Processing gets stocked in a lot of school bookstores because it is being used as a text for classes. So this is something I need to figure out, how can I get a self-published book to stores.

Oh yeah, an index. The publisher made an index for me. There’s got to be a way I don’t need them for that, though.

In the end, I could be wrong. This could be a failed experiment. Maybe no one will buy it, maybe I won’t finish it. The nice thing, however, is that if I’m really headed in the wrong direction here, I can always change my mind and start sending out proposals to a publisher. But the other way around, going from a publisher to self-published, well, that wouldn’t be so easy.

So, if you’re interested in checking out what I’ve started so far, for now (subject to change), you can purchase the PDF on lulu.com. I’m selling draft chapters for small amounts with the idea that I could raise a little bit of money to pay for design, typesetting, technical editing, etc. once I’ve got a more finished draft.

http://stores.lulu.com/dshiffman

UPDATE: I’m also looking for a service that would let users buy early drafts of a book and then upgrade to the final version at a discount or for free. Suggestions for how to do this welcome.

ITP Spring Show 2009 from Winslow Porter on Vimeo.

ITP Show

First, a hearty thank you to Golan Levin who did a tremendous job planning and organizing the mind-bending experience. Some highlights:

Oxford Project Part III — Thanks to the ever ebullient Ira Greenberg and Miami University for sponsoring (and the Studio for Creative Inquiry @ CMU for giving us space), we were able to convene before the main festivities began to give Processing a push towards some number past 1.0. Stay tuned for exciting improvements in Processing’s video and OPENGL libraries as well as to the IDE itself.

Saturday was a day full of workshops. In the morning, I attempted to teach an entire semester of ICM in under three hours, followed by an afternoon mix of topics related to physics simulation and image processing.

Sunday was the day to end all days with the lineup of speakings including lead developers of the languages / environments: Alice, Pure Data, Scratch, Hackety Hack, Processing, Max/MSP/Jitter, vvvv, ExtendScript, and openFrameworks. Some highlights within highlights here were Luke Dubois’ demo of “what is known in the biz as random atonal crap” and Sebastian Oschatz’s boy band metaphor for multi-screen setups (one that I really need to take a look at more closely as we develop “most pixels ever” at ITP.) Videos of all the Sunday talks will eventually be posted at vimeo/artandcode.

On Monday, I was lucky to have the chance before heading home to catch the work of Casey Reas and Marius Watz at the Pittsburgh Center for the Arts.

Of course, all of this was really just an excuse for a nice group photo.