Automatic UI without explicit "perform action" controls

Question

Having seen a number of examples over the years I've been wondering where this kind of interfaces stand today.

What I mean by "automatic UI" is the following.

Normally on screens, dialogues and web pages you have some input controls where you need to enter data then you press a command button "Go", "Search", "Filter" or whatever. If these are the settings, then the buttons say "Save" or "Apply". An important part here is that you always have a way to cancel the intended action by closing the window, the dialog, the page or by clicking the "Cancel" button.

With automatic interfaces there are no such action buttons. Things happen on their own as soon as you stopped entering the data in the input controls or remove the input focus from a control. Examples are many:

• Google instant search where it filters the results as soon as you stopped typing, you don't have to click "Search" explicitly

• Settings dialogues in the Safari Browser. As soon as you change anything it is immediately saved. The dialogues have no explicit "Save" or "Apply" buttons.

• Lately the search on Stack Overflow careers. Search is triggered as soon as you remove the focus from any input control where you've introduced a change.

Now the question is, what is the industry opinion on this kind if interfaces?

• Are they considered modern and "cool" so users want them everywhere?

• Are they known to improve usability? Any studies on the matter?

• Do they have any technical advantage behind the scenes?

• Or is this simply a different way to do things and is nothing but a matter of taste?

My personal experiences with these interfaces are twofold. Sometimes it does simplify the interaction like Google's instant search so I see them as a positive thing. On the other side of the fence, the dialogues save and apply things immediately so if you click or change something wrongfully it will have consequences which are sometimes difficult to clean up, especially if you didn't notice you clicked somewhere (like the focus was in some list and you wheeled your mouse). In that case these interfaces raise the feeling of insecurity.

So I'm interested in your opinion on the thing. Any "official" statements from companies on this sort of things. Any usability case studies. Anything to explain why people are doing such interfaces and how they perform.

UPDATE: I've just come to realize what I don't like in these instant interfaces. It's psychological, it is the feeling of lack of control. With explicit buttons, things happen when I say. Without them, things happen when the software decides and I feel like a passive and helpless observer.

Answer 1

I think you're mixing two distinct things to define "automatic". Yes there is some thing that happens "automatically", but what is it?

1. If you take Google instant search (which by the way is optional), then you start typing in information and you are presented the best results as you go on. This feature guides you, it provides options. It provides you real time feedback about how useful your search query is to the system.

2. If you take Safari's Settings (which from your description is a non-optional behaviour), then you make some input and the input is immediately applied. This features takes control of how your input should be handled. This is somewhat like a text editor, that directly saves any input you make (assuming there's no history, you're screwed). Or like a web content editor, that directly publishes your input to the server as you write it (this would turn stackexchange "threads" into fierce chat battles :D). Or like a spell checker that automatically inserts its best guess (which can go REALLY wrong).

So the first approach contextually provides options to you, while the second unconditionally makes decisions for you.
To rephrase that: The first one is helpful, the second one is not only annoying, but potentially harmful.

At their core, the difference between the two actions is that between queries and commands. Queries are side effect free. So there's little possibility to screw things up with "automatic" queries, but "automatic" commands are almost certain to cause unwanted behaviour (unless you execute them in a "parallel space", i.e. a preview for the settings made rather than direct application, or a backup of the current document state, rather than direct saving).

Answer 2

These kind of interfaces are definitely cool. Because you save time. Because removing lets say a search button saves you the time clicking it.

On the other hand they might not be considered as cool by users because it's new. And new always needs to be learned. And people might not like learning.

Jef Raskin focussed on these matters in his "The Humane Interface". He also measured time that actions like a click or hit of a key requires. So he removed everything he considered not necessary. Even the second letter of his first name.

Some examples from this book (let me know if I mixed up something - read it a couple of years ago):

• A computer that doesn't have an on/off switch. The computer goes into sleep mode and turns on on any action like a hit key. Even the hit key won't be wasted. If there's a word processor running the hit key will be written.
• Instant results in search fields. At the time he wrote the book it was not possible to implement the feature due to slow computers. Nowadays you find that in iTunes or Google Instant.
• No save and load. You just go back in the history of the document via a timeline. Requires everything to be saved automatically.
• No useless metaphors like an application or Icons because they are abstract. He proposes that the zoomlevel let the user dive directly into the content. You can edit immediately without opening an application for that. This would also save the choice what kind of application you should use. He invented the interface used e. g. in Google Maps by that.
• He insisted on good labeling of buttons. E. g. "Do you want to save?" -> ok/cancel is abstract and require to read first what the actions of the buttons would be. He said the buttons should tell what they do: Save/Don't Save. Would save additional time.

Answer 3

The first kind (explicit Apply button) actually has the technical advantage. It allows for low-bandwidth connections, becuase the UI need only contact the backend processing code when the Apply button is hit. This was a big advantage in the old days. For instance, in mainframe programming, a mainframe might serve a thousand users concurrently, and it would not be able to keep up with every edit.

This convention was brought over to PCs, which (being Personal computers) didn't have the problem to satrt with. It became again relevant in the web age, where webservers might now serve tens of thousands of (remote) users, but even there bandwidth has caught up.

Obviously, any interface that penalizes common mistakes (such as typo's) is plain wrong. But in general, that's an argument against the Apply button. That's just a way to make your mistakes permanent. And without an Apply button, you can't click it accidentily.

Answer 4

These predictive actions are good for advanced users, and they may be harmful to beginners, who really need the feeling of control. In case this sounds counterintuitive: advanced users need the actual control, while beginners need the feeling of control, so that they feel like they're getting the hang of it.

When a button is being pressed for them, advanced users will notice it and may (or may not) appreciate the shortcut. But beginners may not even be aware that it was pressed, and will look for a way to carry out the setting that they've defined. An advanced user of google instant search will notice the results changing as he types, and a beginner will finish typing (he is probably looking at the keyboard and not at the screen in any case), and will search for a button to initiate the search.

Look at bit.ly. If you're not signed in, you need to finish typing the original url on their homepage and then press "shorten", which gives you the short url. But if you're signed in, then once you finish typing the url in the textbox, it automatically shortens it within that same textbox. This is because the fact that you're signed in implies that you're probably not a casual or first-time user, and you'll know what happened.

In short, I think it should be treated as an advanced function / shortcut - good for experts, not so good for novices.

Answer 5

You asked at least four questions here. I'm just taking one of them:

• Do they have any technical advantage behind the scenes?

Yes. They go with a style of programming that uses computer resources in a less 'bursty' way. For example, using a compiler that waits till you command it to compile you have a sudden demand spike in processing. If instead you are compiling in the background, as the user types, the computer resources are used much more evenly. The same compute resources seem more powerful.

One point about Google instant is that the early results may not actually arrive. If early in your query you hit an index that can't be served from RAM, the instant search suffers, but by the time you complete your query, or even just type a few more letters, it IS in RAM. Having a preview of what you are typing gave Google a head start on answering your complete query.

I would include collaborative editing in Google docs as part of the trend you are seeing. The small updates as users type are less bursty than the bigger updates when someone submits an updated page to Wikipedia. This has knock on effects from peak network traffic, to memory cache sizes, to the cost of rebalancing load. The net effect is that you can host more users on the same hardware - without it feeling unresponsive.

A second technical benefit of sites that do things as you type is analytics. They get more information, and are better able to improve their service. They see backspaces and pauses, fast and slow typing, that you don't see if you only capture on commit.