A few weeks ago Anthony and I had a discussion about some of our frustrations with modern software interfaces. The interesting thing was that we had both been thinking about it from completely different angles. Whereas Anthony was thinking about how users are being forced to plunge in and out of interfaces in order to excavate the information they needed, I had recently noticed some very elegant examples of interfaces that “surfaced” pertinent data.
Hot and Cold
While I agree that business operations is certainly an important place where spelunking is causing irritation, inefficiency, and loss of productivity, it is hardly the only one. These same dynamics are playing themselves out in the personal device arena, but more rapidly. What is interesting about the smart phone and tablet field is that the incredibly competitive market is forcing rapid change. Things happen there in a matter of weeks versus the glacial years that enterprise applications can take to evolve. I think the enterprise market could learn a lot by looking at the most recent crop of tablets and how they manage information.

Uh oh, here comes the geek talk
Before we start comparing tablets and smartphones, I think we should take a few minutes to examine a fascinating cycle we are repeating in the world of human/computer interaction. What we are seeing is the sunset of the era of bloated PC applications and the return to smaller linked utilities. Understanding this interaction cycle is important when we discuss what’s happening now. Let me start by dissecting one of the oldest, and most elegant interactions I think I’ve seen in computing:
$bash: cat log.txt | uniq | grep acct | grep smith | less
I realise that most readers were lost at the dollar sign above, so I’ll take a few minutes to explain. You see, way back in the salad days of computing when UNIX ruled information systems, you had to be able to process data using a set of tiny little applications. Like itty bitty versions of Rain Man, these applications could only do one thing each but they did it very well and very fast.
By stringing them together and having them pass information to each other you could accomplish very complex tasks in a short time frame. You used something called a “pipe” to do this, which was symbolized by the vertical line between the applications. So if I change the above command line into everyday English it would look something like this:
1. Program “cat” - read the file “log.txt” and pass the information to the application “uniq”
2. Program “uniq” - remove any duplicate lines from the file and hand the output to the application “grep”
3. Program “grep” - find every line that contains “acct”, then pass the information back to yourself and search the results for “smith”, then hand the results off to the application “less”
4. Program “less” - display the results on screen
Everything old is new again
The end result was a short list of entries in a log from a guy named “smith” in the accounting department. Crazy huh? Seems complicated and frankly it was. Learning the thousands of little applications and the proper order to combine them in took years of experience. But mastering the most common 20 or so made you a pretty powerful user.
But think about how amazingly powerful a scenario like that would be if you didn’t have to memorize anything!
The truth is, we live in that world now with the tiny apps available for our smart phones/tablets like the iPhone/iPad and the Android based competitors. Moreover, the concept of passing information between these specialized apps for further processing is returning. If we were listening to users over the last decade we would have heard them screaming for this every time they moaned “I just want to be able to get my email!”.
Rain Man 2.0
Thankfully, the small form factor, interface limitations, and lack of input options in smartphones forces designers to question everything in interface design. How do you handle selections when the cursor is as big as a fingertip and the screen as small as the palm of your hand? How do we input data without a keyboard? But the most important question that has arisen lately is this:
What is the interaction length tolerance? - Or in everyday terms, how long can an interaction take before users lose patience with it?
What we are discovering is that the answer is “short”. A small screen, limited input options, and mobile use means that typical interactions need to be less than 30 seconds. This is typically driven by when people choose to use their mobile, such as while walking or in between other activities. There is also a higher degree of concentration because of the dexterity required. The demand for this means that applications have to be small and focused on doing one task well, just like the little “Rain Men” of yore. It also brings forth a central concept in interface design - surfacing.
Coming up for air, finally
Surfacing means that designers are paying attention to the data that users are most commonly accessing and they are bringing this information up to the earliest point of interaction. Executive dashboards are a good example of this in enterprise software and the iGoogle reader is a fantastic example being driven out in the web space. Instances of this are springing up everywhere from dashboards, to RSS, and desktop gadgets. These innovations are all seeking to help users alleviate the stress and time loss required by spelunking.
I’m frankly stunned that Apple has done such a poor job of noticing this need and addressing it. If you look closely at the iPad and iPhone interfaces you will notice that information is poorly surfaced, or not surfaced at all! The time, wireless status and battery status are always seen, but other lifestyle critical items like email status etc are buried! This is because Apple adapted a launcher metaphor for these devices, rather than a desktop one. They also focused on items that communicated the device status, but not lifestyle and communications status. This was a serious mistake in my opinion. The only visual indication of new email is a number badge attached to the icon or a modal dialog box that pops up over your current activity. This is a loss of persistence and a disruption. Viewing email requires you to launch the application, and within the application you touch the inbox button to get an overview of the inbox. The iPad app gives you a limited scanning capability for mail in your inbox, and the iPhone gives you none at all. Overall you find yourself spelunking for the app, spelunking the app, then spelunking within the app. You’ve used up more than half of your interaction length tolerance right there. Ouch.

The limited iPhone and iPad home screens
If you contrast this against the Android, you see a better implementation. The top bar serves as a universal indicator and alert space. This means that things you should be aware of remain visible, no matter what screen you are on, or if you are inside another application. In addition, by using a desktop metaphor the Android allows developers to create active widgets that users can place on any screen. These widgets can display any information that is contained within an application. Doing this allows important information to be available at a glance, requiring little, or no interaction at all. Interaction length is at an absolute minimum.


Widgets and universal notification bar in action on an Android Phone and Tablet
Can we talk?
The second, and equally crucial component of an interface that minimizes spelunking is a contextually aware application communication layer. In laymans terms, this is a component to the OS that allows applications to know about, and pass relevant information to each other. Think back to the original command line I showed and here we see the “pipe” resurrected! For instance, in most smartphones holding your finger on a phone number displayed on a web page will present you with several applications you can pass the information to.

You see this metaphor echoed in other applications, with voice search automatically knowing the names of your contacts and launching your address book entry for that person, rather than googling them. The contact list automatically absorbs and recasts metadata like Facebook connections and twitter information. So looking at someones contact information also shows your their last Twitter and Facebook updates, with one-click jumps to those apps.
Out into the sunlight
What the Android interfaces demonstrate is that when interaction designers and developers work together - users win. When developers create a platform that allows information to be flowed intuitively between applications, designers can create a more fulfilling, and intuitive interface that requires a lot less work on the part of the user. When you add in proper surfacing of relevant data in a timely manner, spelunking essentially stops.
As designers and developers we have an obligation to think about things like this. How and when we deliver information is as important as the information itself. In the end, the best interface is the one that users barely even notice. Information access is the goal, and unlike life it shouldn’t be the journey.