The progress paradigm
Before, you could open your computer, do your stuff, close it and enjoy life. Remember when loading a program, like a word processor, took a minute or more?
Today’s applications and websites typically employ a model where there’s a backend process that either runs locally on the same machine or on a server somewhere. Computers are thousands of times faster and perform much more analogue-like and complex functions.
Here’s the problem – we spend hours of our day staring at this:
It spins. It spins and spins to no end. We don’t know how long it’s going to spin. That’s why it is called an “indeterminate progress” indicator. And the program that shows you the spinner doesn’t know how long it will spin. In some cases, it might not even know if it’s ever going to stop spinning. You could leave it and come back the following day and still find it spinning.
The indeterminate progress indicator serves and important function. It tells you something is happening and there is nothing you can do about it. It is like the wheels of bureaucracy brought into the computer world. “File these applications and wait for a response.”
Those times when we waited for the program to load from a floppy were better in many ways:
- You knew that the program always would load
- You knew approximately how long it would take
- You had an indication on exactly what is happening – the floppy drive made a distinct sound that let you know that data was being read from the disk! You probably could even know what condition the floppy was in and when it was time to make a new usable copy of it.
Why can’t we still do this? Why must we look at a quiet spinner that tells us nothing? In some cases, it might momentarily stop spinning, making us hold our breath until it starts spinning again. Imagine seeing it while rebooting your portable device – and it stops for 20 seconds!
Informative Progress Indicator
Indeterminate progress UI components should allow for the program to provide feedback. Perhaps mechanical sound is no longer the way to go, although that would be cool too, but at least some sort of visual feedback. This could be called an Informative Progress Indicator.
There’s a lot happening during that spin.
- Web app refresh: there’s a lot of information going to the server and returning from the server.
- Standalone app spinners: the app knows, even if the task is being run in a separate thread, when something is happening and when not
If the spin involves sending a request to a server and waiting for a response, why can’t the server talk back small bits of information while it is processing? Let’s take a typical case of sending a REST-type request to a server.
Send request as POST or GET -> wait, wait, wait -> receive a monolithic XML or JSON response.
This could be:
Send a request as POST or GET -> start receiving a text stream from the server -> receive a “START PROGRESS” line if the server supports this, then receive “ticks” for random processing, followed by a line feed each. They could be:
- Empty line changes whenever nothing quantifiable is happening
- A floating percentage value when the server knows how much is already processed
- Other numeric value when there is something quantifiable but not a known fraction of the completion
- When all is done, a line signifying that the actual response is coming, e.g. “END PROGRESS”
Then, receive the JSON or XML you normally would get.
Now you have all sorts of information at your disposal.
Imagine opening Mac App Store and actually seeing it communicate with the server, giving you assurance that eventually something will happen?