kip/bot/blog

Note: The app’s designer, coder, all-around maker, responded in his blog. Some additional comments, responses to this post, in a later post.

I just downloaded the Pennant iPad app. While connected to the internet, this app lets you look at every play of every game of professional baseball going back to 1951. It’s gotten glowing reviews from Wired and other places with praise for its “rich interface” and all the fun they bring to stats. I was stoked to buy it — I like reading about baseball more than watching it, I loves me my data, and I was genuinely happy with the Jazz app, which has a similar visual language and navigation tropes.

Sadly, Pennant is just prettied up data, prettied up so much that it underperforms the highly evolved system of box scores and the recent and insufficiently explored sparklines of Edward Tufte. It’s also loaded with some bad usability posing as visualization.

The first problem comes with the app designers’ attachment to cover flow. I’ve never been a big fan of cover flow, finding it imprecise for task completion, and way too low in information density for exploration of anything larger than 20 items. In Pennant, it’s a real waste of space and a strange distortion of a timeline.

The colors are meaningless and confusing, the covers themselves add nothing to the exploration (might be nice to have the jerseys to differentiate between the different iterations of the Giants, or some basic information about team founding, league, or notable players — anything beyond text to justify a visual treatment). Worse, they don’t even show enough items, requiring extra work to get around. While I dislike it, at least the iTunes version previews information and provides more:

The cover flow fixation obscures the drill-downs in the experience as well. This is a screenshot of the 1981 Pirates season:

The real information is the line across the bottom of the screen, but the cover, which simply confirms the user’s choice and serves as an over-sized title, dominates. The line across the bottom of the screen is also problematic — the individual data points are hard to pinpoint, as an adult fingertip can actually touch three at a time and the finger obscures your sight line. (It’s also a repetition of the cover flow above, but with the added, and admittedly useful though inefficiently executed, depiction of the average.)

This disregard for information and usefulness is pretty much the problem with the whole app. At a brisker pace, some screenshots and critiques:

Maps are possibly the most abused data visualization techniques out there. To make room for the map, you have to shrink the actual data (team names) to pin points. And for what? Spatial relationships? For this particular data set, maps actually create confusion – if you don’t remember that a team moved, or simply want to find the team name in that cluster of points in the northeast, or you don’t really consider the renaming of the Angels as different teams in the same way you think of the Brooklyn Dodger and LA Dodgers as being different.

This is the one that most people praise. It sure looks nifty, and you need code to draw it and do the transition, but why a circle? Usually the stats are listed in proximity and tell a quick story, and are clumped in ways that tell interesting stories. Here, all you have are wedges next to each other, forcing you to spatially assess the relative stats. Worse, they’ve got cumulative stats (number of walks, hits, runs) intermixed with percentage stats (OBP and AVG). Worse than useless, this actually reduces the clarity and usefulness of the data. (The pitching one is a drag too. A standard measure is strike out to walk ratios and you don’t even have the numbers and the shapes that might make for comparison are on opposite sides of the wheel.)

The most difficult thing about the screen is that, at its core, it’s a pie graph. There is a set of wedges indicating some proportional relationship with the other items, further implying that how far out it radiates is an extra dimension. None of these implied relationships, basic knowledge for an adult reader, is delivered on, thus frustrating user expectations.

Quick hit here: the win loss line on the bottom is hard to access (see adult finger stuff above) and the representation makes the Loss look like half of a Win, not the opposite. Compare to a Tuftean style presentation:

Here, the color pops for winning and losing streaks, and you get a sense of home and away performance. And, oh yeah, you have summary data at the end of the line.

I have no idea what they were thinking with this one. And, yes, you can move the bubbles around – and get absolutely nothing out of it.

The most annoying of all. This is the meat of the experience, the play-by-play, the true fan’s recreation of the great moments in baseball. Why a circle? Is there something full-circle about the game? What happens to the already maddening smallness of the lines when you go into extra innings? The metaphor dominates at the expense of the information and the narrative.

It gets weirder when you set it to play:

The weirdness comes in a couple places. First, all of the lines from the earlier screen are made the same length when it turns into a wheel. All you have now is the number of at bats and a preview that the last out is happening. The second is that, by ticking off the plays individually, you actually lose the narrative that would come with the list. In this case, Gary Carter tripled, but there’s no context – how many men on base, how many outs, what’s the score, how long has the pitcher been in? These are the moments that make individual plays dramatic. But, by putting the display at the service of the interface metaphor, the events are reported with no context and no outcome (which a list of plays would have allowed the user to put together, and which newspaper scorecards fill in).
Enough of the hating. A quick note about how good infographics are pleasing to the eye, engage you in conversation and add to the story the data tells.

Tufte shows cleaner, higher-resolution versions in his book, but I chose the larger, jaggier one to highlight the point. This graphic shows the pattern of a teams season, it visualizes, surges and slumps, shows tight races, conveys the hopelessness of being a fan for some teams and it has data.

Pennant is mostly chartjunk. Sad, but maybe there will be other efforts, as the data isn’t exclusive.

One of the most dangerous, and therefore regrettable, books floating around in the various design-related industries is John Maeda’s Laws of Simplicity. The book is actually great, but in the category of “Learn it in 120 Pages” and “x Rules to Success” books, this is probably the one that creates the most dangerous reflexes. By fetishizing simplicity, we’ve turned it into a weasel word. The success of nearly everything can be attributed to simplicity. Anyone in a meeting can say “let’s make it more simple” and have it pass as useful, insightful, or designery. The trickiest reflex, though, is achieving simplicity by cutting — cutting words, cutting features, cutting links or buttons, and, eventually reducing the overall quality and enticement of the product or experience.

What’s interesting, though, is that Maeda actually tries to prevent this and other reflexes. In the book, Maeda offers a simplicity acronym: S/H/E standing for Shrink, Hide, and Embody. Three paths to simplicity, but only one of them actually suggests cutting. The others suggest design — balancing, trading off, managing form, function, levels of attention, lines of sight and cognition. They suggest it in a way that pulls you into interesting design ideas like paced layering, and which remind us that people use things more than once and that you win when the things actually get better over time (ie, discovering a new feature, finding your own shortcuts, optimizing and customizing, anticipating how it feels.)

In his TED talk, Maeda takes people in a direction that is much more productive. At 2:30 into the talk he points out that simplicity isn’t really what we crave and proves it nicely with pictures of a sunset. The simplest sunset is a 41% grey one:

It’s nice, but not that exciting, not what you want to sit on the deck and watch for an hour. Instead, this is what we love:

Nothing simple about that one but it’s what we <3. Why? Complex thing are interesting, they have crunch, they engage many parts of the brain emotionally and intellectually, they fascinate as they change over time even if they remain static, like a piece of recorded music. (This is familiar territory for fans of Steven Johnson's Everything Bad is Good for You which has great demonstrations of how we have, over the years, come to demand more complex material and plotlines and characters in TV.)

So what are we getting at? Is there a way out of the pendulum swing of shrinking and adding and shrinking and adding?

One answer was inspired by a passage I read in Mark Frauenfelder’s Made by Hand where he talk about the process of seeking “complexity out of chaos”. It’s a nice phrase in that it highlights differences between chaos, complication, complicatedness, and complexity. Complication is something no one would ever seek — in fact, it’s a much better word to contrast with simplicity. But saying people crave complexity is a little risky — complexity, as a word, doesn’t connote something virtuous. But richness does. People seek things that are rich — things that go somewhere, are worth revisiting (re-reading, re-listening, re-watching, re-thinking in your head, re-ferencing in conversation, making into a metaphor or analogy), things that yield nuance, depth, and new truths and emotions on longer, sustained watching — like a song that builds to a part you love, or the build-up to a great line in a movie.

So you could look at the goal like this:

People want the richness that comes from exploring complex things, but want to avoid complication. So it’s tempting to do this:

Make simplicity out of richness! But that takes design too far — simplifying richness puts a narrowing word too close to the expansive. I would argue that it’s better to think of simplicity as an interface to richness:

This puts you in a place of thinking about designer-y things like affordance, pace, multiple use, conceptual portability (if you’re writing), clear prose, rich metaphor in simple language, use of symbols.

Create richness out of complexity, provide simplicity as an interface to it. Don’t be simple.

Only possible down-side: reminds people that your emails are being parsed for all sorts of reasons. Still, saved me from having to do a “Doh! Here’s the attachment” note.