himalia.net | community blogs

Google has launched a new version of GMail with some good new features.  However, what really surprised me were the very bad changes in the user interface of the contacts "subsystem". Google has a very deserved prestige in providing dead simple and very well designed user interfaces. However, I think they couldn't repeat themselves this time. Luckily I am not the only one this time; users care about usability and as always, problems have more repercussion.

I was not going to post about this, but then I thought it could be a very interesting example to show how the right models/tools can help to avoid this kind of errors. Last but not least, I strongly believe you have to fall into a lot of mistakes in the process of creating a great user interface, but if you use the right tools and you are describing things at the right abstraction level, they become evident, and you can quickly walk through the continuous prototyping process to achieve a successful design.

What's Wrong With The Contacts Design In The New Version Of GMail ?

The main problem is it has a bad layout. Layouts should be simple and Google knows it more than anybody. Not only simple, they have also to be familiar, recognizable (yes, copy them from other user interfaces). Layouts aren't an innovation area and simple layouts have been all already invented.

So, What's Wrong With The GMail Layout?

Well, first of all it has too many areas. An area is the part of the screen where you will present a UI concept. Actually, you should have so many areas as concepts you want to present on screen at the same time. And you don't want to expose your user with dozen of concepts at the same time, so you don't want too many areas. In the new version of the contacts subsystem they have 5 areas (just in that part).

However, five areas wouldn't be a problem is they weren't so poorly orchestrated. Area orchestration, or Layout Behavior (as I lately redefined it) is the way you assign a hierarchy to the different areas on the screen. The main pattern you should know in this field is called Visual Framework. I will translate it in this way: "Try to keep the area hierarchy always, never mind which concepts are you presenting at each time in each area". 

The Layout Behavior can be defined using with transitions that are represented as arrows (this is a very natural representation). Each arrow means that the target will be refreshed when any action is fired in the source. Typically you expect that top menus refresh second layer menus, left or right bars refresh the content area and so on. This approach is very interesting because you don't need to think it in terms of events and other programming-related stuff. Just answer: when an action is fired in one specific area, which area(s) will be refreshed? If you can find a simple and recognizable orchestration for your areas, it will be good enough.

Back to GMail, have you seen this kind of orchestration in some other place?

Other problem with the chosen transitions are the transition jumps. The one from FirstTopArea to the RightArea is anti-natural because broke the logic sequence. The same happens with the transition from LeftArea to RightArea, but in this case you should add that it provokes a a little inconsistence because there is another transition from LeftArea to CenterArea.

Other good advice to take when possible is to define the transitions targeting contiguous areas, in order to facilitate the focus flow of your user. Why jumping to the other side of the screen?  Users don't want to guess where to look after clicking something. In this case, the user is forced to jump his focus from the left to the right in one jump. When you press something, the refreshed area should be the one the user is expecting to be, and users don't expect to move their heads all around like playing Simon in a big wall.

Also, there is a very ironic problem, the very strange behavior in the search box. When you search a contact, a new item is added in the left list (groups and other stuff list), while the results are added in the center list at the same time. Why? What's the purpose of the left list with two fixed items, all the groups and an intermittent search result item? Why adding that item there? Why just not showing the results as Google taught us in a dead simple way?

Finally, probably the most annoying error is the inconsistence. Consistence is THE fundamental behind all great designed user interfaces. When you press the "New contact" button you are directed to the RightArea, but when you press the "New Group" button (placed just at it side) a popup appears on the top left corner of the screen, while  other popup's appear centered on the screen. Added up, it provides a baffling experience for the user.

Random isn't a good friend of user interfaces. Actions presented in the same style and grouped together, are expected to produce the same kind of feedback in the user interface. If they are going to provide different experience they should be separated or presented with a different style (see examples below).

So, now you may be thinking: ok, user interface guru-wannabe, how would you improve this? But I will answer it the next post, because it is already quite long ;)

Labels: Himalia, Patterns, Prototyping, Usability, UX

# posted by leovernazza : 12/09/2007 04:15:00 PM  1 comments links to this post

From a long time ago I wanted to post about this topic because it is one of the features I love about the way we can build the user interfaces with Himalia.

Iterating From Paper

Many studies have shown the importance of early prototypes. Actually, recent articles point to paper prototyping as one of the best tools for the development of user interfaces, in a cost-benefit point of view, because it helps to point the UI in the right direction from the beginning at a very low cost (if you don't use it, you may be very wrong, too late).

But paper prototyping has some problems, most of them related to accuracy and imagination:

1. you can't test interaction in a reliable way
2. what you see is not what your get; but mainly, is not what the user see
3. once you have started with the development, paper-prototyping becomes more and more expensive
4. once you have prototyped, you have to translate it to code (and you know that translations produce errors)

I think it's similar to the problem we used to have with integration of software before Continuous Integration, so, a similar solution could make sense also here. Note that what makes continuous integration possible, is the fact we have a tool who knows the process used to create software. That is, our integration server knows about check-ins, tests, fails, people, etc and use them as first-class citizens in the process. I think that more and more tasks in software development should be made as frequent as you can, and automatically when it's possible.

If we wanted to take this approach in the user interface field, I would like to have a tool who knows about prototypes, and let me:

1. start with a little one
2. load most used layouts and patterns from a repository
3. change the initial prototype through many steps
4. test interactivity from the beginning and in each step
5. iterate in seconds from the changes to the user-feedback
6. build the final version as an evolution of the initial prototype (I don't want to throw more paper to the bin)

Getting feedback

One main aspect that should be considered, is that the prototyping task is not finished once you release your application. In other words, usage analysis and statistics have changed the way web applications are built today (and probably part of the commerce' history), turning marketing into a tangible discipline.  World-class web enterprises are already doing "continuous prototyping", regardless if they use this term or a specific tool in the process. Sites like Netflix, Amazon and Facebook are continually modifying the user interface in order to better adapt it to the user needs or/and add new functionalities. 

I think it is obvious, but I will say it anyway: not only web user interfaces should adapt itself from users. The user is the same, regardless he is watching the application inside a browser or not. However, while in the web we can just add a simple javascript to all the pages and get a good analysis, you can't achieve it easily in the desktop (mainly because it lacks of the "addressability" concept).

Putting All Together 

So, in order to accomplish both things, we need not only a good tool in the developer side but also a good framework in the user side to make the full story available for us, because feedback is -at least- as important as early-prototypes.

Prototyping should not be seen as the task involved in building an artifact, but as the continuous process of adapting the user interface to the users needs.

In this way, everything we can do to reduce the time from the development to the user feedback, is going to give us more time to do more iterations, and as with continuous integration, each iteration will increase the quality of our "final" product. 

Labels: Guilder, Himalia, Prototyping

# posted by leovernazza : 10/15/2007 11:17:00 PM  2 comments links to this post