Ira Greenberg

Download it here. This is the third alpha release as we head toward 2.0. There are many significant changes in 2.0, so be sure to read up on them.

If you find problems, please file a report so that we can fix them.

The big changes since 2.0a2:

• Several Android fixes to handle recent SDK changes by Google. For anyone using Android, you’ll need to install 2.0a3. The Android page on the Wiki has also been updated.
• Fixed a regression in 2.0a2 that prevented serial from working on OS X.
• Tracked down a problem on OS X 10.7 (Lion) where the mode and open menus on the toolbar disappeared immediately.

The full revisions list with the gory details:

PROCESSING 2.0a3 (REV 0202) – 5 November 2011

Some weekend bug fixing and regression repair for the recent alpha releases.

Also several Android fixes to get things working again with more recent
updates from Google. You’ll need to upgrade to this version of Processing
in order to continue using Android mode.

[ environment ]

+ Fix problem with serial not loading on Mac OS X.

+ Fix problem with popup menus on the toolbar disappearing immediately
when used on Mac OS X 10.7 (Lion).
http://code.google.com/p/processing/issues/detail?id=846
http://code.google.com/p/processing/issues/detail?id=887

+ Incorrect tab/line shown for preprocessor errors when more than 2 tabs
http://code.google.com/p/processing/issues/detail?id=873

+ Commenting via menu or shortcut does not set sketch to “need save”
http://code.google.com/p/processing/issues/detail?id=766

+ IDE Export Application button exports applet (fixed in 2.0a2)
http://code.google.com/p/processing/issues/detail?id=863

[ core ]

+ Fix for video frames not showing up in 3D.

+ Rounded rect() does not have a maximum length for corner radius
http://code.google.com/p/processing/issues/detail?id=813

[ android ]

+ Fix libraries when used with Android. Libraries can also specify
an Android version by including an ‘android’ subfolder.
http://code.google.com/p/processing/issues/detail?id=766

+ Fix problem with export menu, keys, toolbar being different.

+ Change default package name a bit.

+ Switch to SDK 8 (Android 2.2) as the minimum that we’re supporting.
This allows us to rely on far more consistent OpenGL implementations.

+ Update the project files for Android SDK Tools Revision 15 (now required)
http://code.google.com/p/processing/issues/detail?id=876

+ Improve launching with the emulator.

+ Remove ‘includeantruntime’ warning during build.

+ “Date could not be parsed” error.
http://code.google.com/p/processing/issues/detail?id=864

I’ve been developing a new piece (pretty much frantically) for the upcoming Sept 15th Amnesty International event, sponsored by the Embrey Human Rights Program at SMU, in Dallas.

The event commemorates Amnesty’s founding 50 years ago in London, sparked by English labour lawyer Peter Benenson’s article “The Forgotten Prisoners“. Beneson reported being moved to action when reading of two Portugese students jailed for simply drinking a toast to liberty.

In the piece, viewers will be able to record their own toasts to liberty, generating an interactive 3d, archived visualization of the recordings. The piece utilizes my new Protobyte library (still heavily under development).

If you’re in Dallas the evening of Sept 15, please stop by!

I’ve been spending probably waay too much time developing my never ending Protobyte library - now in C++. Part of my challenge is as I learn new stuff I go back and revise/refactor (which is supposed to be evil, right?) I’m also sort of building by touch/feel design, so I don’t really have a plan, but when I seez it, I hope I noze it. I do roughly know what I’d like ultimately to be able to do with the library, which is what drives most of the day-to-day dev .

I switched the library from Java to C++ partly out of necessity. I taught the CS 2 course for majors this summer, and it needed to be in C/C++. So I hit the books to get myself fully up to speed. I also felt it was better for me to be thinking fully in C/C++, as I coded my own work leading up the class. I never feel comfortable teaching material that I’m not currently engaged with–somehow the spark is just not there. In the process of the C-immersion, I got smitten by the power, chaos and vastness of it all.

This came as a surprise, as in the past I’ve publicly expressed my love of Java–including trash talk’n C++.  l always liked Java because of its elegant and consistent simplicity, at least vis-a-vis C++. (I’ve also been known to trash numerous other hipster scripting languages that lack strictness and are chock-full of flexible confusion.) C++ is absolutely a chaotic kludge, with so many opportunities to blow yourself up, but for some reason now, I’m loving it.

In my typical fashion I just couldn’t teach the CS2 class in a straightforward way, so I decided to incorporate OpenGL and create all graphics assignments. (I should state here that I was warned by my grad TA, in no uncertain terms, to NOT do this.) I of course did not heed his warning.

Well, this really, REALLY did turn out to be a near disaster. Since the students (at best) had only had 1 prior Processing/Java class and many had no graphics experience at all, I knew I needed to provide a Processing like code womb to get them started, so I wrote lots of code quickly in the month leading up to the class and generated a cross-platform (oh yeah, the students used their very varied laptops) OpenGl template so they could actually render some primitives before the last week of class. I didn’t of course have time to build an ide like Processing, but I wrote numerous drawing routines, simplified things like lighting, transformations, camera stuff, tessellation, etc,  and I heavily commented the template, which said things like /*******/ ONLY PUT YOUR DRAWING CODE HERE /*******/

Somehow we pulled it off, and I had a ball. The students also seem to enjoy the class. My TA worked his ass off, which I’m very appreciative of (Thanks again James!) The experience also helped me broaden/deepen my own OpenGL skills/understanding (which almost always happens for me when teaching), which is paying off now with the Protobyte library.

A pre-release with a million billion bug fixes and tweaks. Download here (in the pre-releases section of your grocer’s freezer), especially if you’re using Android. If this feller works, we’re hoping to do a stable release called Processing 1.5 sometime in the next few days. If you have issues, please report them on Google Code (not in the forum!)

PROCESSING REV 0195 – 10 April 2011

Bug fixes and several Android updates. Working to close in on a proper
Processing 1.5 release.

This release has several changes to renaming sketches, using Save As,
and how untitled sketches are handled. Please help test!

Note that on the Android side, this release once again requires installation
of the Google APIs. See the Android Wiki page for details.

[ general ]

+ Sketch restarts automatically after pressing stop button on PDE
http://code.google.com/p/processing/issues/detail?id=561

+ ‘unexpected token void’ for any type of error (due to fallback)
http://code.google.com/p/processing/issues/detail?id=551

+ Deal with weird states when closing last editor window on OS X

+ With one sketch open, changing the mode doesn’t close the original editor
http://code.google.com/p/processing/issues/detail?id=569

+ Move library examples to the examples menu
http://dev.processing.org/bugs/show_bug.cgi?id=1278
http://code.google.com/p/processing/issues/detail?id=181

+ Ctrl-slash not working on Linux (fix from pkalauskas, thanks!)
http://code.google.com/p/processing/issues/detail?id=596

+ Update to Java 6u24 for Linux and Windows

+ Export .java source files with applets and applications.
http://code.google.com/p/processing/issues/detail?id=570

+ Reference broken in 0194.
http://code.google.com/p/processing/issues/detail?id=572

+ Other reference tweaks

+ Fix exception spew when clicking between editor windows.

+ Don’t reload sketch on “save as”
http://code.google.com/p/processing/issues/detail?id=62

+ Smooth text on the status bar on Linux.

+ Clear up some issues with focus handling in the editor.

+ Save As/Rename don’t properly set focus
http://code.google.com/p/processing/issues/detail?id=13

+ “No library found” message when using import statements and the code folder
http://code.google.com/p/processing/issues/detail?id=568

+ Remove version number from splash image
http://code.google.com/p/processing/issues/detail?id=324

+ Subfolders in /libraries folder not supported in 0194,
bring them back for toxi and the toxiclibs folks.
http://code.google.com/p/processing/issues/detail?id=578

[ core ]

+ Deal with bad screen updates for sketches running < 60 fps in JAVA2D

+ OPENGL2 record only saves one line in a LINES shape (fix from Andres)
http://code.google.com/p/processing/issues/detail?id=579

+ normal() command commented out in sphere() method
http://code.google.com/p/processing/issues/detail?id=602

+ save() and other pixel operations no longer working with JAVA2D in 0194
http://code.google.com/p/processing/issues/detail?id=594

[ android ]

+ point() doesn’t render in A3D
http://code.google.com/p/processing/issues/detail?id=592

+ Android stuck at “Starting Build”
http://code.google.com/p/processing/issues/detail?id=590

+ Deal with missing android-core.zip (No such file or directory)
http://code.google.com/p/processing/issues/detail?id=577

+ Error messages about “No library found for android.*”

+ When returning to android application, sometimes screen stays black
http://code.google.com/p/processing/issues/detail?id=237

+ Device Killed or Disconnected Error Message with Libraries
http://code.google.com/p/processing/issues/detail?id=565

+ Better error handling when certain SDK components are not installed.

+ Canceling an attempt to find the Android SDK leaves no window open,
or crash when trying to change to Android mode w/ no Android SDK
http://code.google.com/p/processing/issues/detail?id=605

I participated in my 2nd Jampact performance; this time at the very cool Interfaith Chapel of Dallas. This beautiful chapel was the last building designed by Philip Johnson.

Marty Sweidel and I had about 3 days to cram some new code into our existing performance system (which is barely a system at this point.) I coded all the visuals in Processing, and Marty built his aural madness in Max; we used OSC to move data between us. Marty, a composer, theorist and electronic music pioneer, filtered direct midi data while also converting live audio to midi, which he then fed to me in quite clean and tidy values.

During the performance, we monitored our system, levels, etc-occasionally tweaking vals and code. For example, if the musicians–who are improvising–get very quiet or super loud or start bashing tons of notes, we can adjust things to keep the visuals from disappearing or the system from catching on fire.

In addition to our contribution, artists Richard Klein and Susan Kae Grant integrated their video projections into ours. My visuals thus far have been fairly iconic, based on explicit 3D geometry–which gets lovingly integrated/blended with Richard and Susan’s beautiful video clips; there are moments that are quite rich and evocative (and others that are somewhat confusing). The performance also included 3 dancers–led by the extremely talented Millicent Johnnie–moving through the space and interacting at time with the projections.

There is a LOT more that we can do to integrate all the elements and tame our systems, but for 3 days notice, it was a great 2nd attempt.

Pulling out some old paintings from the garage-you know how it goes you decide to clean the garage or attic, but as you go through things you get sucked down memory lane–and placing them around the still bare walls of our living room, I had an exciting thought. The paintings were done just prior to my full immersion in programming. I was pushing bits around before and during this period of painting, but it was after completing this body of work that I put down the paint brush to fully concentrate on coding–which led to the job relocations, 2 books, hockey obsession, temporary facial paralysis, etc. This last body of work was based on close up views of branches and foliage. The series began in my back yard in Easton PA, directly in front of the motif, then moved to a visiting studio at the University of California Santa Barbara and back to the walls of my studio in Easton. I had made the break (which took me about 15 years) to move from direct observation of nature to non-objective field painting. During this period of painting, I made the initial exciting observation that my work had discernible underlying algorithms–which led to coding some studies of the paintings and ultimately to my current iteration of existence.

Today, looking back at some of these painting propped up on the edge of my couch, I immediately saw parametrized functions, class definitions, code libraries–beyond just algorithms I saw entire systems. It made me want to retrieve my easel from the garage, set it up in our sun room and begin painting again–as a type of software specification. My current impulse was to begin categorizing the paintings in terms of instance fields and methods (classes)–to create a library of painting definitions.

I may do this and report back.

Number of Processing users, every four weeks, since 2005:

Long version: this is a tally of the number of unique users who run the Processing environment every four weeks, as measured by the number of machines checking for updates.

Of note:

• In spite of the frequently proclaimed “death of Java” or “death of Java on the desktop,” we’re continuing to grow. This isn’t to say that Java on the desktop is undead, but this frustrating contradiction presents a considerable challenge for us… I’ll write more about that soon.
• There’s a considerable (even comical) dip each January, when people decide that the holidays and drinking with their family is more fun than coding (or maybe that’s only my household). Things also tail off during the summer into August. These two trends are amplified due to the number of academic users, however other data I’ve seen (web traffic, etc) suggests that the rest of the world actually operates on something like the academic calendar as well.

About the data:

• This is a very conservative estimate of the number of Processing users out there. Our software is free — we don’t have a lot to gain by inflating the numbers.
• This covers only unique users — we don’t double count the same person in each 4-week period. Otherwise our numbers would be much higher.
• This is not downloads, which are also significantly higher.
• This is every four weeks, not every month. Unless there are 13 months in a year. Wait, how many months are in a year?
• This only covers people who are using the actual Processing Development Environment — no Eclipse users, etc.
• Use of processing.js or spinoff projects are not included.
• This doesn’t include anyone who has disabled checking for updates.
• This doesn’t include anyone not connected to the net.
• The unique ID is stored in the preferences.txt file, so if a single login is used on a machine, that’s counting multiple people. Conversely, if you have multiple machines, you’ll be counted more than once.
• Showing the data by day, week, or year all show the same overall trend.

This is a pretty lame visualization of the numbers, and I’m not even showing other interesting tidbits like what OS, version, and so on are in use. Maybe we can release the data if we can figure out an appropriate way to do so.

Exciting news! The short story is that there’s a new Processing Plug-in for Eclipse, and you can learn about it here.

The long story is that Chris Lonnen contacted me in the spring about applying for the Google Summer of Code (SoC) program, which I promptly missed the deadline for. But we eventually managed to put him to work anyway, via Fathom (our own SoC army of one, with Chris working from afar in western New York) with the task of working on a new editor that we can use to replace the current Processing Development Environment (the PDE).

After some initial work and scoping things out, we settled on the Eclipse RCP as the platform, with the task of first making a plug-in that works in the Eclipse environment (everything in Eclipse is a plug-in), which could then eventually become its own standalone editor to replace the current PDE.

Things are currently incomplete (again, see the Wiki page for more details), but give it a shot, file bugs (tag with Component-Eclipse when filing), and help lend Chris a hand in developing it further. Or if you have questions, be sure to use the forum. Come to think of it, might be time for a new forum section…

This piece from Niklas Roy made me laugh out loud:

Built with Processing and AVR-GCC.

(Thanks to Golan, who pointed out this link.)

Casey and I are in Chicago this weekend for the Processing+Android conference at UIC, organized by Daniel Sauter. In our excitement over the event, we posted revision 0191 last night (we tried to post from the back of Daniel’s old red Volvo, but Sprint’s network took exception). The release includes several Android-related updates, mostly fixed from Andres Colubri to improve how 3D works. Get the download here:

http://processing.org/download/ (under pre-releases)

Also be sure to keep an eye on the Wiki for Android updates:
http://wiki.processing.org/w/Android

(By the time you read this, there may be newer pre-releases like 0192, or 0193, and so on. Use those instead.)

Release notes for the 0191 update follow. And we’ll be doing a more final release (1.3 or 2.0, depending) once things settle a bit.

Processing Revision 0191 – 30 September 2010

Bug fix release. Contains major fixes to 3D for Android.

[ changes ]

+ Added option to preferences panel to enable/disable smoothing of text inside the editor.

+ Added more anti-aliasing to the Linux interface. Things were downright ugly in places where defaults different from Windows and Mac OS X.

[ bug fixes ]

+ Fix a problem with Linux permissions in the download.
http://code.google.com/p/processing/issues/detail?id=343

+ Fix ‘redo’ command to follow various OS conventions.
http://code.google.com/p/processing/issues/detail?id=363
Linux: ctrl-shift-z, macosx cmd-shift-z, windows ctrl-y
http://en.wikipedia.org/wiki/Table_of_keyboard_shortcuts
http://developer.apple.com/mac/library/documentation/

+ Remove extraneous console messages on export.

+ When exporting, don’t include a library multiple times.

+ Fixed a problem where no spaces in the size() command caused an error.
http://code.google.com/p/processing/issues/detail?id=390

[ andres 1, android 0 ]

+ Implemented offscreen operations in A3D when FBO extension is not available
http://code.google.com/p/processing/issues/detail?id=300

+ Get OpenGL matrices in A3D when GL_OES_matrix_get extension is not available
http://code.google.com/p/processing/issues/detail?id=286

+ Implemented calculateModelviewInverse() in A3D
http://code.google.com/p/processing/issues/detail?id=287

+ Automatic clear/noClear() switch in A3D
http://code.google.com/p/processing/issues/detail?id=289

+ Fix camera issues in A3D
http://code.google.com/p/processing/issues/detail?id=367

+ Major fixes for type to work properly in 3D (fixes KineticType)
http://code.google.com/p/processing/issues/detail?id=358

+ Lighting and materials testing in A3D
http://code.google.com/p/processing/issues/detail?id=294

+ Generate mipmaps when the GL_OES_generate_mipmaps extension is not available.
http://code.google.com/p/processing/issues/detail?id=288

+ Finish screen pixels/texture operations in A3D
http://code.google.com/p/processing/issues/detail?id=298

+ Fixed a bug in the camera handling. This was a quite urgent issue, since affected pretty much everything. It went unnoticed until now because the math error canceled out with the default camera settings.
http://forum.processing.org/topic/possible-3d-bug

+ Also finished the implementation of the getImpl() method in PImage,  so it initializes the texture of the new image in A3D mode. This makes the CubicVR example to work fine.

[ core ]

+ Fix background(PImage) for OpenGL
http://code.google.com/p/processing/issues/detail?id=336

+ Skip null entries with trim(String[])

+ Fix NaN with PVector.angleBetween
http://code.google.com/p/processing/issues/detail?id=340

+ Fix missing getFloat() method in XML library

+ Make sure that paths are created with saveStream(). (saveStream() wasn’t working when intermediate directories didn’t exist)

+ Make createWriter() use an 8k buffer by default.