Writing

This here is a ghost town

This blog was created in 2008 and hasn’t been actively updated for several years.

For more recent work, please visit the Fathom site, where you can see current projects, or read the latest updates on what we’ve been up to.

For Processing Foundation work, please visit the site or check out our page on Github.

Tuesday, April 14, 2015 | site  

And speaking of height…

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.

(From The Economist, by way of Eva)

Tuesday, February 1, 2011 | finance, scale  

The importance of showing numbers in context

An info graphic from the Boston Globe:

measuring in shaq inches

Monday, January 31, 2011 | basketball, scale, sports  

Come work with us in Boston

Fathom Information Design is looking for developers and designers. Come join us!

We’re looking for people to join us at Fathom. For all the positions, you’ll be creating work like you see on fathom.info, plus more mobile projects (Android, iOS, JavaScript) and the occasional installation piece. If you’re a developer, design skills are a plus. Or if you’re a designer, same goes for coding.

  • 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.
  • Web Developer – In 1996, I used Java for my Computer Graphics 2 homework at Carnegie Mellon. I’ll never forget the look on the face of my professor Paul Heckbert (Graphics Gems IV, Pixar, and now Gigapan — a man who wrote an actual ray tracer in C code that fit on the back of a business card), when he asked me during office hours why this was a good idea. Your professor did the same thing when you told him (or her) that you’d be implementing your final project with JavaScript and Canvas. We need amazing things to happen with HTML, CSS, and JavaScript, and you’re the person to do it.
  • 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.

Monday, January 17, 2011 | opportunities  

Minnesota, meet Physics

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:

Sunday, December 12, 2010 | physical, simulation, water  

The growth of the Processing project

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

humbling and terrifying

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.

Tuesday, November 2, 2010 | processing  

Processing + Eclipse

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

twins!

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…

Tuesday, October 19, 2010 | processing  

When you spend your life doing news graphics…

…like Karl Gude has, then parking lots start to look like this:

179527385-500px

Tuesday, October 19, 2010 | mapping, news, perception  

Ever feel like there’s just a tiny curtain protecting your privacy online?

This piece from Niklas Roy made me laugh out loud:

Built with Processing and AVR-GCC.

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

Monday, October 18, 2010 | laughinglikeanidiotatyourcomputer, processing  

Already checked it in Photoshop, so you don’t have to

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.

prepare to have your mind blown. what's that? it already was?

The image is from Edward H. Adelson at MIT, and you can find my original source here. More details (proof, etc) on Adelson’s site here, which includes this explanation:

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.)

Sunday, October 17, 2010 | perception, science  

Processing 0191 for Android

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.

Friday, October 1, 2010 | processing  

Matthew Carter wins a MacArthur

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.

Tuesday, September 28, 2010 | typography  

Awesome now travels by poster tube

A few weeks ago I received a note from Ed Fries, who was interested in a distellamap-style print of his recently-finished Halo 2600.

Halo? Like the Xbox game by Bungie?

Why, yes! Sure enough, he’s written a version of the game for he Atari 2600.

You can play the game here, and if you don’t drown in the awesome (or die from laughing), you can now purchase prints here. Like the other distellamap prints, it shows how the image and code data coexist and interact inside an Atari 2600 cartridge games:

with all new colors!

A detail of what it looks like up close:

grab the key!

(And as with the other prints, proceeds are given to charity.)

Saturday, September 4, 2010 | distellamap, prints  

That wasn’t all he lost on his trip to Tiny

Trying to open an SVG with Illustrator, and she tells me this sad story…

shoulda listened to mom instead of the guys

Have a good Friday, everyone.

Friday, September 3, 2010 | thisneedsfixed  

Conveying multiple realities in research and journalism

A recent Boston Globe editorial covers the issue of multiple, seemingly (if obviously) contradictory statements that come from complex research, in this case around the oil spill:

Last week, Woods Hole researchers reported a 22-mile-long underwater plume that they mapped out in the Gulf of Mexico in June — a finding indicating that much more oil may lie deep underwater and be degrading so slowly that it might affect the ecosystem for some time. Also last week, University of Georgia researchers estimated up to 80 percent of the spill may still be at large, with University of South Florida researchers finding poisoned plankton between 900 feet and 3,300 feet deep. This differed from the Aug. 4 proclamation by Administrator Jane Lubchenco of the National Oceanic and Atmospheric Administration that three-quarters of the oil was “completely gone’’ or dispersed and the remaining quarter was “degrading rapidly.’’

But then comes the Lawrence Berkeley National Laboratory, which this week said a previously unclassified species of microbes is wolfing down the oil with amazing speed. This means that all the scientists could be right, with massive plumes being decimated these past two months by an unexpected cleanup crew from the deep.

This is often the case for anything remotely complex: the opacity of the research process to the general public, the communication skills of various institutions, the differing perspective between what the public cares about (whose fault is it? how bad is it?) versus the interests of the researchers, and so on.

It’s a basic issue around communicating complex ideas, and therefore affects visualization too — it’s rare that there’s a single answer.

sadness

On a more subjective note, I don’t know if I agree with the premise of the editorial is that it’s on the government to sort out the mess for the public. It’s certainly a role of the government, though the sniping at the Obama administration makes the editorial writer sound one who is equally likely to bemoan government spending, size, etc. But I could write an equally (perhaps more) compelling editorial making the point that it’s actually the role of newspapers like the Globe to sort out newsworthy issues that concern the public. But sadly, the Globe, or at least the front page of boston.com, has been overly obsessed with more click-ready topics like the Craigslist killer (or any other rapist, murderer, or stomach-turning story involving children du jour) and playing “gotcha” with spending and taxes for universities and public officials. What a bunch of ghouls.

(Thanks to my mother-in-law for the article link.)

Wednesday, September 1, 2010 | government, news, reading, science  

Scientific identification, ordering, & quantification of awesome

There may be many versions of the Periodic Table, but this is my favorite.

it's more fun to be a 10-year-old boy than a crusty old academic

The image was created by The Dapperstache, who has since updated the graphic, but I prefer this version with its bevel-crazy gradient awful.

Saturday, August 21, 2010 | infographics  

Fathom

Ben Fry LLC now has a proper name, and it is Fathom. Or if you want to be formal about it, “Fathom Information Design”.

And today we launched a new site, fathom.info, for our work. (I’ll still be using benfry.com for my older research projects, Processing updates, software and visualization ramblings, book updates…)

We also have a new project that launched yesterday with GE, this time looking at shifts in age within world populations. A little more info about it is on the Fathom updates page (some might call it a blog). And when we have a chance, we hope to post a bit more of the process behind the piece.

Friday, July 23, 2010 | fathom  

Processing 0187

New release available shortly in the pre-releases section of processing.org/download.

More bug fixes, and one new treat for OS X users. Hopefully we’re about set
to call this one 1.2. Please test and report any issues you find.

[ additions ]

+ On Mac OS X, you’re no longer required to have a sketch window open at
all times. This will make the application feel more Mac-like–a little
more elegant and trendy and smug with superiority.

+ Added a warning to the Linux version to tell users that they should be
using the official version of Java from Sun if they’re not.
http://wiki.processing.org/w/Supported_Platforms#Linux
There isn’t a perfect way to detect whether Sun Java is in use,
so please let us know how it works or if you have a better idea.

[ fixes ]

+ “Unexpected token” error when creating classes with recent pre-releases.
http://code.google.com/p/processing/issues/detail?id=292

+ Prevent horizontal scroll offset from disappearing.
Thanks to Christian Thiemann for the fix.
http://code.google.com/p/processing/issues/detail?id=280
http://code.google.com/p/processing/issues/detail?id=10

+ Fix NullPointerException when making a new sketch on non-English systems.
http://code.google.com/p/processing/issues/detail?id=283

+ Fixed a problem when using command-line arguments with exported sketches
on Windows. Thanks to davbol for the fix.
http://code.google.com/p/processing/issues/detail?id=303

+ Added requestFocusInWindow() call to replace Apple’s broken requestFocus(),
which should return the previous behavior of sketches getting focus
immediately when loaded in a web browser.
http://code.google.com/p/processing/issues/detail?id=279

+ Add getDocumentBase() version of createInput() for Internet Explorer.
Without this, sketches will crash when trying to find files on a web server
that are not in the exported .jar file. This fix is only for IE. Yay IE!

Monday, July 12, 2010 | processing  

Processing 0186

Mixed bag of updates as a follow-on to release 0185.

[ mixed bag ]

Android SDK requirement is now API 7 (Android 2.1), because Google has deprecated API 6 (2.0.1).

More Linux PDF fixes from Matthias Breuer. Thanks!

PDF library matrix not reset between frames. (Fixed in 0185.)
http://dev.processing.org/bugs/show_bug.cgi?id=1227

Updated the URLs opened by the software to reflect the new site layout.
http://code.google.com/p/processing/issues/detail?id=278

Updated the included examples with recent changes.

Friday, June 25, 2010 | processing  

Processing 0185

Just posted release 0185 of Processing on the download page. It’s a pre-release for what will eventually become 1.2 or 1.5. Please test and file bugs if you find problems. The list revisions are below:

PROCESSING 0185 – 20 June 2010

Primarily a bug fix release. The biggest change are a couple tweaks for problems caused by Apple’s Update 2 for Java on OS X, so this should make Processing usable on Macs again.

[ bug fixes ]

+ Fix for Apple bug that caused an assertion failure when requestFocus() was called in some situations. This was causing the PDE to become unusable for opening sketches, and focus highlighting was no longer happening.
http://code.google.com/p/processing/issues/detail?id=258
http://dev.processing.org/bugs/show_bug.cgi?id=1564
http://dev.processing.org/bugs/show_bug.cgi?id=1569

+ Fixed two bugs with fonts created with specific charsets.

+ Fix from jdf for PImage(java.awt.Image img) and ARGB images. The method “public PImage(java.awt.Image)” was setting the format to RGB (even if ARGB)

+ Large number of beginShape(POINTS) not rendering correctly on first frame
http://dev.processing.org/bugs/show_bug.cgi?id=1572

+ Fix for PDF library and createFont() on Linux, thanks to Matthias Breuer.
http://dev.processing.org/bugs/show_bug.cgi?id=1566

+ Fix from takachin for a problem with full-width space with Japanese IME.
http://dev.processing.org/bugs/show_bug.cgi?id=1531

+ Reset matrix for the PDF library in-between frames also added begin/endDraw between frames
http://dev.processing.org/bugs/show_bug.cgi?id=1227

[ additions ]

+ Add the changes for “Copy as HTML” to replace the “Copy for Discourse” function, now that we’ve shut down the old YaBB discourse board.
http://code.google.com/p/processing/issues/detail?id=271

+ Option to disable re-opening sketches when you start Processing. The default will stay the same, but if you don’t like the feature, alter your preferences.txt file to change:
last.sketch.restore=true
to the following:
last.sketch.restore=false
The issue was originally filed here:
http://dev.processing.org/bugs/show_bug.cgi?id=1501
http://code.google.com/p/processing/issues/detail?id=245
However the main problem with this is that due to other errors, the wrong sketches are being opened, sketches are sometimes forgotten, or windows are opened concurrently on top of one another, creating a bad situation:
http://code.google.com/p/processing/issues/detail?id=177
http://code.google.com/p/processing/issues/detail?id=179
Those bugs are not yet fixed, but will be addressed in future releases.

+ Option to change the default naming of sketches via preferences.txt.
First, you can change the prefix, which defaults to:
editor.untitled.prefix=sketch_
And the suffix is handled using dates. The current default (since 1.0) is:
editor.untitled.suffix=MMMdd
Or if you want to switch back to the old (six digit) style, you could use:
editor.untitled.suffix=yyMMdd
http://dev.processing.org/bugs/show_bug.cgi?id=1091

+ Updated bundled JRE/tools to 6u20 for Windows and Linux

+ Several SVG fixes and additions, including some tweaks from PhiLho. These changes will be documented in a future release once the API changes are complete.

+ Added option to launch a sketch directly w/ linux. Thanks to Larry Kyrala.
http://dev.processing.org/bugs/show_bug.cgi?id=1549

+ Pass actual exceptions from InvocationTargetException in registered methods, which improves how exceptions are reported with libraries.

+ Added loading.gif to the js version of the applet loader. Not sure if this is actually working or not, but it’s there.

[ android ]

+ Added permissions for INTERNET and WRITE_EXTERNAL_STORAGE to the default AndroidManifest.xml file. This will be addressed in greater detail here:
http://code.google.com/p/processing/issues/detail?id=275
And with the implementation of code signing here:
http://code.google.com/p/processing/issues/detail?id=222

+ Lots of work happening underneath with regards to Android, more updates soon as things start evening out a bit.

+ Defaulting to a WVGA screen for the default Processing AVD.

Monday, June 21, 2010 | processing  
Older Posts »
Book

Visualizing Data Book CoverVisualizing 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.

Archives