This blog was created in 2007 and hasn’t been actively updated for several years.
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).
+ Incorrect tab/line shown for preprocessor errors when more than 2 tabs
+ Commenting via menu or shortcut does not set sketch to “need save”
+ IDE Export Application button exports applet (fixed in 2.0a2)
[ core ]
+ Fix for video frames not showing up in 3D.
+ Rounded rect() does not have a maximum length for corner radius
[ android ]
+ Fix libraries when used with Android. Libraries can also specify
an Android version by including an ‘android’ subfolder.
+ 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)
+ Improve launching with the emulator.
+ Remove ‘includeantruntime’ warning during build.
+ “Date could not be parsed” error.
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
+ ‘unexpected token void’ for any type of error (due to fallback)
+ 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
+ Move library examples to the examples menu
+ Ctrl-slash not working on Linux (fix from pkalauskas, thanks!)
+ Update to Java 6u24 for Linux and Windows
+ Export .java source files with applets and applications.
+ Reference broken in 0194.
+ Other reference tweaks
+ Fix exception spew when clicking between editor windows.
+ Don’t reload sketch on “save as”
+ 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
+ “No library found” message when using import statements and the code folder
+ Remove version number from splash image
+ Subfolders in /libraries folder not supported in 0194,
bring them back for toxi and the toxiclibs folks.
[ 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)
+ normal() command commented out in sphere() method
+ save() and other pixel operations no longer working with JAVA2D in 0194
[ android ]
+ point() doesn’t render in A3D
+ Android stuck at “Starting Build”
+ Deal with missing android-core.zip (No such file or directory)
+ Error messages about “No library found for android.*”
+ When returning to android application, sometimes screen stays black
+ Device Killed or Disconnected Error Message with Libraries
+ 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
Another wonderful example, more powerful as words than as an image:
Jan Pen, a Dutch economist who died last year, came up with a striking way to picture inequality. Imagine people’s height being proportional to their income, so that someone with an average income is of average height. Now imagine that the entire adult population of America is walking past you in a single hour, in ascending order of income.
The first passers-by, the owners of loss-making businesses, are invisible: their heads are below ground. Then come the jobless and the working poor, who are midgets. After half an hour the strollers are still only waist-high, since America’s median income is only half the mean. It takes nearly 45 minutes before normal-sized people appear. But then, in the final minutes, giants thunder by. With six minutes to go they are 12 feet tall. When the 400 highest earners walk by, right at the end, each is more than two miles tall.
Fathom Information Design is looking for developers and designers. Come join us!
- Developer – Looking for someone with a strong background in Java, and some C/C++ as well. On Monday this person would be sorting out more advanced aspects of a client project. On Tuesday they would hone the Processing Development Environment, mercilessly crushing bugs. On Wednesday they would refactor critical visualization tools used by brilliant scientists. On Thursday they could put out a fire in another client project without breaking a sweat, and on the fifth day, they would choose what we’re having for Beer Friday. This messiah also might not mind being referred to in the third person.
- Junior Designer – You’ve finished your undergrad design program and feel the need to make beautiful things. Your commute is spent fixing the typography in dreadful subway ads (only in your head, please). You are capable of pixel-level detail work to get mobile apps or a web site just right. And if we’re lucky, you’re so good with color that you’ve been mistaken for an impressionist painter.
- Senior Designer – So all that stuff above that the Junior Designer candidate thinks they can do? You can actually do it. And more important, you have the patience and humility to teach it to others around you. You’re also an asset on group projects, best friends with developers, and adored by clients.
At the moment, we’re only looking for people located in (or willing to relocate to) the Boston area.
Please send résumé or CV, links to relevant work, and cover letter to inquire (at) fathom (dot) info. Please do not write us individually, as that may void your contest entry.
The roof of the Metrodome springs a leak following heavy snow in Minnesota:
I’ve been looking at too many particle and fluid dynamics simulations because it looks fake to me — more like a simulation created by the structural engineers of what would happen if the roof were to collapse — rather than thousands of pounds of honest-to-goodness midwestern snow pummeling the turf seemingly in slow motion. Beautiful.
And another version from a local FOX affiliate in Minnesota:
Date: January 12–13, 2011
Time: 9 am to 5 pm
Location: Harvard University
Tuition: $1,900. After December 20: $2,200
Class size is limited.
The amount and complexity of information produced in science, engineering, business, and everyday human activity is increasing at staggering rates. This program introduces you to visual representation methods and techniques that increase the understanding of complex data. Good visual interpretations of data improve comprehension, communication, and decision making.
What you will learn
- How visual representations help in the analysis and understanding of complex data
- How the human visual system processes and perceives images
- How to critique visualizations and identify the design principles used to create them
- Good design practices for visualization
- Various visualization approaches for different data types
- Design principles
- Statistical graphs
- Trees and networks
- High-dimensional data
- Visualization tools
Who should enroll
Professionals or academics who need to analyze and present complex information in an easily digestible manner benefit from this program. The program is open to anyone who is interested in the visual analysis of data. You should have a basic knowledge of how to use computers and the Internet.
You are encouraged to bring a wireless laptop.
Hanspeter Pfister is Gordon McKay Professor of the Practice of Computer Science in the School of Engineering and Applied Sciences at Harvard. His research lies at the intersection of visualization, computer graphics, and computer vision. It spans a range of topics, including scientific visualization, point-based graphics, appearance acquisition, GPU computing, and 3D displays. Pfister also offers his semester-long courses online at Harvard Extension School, where he won the Petra T. Shattuck Excellence in Teaching Award in 2009.
Before joining Harvard he worked at Mitsubishi Electric Research Laboratories as an associate director and a senior research scientist. Pfister has a PhD in computer science from the State University of New York at Stony Brook and a master’s in electrical engineering from the Swiss Federal Institute of Technology, Zurich.
Should be great!
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.
- 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…
I wasn’t going to post this one, but I can’t get it out of my head. In the image below, the squares marked A and B are the same shade of gray.
The visual system needs to determine the color of objects in the world. In this case the problem is to determine the gray shade of the checks on the floor. Just measuring the light coming from a surface (the luminance) is not enough: a cast shadow will dim a surface, so that a white surface in shadow may be reflecting less light than a black surface in full light. The visual system uses several tricks to determine where the shadows are and how to compensate for them, in order to determine the shade of gray “paint” that belongs to the surface.
The first trick is based on local contrast. In shadow or not, a check that is lighter than its neighboring checks is probably lighter than average, and vice versa. In the figure, the light check in shadow is surrounded by darker checks. Thus, even though the check is physically dark, it is light when compared to its neighbors. The dark checks outside the shadow, conversely, are surrounded by lighter checks, so they look dark by comparison.
A second trick is based on the fact that shadows often have soft edges, while paint boundaries (like the checks) often have sharp edges. The visual system tends to ignore gradual changes in light level, so that it can determine the color of the surfaces without being misled by shadows. In this figure, the shadow looks like a shadow, both because it is fuzzy and because the shadow casting object is visible.
The “paintness” of the checks is aided by the form of the “X-junctions” formed by 4 abutting checks. This type of junction is usually a signal that all the edges should be interpreted as changes in surface color rather than in terms of shadows or lighting.
As with many so-called illusions, this effect really demonstrates the success rather than the failure of the visual system. The visual system is not very good at being a physical light meter, but that is not its purpose. The important task is to break the image information down into meaningful components, and thereby perceive the nature of the objects in view.
(Like the earlier illusion post, this one’s also from my mother-in-law, who should apparently be writing this blog instead of its current—woefully negligent—author.)
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:
(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.
+ Fix ‘redo’ command to follow various OS conventions.
Linux: ctrl-shift-z, macosx cmd-shift-z, windows ctrl-y
+ 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.
[ andres 1, android 0 ]
+ Implemented offscreen operations in A3D when FBO extension is not available
+ Get OpenGL matrices in A3D when GL_OES_matrix_get extension is not available
+ Implemented calculateModelviewInverse() in A3D
+ Automatic clear/noClear() switch in A3D
+ Fix camera issues in A3D
+ Major fixes for type to work properly in 3D (fixes KineticType)
+ Lighting and materials testing in A3D
+ Generate mipmaps when the GL_OES_generate_mipmaps extension is not available.
+ Finish screen pixels/texture operations in A3D
+ 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.
+ 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
+ Skip null entries with trim(String)
+ Fix NaN with PVector.angleBetween
+ 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.
I’m really happy to see typographer Matthew Carter receive a well-deserved MacArthur “Genius” Grant. A short video:
Very well put:
I think they’re saying to me, “You’ve done all this work. Well done… Here’s an award, now do more. Do better.” And it’s very nice, at my age, to be told by someone, that “we expect more from you. And here’s the means to help you achieve that.”
And if you’re not familiar with Carter’s name, you know his work: he created both Verdana and Georgia, at least one of which will be found on nearly any web site (the text you’re reading now is Georgia). Microsoft’s commission of these web fonts helped improve design on the web significantly in the mid-to-late 90s. Carter also developed several other important typefaces like Bell Centennial (back in the 70s), the tiny text found in phone books.
Visualizing Data is my book about computational information design. It covers the path from raw data to how we understand it, detailing how to begin with a set of numbers and produce images or software that lets you view and interact with information. Unlike nearly all books in this field, it is a hands-on guide intended for people who want to learn how to actually build a data visualization.
The text was published by O’Reilly in December 2007 and can be found at Amazon and elsewhere. Amazon also has an edition for the Kindle, for people who aren’t into the dead tree thing. (Proceeds from Amazon links found on this page are used to pay my web hosting bill.)
Examples for the book can be found here.
The book covers ideas found in my Ph.D. dissertation, which is basis for Chapter 1. The next chapter is an extremely brief introduction to Processing, which is used for the examples. Next is (chapter 3) is a simple mapping project to place data points on a map of the United States. Of course, the idea is not that lots of people want to visualize data for each of 50 states. Instead, it’s a jumping off point for learning how to lay out data spatially.
The chapters that follow cover six more projects, such as salary vs. performance (Chapter 5), zipdecode (Chapter 6), followed by more advanced topics dealing with trees, treemaps, hierarchies, and recursion (Chapter 7), plus graphs and networks (Chapter 8).
This site is used for follow-up code and writing about related topics.
- April 2015
- November 2011
- April 2011
- February 2011
- January 2011
- December 2010
- November 2010
- October 2010
- September 2010
- August 2010
- July 2010
- June 2010
- May 2010
- April 2010
- March 2010
- February 2010
- January 2010
- November 2009
- October 2009
- September 2009
- August 2009
- July 2009
- June 2009
- May 2009
- April 2009
- March 2009
- February 2009
- January 2009
- December 2008
- November 2008
- October 2008
- September 2008
- August 2008
- July 2008
- June 2008
- May 2008
- April 2008
- March 2008
- February 2008