 |
|
|
CASE STUDY: WHY MOOFUSLIST FOR IPHONE IS SO FAST
To designers and developers who have gotten used to web application
design, it might seem that UI design is just drawing pages
and linking them together. After all, a web application has just a
few ways of moving between pages (buttons and links) and nobody
expects extreme responsiveness when they are using a browser.
Mobile applications must meet higher expectations. Users on the go
don't have a lot a time to find the information they need. They know
from the games that run on their smartphones that the devices can be
graphically rich, fast to respond, and highly interactive. For a
mobile app to be delightful, it has to look good, but it also has to
seem fast.
The moofuslist app takes advantage of context, human perception, and
good old fashioned software engineering to make the application seem
fast.
About moofuslist
The moofuslist app helps you to find listings of bank-owned real estate from multiple banks, using
the same data that's available on the moofuslist website (also
designed by Adducive).
There are two ways to search the listings. You can run a
quick-and-dirty search, called a Quick Search, which just shows you
the most recently listed properties in a given city, state, or ZIP
code. For a little more effort, you can set up an Automatic Search,
where you can define a more complex location and limit the properties
by price, number of bedrooms, and number of bathrooms. Because
moofuslist collects its property information about from banks and not
a typical MLS database, there is not as much information available and
so the searching can be and has to be much simpler.
The app lets you create bookmark lists and e-mail property info. You can also
map the property or call the agent. On the iPhone, this quits the app and starts up
Apple's own map and phone apps. Learn more about the app
from moofuslist.com.
Context
A user's history with the application and the application's own data, combined with all the sensors in a smartphone for
location, ambient brightness, compass heading, etc. can make it possible to just
give the right information at the right time.
- The app always picks up where you left off. On a smartphone,
anything can be interrupted by a phone call. If you are looking at a
property, you will return to that property when you restart the app.
If you have an unfinished e-mail message, it will be saved before the
app quits so you can pick up where you left off.
- When you send an e-mail message, the app uses the From address that you used the last time. This means that it only has to be typed once.
- The app keeps its own list of recent e-mail recipients. Since most
people will be sharing property info with just a few family members
and their agent, this feature keeps you from having to scroll through
your entire contact list every time.
- When you run a search, the app fills in the last city/state/ZIP info
you typed, assuming that the most likely thing to do is to run the
search again to get the newest listings in the same area.
- When you create an Automatic Search, the location is filled in from
the last Quick Search you conducted. The other criteria for the
search (price, number of bedrooms, number of bathrooms) is based on
the other searches you've already created. For example, if your max
price is $500,000 in your previous searches, your max price will
default to $500,000 for any new search you create. Since the label is
usually just the location, the label for the search changes
automatically as you change the location, until you enter your own
label text.
- The keyboard appears automatically when needed. When addressing an
e-mail message, the cursor goes to the message text after you've
selected a recipient.
Perception
Using animation and setting expectations properly can be even more important
than the absolute time a system takes to respond.
- There is no splash screen. The app always picks up where you left
off, and so the launch image is designed to seamlessly transition to
the property info. (The moofuslist logo gets shown whenever a
property has no photo available, so you are exposed to it frequently
enough anyway.)
- The app displays one property at a time, and avoids a list view.
List views seem slow because you can see the data slowly loading and
many people will wait for it to load completely before starting to
navigate. Therefore, only one property needs to be ready for the app to seem
finished with a search.
- The app uses no progress bars. Under normal conditions, nothing takes more than
a second to respond to.
- The app uses animation after you conduct a search that takes just
about the same amount of time as the search takes. So it seems to
respond almost instantly.
- Network activity not only takes place in the background, but is
scheduled when your attention is directed elsewhere. The only
place where you ever have to wait for the server is when conducting a
Quick Search. For saved searches (called Automatic Searches in the
app), the updates take place without user intervention.
Software Engineering
Even with perceptual tricks, nothing beats an app that really is fast.
Under most conditions, the moofuslist app responds to Quick Searches
in less than a second.
- The app uses its own network communications conventions, instead of
SSL and XML, which are less efficient. Inefficient use of the network
on a mobile device not only keeps you waiting, but it drains the
battery. Now that backlights use LEDs, the radio circuitry is the
biggest power hog developers need to worry about.
- Even the server knows what it needs to respond to first to keep you
from waiting. Results of a Quick Search are returned before anything else, because
you are always waiting for those to finish. Since properties are sorted in price order,
the server sends lower-priced property photos first since you have to
scroll past those to get to the more expensive ones.
- The app was extensively profiled using the excellent tools Apple
provides. It is efficient with memory. Several different methods of
creating the reflection of the property photo were tested to keep the
app responsive.
Results
Not many clients would accept the idea that a user interface designer
should be specifying subsecond responses to client/server search
queries. Not many apps follow Apple's Human Interface Guidelines to
avoid splash screens and pick up where users leave off, but thanks to
close cooperation on this project, the moofuslist app feels fast and
responsive. Over WiFi, it is almost instantaneous. Over 3G, it still
feels faster than other network applications, including Safari. You
can spend almost all your time in the app with the property info you
are interested in, and hardly any time on splash screens, progress
bars, or administration.
|
|
