Mobile gestures are all the rage and at the same time, its almost like no one cares. Don Norman wrote a post about them on LinkedIn: Gestural Control: The Good, The Bad and The Ugly.
He pointed out that patenting gestures is causing a significant amount of problems. We can’t standardize across operating systems and platforms because everything is proprietary and users have to learn too many things. So what do users do? They don’t learn anything and do what is familiar and comes naturally.
He also pointed out:
Well, gestures are the new form of command-line interfaces. They have to be memorized. Worse, they lack the power of the old command lines. We went from far too many alternatives and commands of menu-based systems to the highly oversimplified capabilities of today’s gesture systems.
And it is true. Gestures aren’t intuitive or easy to use.
But this brings up the discussion around intuitive interfaces being more familiar interfaces that Jef Raskin addressed long ago:
From this and other observations, and a reluctance to accept paranormal claims without repeatable demonstrations thereof, it is clear that a user interface feature is “intuitive” insofar as it resembles or is identical to something the user has already learned. In short, “intuitive” in this context is an almost exact synonym of “familiar.” – Jef Raskin http://www.asktog.com/papers/raskinintuit.html
And I agree with Raskin. Most of what we consider intuitive is designed based on what we know and understand – what is familiar.
Are menu systems intuitive? They are today because they have been in use for over 30 years – and heck, they beat memorizing command lines. Using user-centric design, would we have chosen to use a menu system? That’s the million dollar question.
Minority Report creates a fantastic dramatic moment when Tom Cruise flips through screens and video at the police station. It was like watching him dance – just great drama. But I had to wonder – is this intuitive?
Swiping is intuitive because it resembles how we turn a page (flip a corner and push it to the left). Tap is familiar because we do that with a mouse when we select something onscreen.
Are we literally using a finger to replicate what we do with a mouse? Yes.
Do we know what types of gestures would make sense for users? I don’t think so. There needs to be research about gestures and what makes sense. We have been told by software companies and engineers which gestures we should use to complete certain actions – the gesture language is being defined for us rather than by us.
But this trend is changing…
I met with RoamTouch a couple of weeks ago, and they make GestureKit.
GestureKit is a tool for a designer or developer to quickly create new gestures and implement them outside of an operating system.
What’s wonderful about the tool is that it is breaking through conventions to allow people to create gestures with just an easy to use GUI. Once the gesture is created with fingers onscreen, the system then creates code for the developer to include in an app or site. Once the code is integrated, the gestures are available for immediate use.
Here’s a video that gives you more details and a demo:
In many ways, RoamTouch’s approach is revolutionary in computing – about as revolutionary as Linus Torvalds’s approach with Linux. It is also similar to what social media is doing to publishing. They are moving gesture creation out of a dictatorial model (the engineers/technology companies) into a social model (for the users, by the users).
According to their blog (by Nico and Ning),
We therefore believe that gestureKit has the potential to drive this change that is much needed in the industry, not by imposing a set of standards, but rather by creating and nurturing the perfect environment where these can emerge and grow into widely adopted and recognized patterns.
During our meeting, we discussed how gestures are like a language – and languages are not created by individuals or organizations but organically within a group of people. And then language becomes intuitive because it is integrated within that group’s experiences and culture. I’ll go into this more in another post because it really is its own discussion.
So let’s say you create new gestures in your app or site. This raises the questions:
- How would users know what the new new gestures are?
- How would users know that they exist?
RoamTouch is aware of this challenge and has a few ideas/suggestions to solve the issue – help areas, etc. However, as we all know, the more someone uses a tool and learns the new gestures, the more likely he will use them. The challenge is how the gestures are introduced to users, where additional work is needed.
I find this product so exciting because it can help designers evolve the use of mobile devices in daily life in a more organic, social way rather than being defined by a business and engineers (as our technologies have been).
- We can now more easily test gestures – creating a gesture doesn’t require an incredible amount of mathematical programming that may be discarded after a single round of testing. It’s easy to experiment.
- We can make adjustments and enhancements more easily on the fly and be more iterative in gesture creation. A full-release isn’t needed to fix something that clearly isn’t working and creating a difficult user experience.
- Gestures can be more easily shared between apps – determine as a larger group/society about what works and what doesn’t, leveraging the success of others (and avoiding self-inflicted failure).
Social approaches are redefining how we look at business, communication and computing. We are moving away from a world where we use products that are defined for us, into a world where products are defined by us. The more involved we are in creating products, the more likely we are use to them. RoamTouch’s GestureKit is on the way to do this – involving the user in creating gestures that they will use and understand on their own without a manual.
