discuss-gnustep
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Installer UI advices


From: Jeff Teunissen
Subject: Re: Installer UI advices
Date: Fri, 18 Mar 2005 10:35:27 -0500

Frederico Muñoz wrote:

[snip]

Sorry this message is so long, I didn't have time to make it shorter.

> >>> (And when you do have to do this, the wizard UI seems the most
> >>> reasonable and efficient way to get through it.  It is easier to
> >>> rush through a wizard and be sure you've at least glanced at
> >>> everything than to click around a tabbed or other non-sequential
> >>> interface.  The wizard is also well-suited to delivering clear
> >>> information to the user on what stage of an install process failed.)
> >>
> >> Agreed -- it's a sequential process, it should have a sequential
> >> interface.
> >
> > Agreed too. Even if I'm not fond of it, it seems to me less
> > error-prone than the non-sequential way.
> > But perhaps let people jump through steps easily (if that doesn't
> > prevent the installation of course.. ie let them jump if the steps are
> > not mandatory..).
> 
> This is why i made the RFC, even though the NeXT UI is better for
> "power users" that want all the info at hand, it's terribly confusing
> when one needs to present options. I also think that sequential is the
> best way, given it is made with both simplicity and ability to easily
> navigate (even the ability to just press "Quick Install" when the app
> contains defaults and doesn't need any kind of compulsory user
> interaction).

This is why all possible options for the _package_ (note: this is distinct
from the options for the _application_, which should not be covered at all
during installation) should be presented on one window, to be changed all at
once. Nothing else is necessary, and indeed only useful if something goes
wrong (in which case, the detailed progress view should be switched to
automatically to tell you _what_ went wrong).

The NeXT installer is a fire-and-forget installer; press one button, wait
for it to complete, and it's finished -- and in the meantime, you can be
doing other things.

Contrary to what Jesse Ross says above, software installation is *not* a
sequential process. There is only one step in installing a program, a
framework, a set of libraries, a toolchain, or a giant group of the above in
a megapackage: "Install". The other "steps" are artificially created and
unnecessary.

And to respond to the idea of an "error-prone" installer...there's no way
for the user to fuck it up if all the installer does is, well, install
files. Setup should not be done at installation time; that is for when the
application starts the first time. No handling or even displaying of
application licenses unless you specifically request it, because that is not
a concern for the _installer_ (usually an administrative user) of a program
as much as it is for the end user of the program. If the user refuses a
click-through license, then the program may choose to refuse to run for
them, but that should not affect others' use of the program.

Remember that anything not DIRECTLY involved with the actual installation of
a package is an unwanted and unneeded interruption of the person doing the
installation. Their time is valuable, much more valuable than yours is,
because there are more of them than just you. :)

If you waste only fifteen seconds of their time making them read and respond
to the text on a window and there are only thousand users, that's four hours
of productive time that you have wasted -- half of a work day. How many
different pages does the average installer wizard make you go through?

Now, consider that NeXT's installer had one "extra" page, with a maximum of
three options on it, and as few as zero. The extra window levels on the
popup button were not even needed unless something went wrong. Some have
said that it's too minimal or arcane...but really, what more do you need,
and how much more friendly could it have been? Really, you just press the
"install" button and get going, without any fuss.

The rest of this isn't related to this particular message, but I'm adding it
anyway because it speaks to other messages in this thread. :)

In <address@hidden>, Pete French says that you have
to hide the complexity of the computer; this is misguided at best, and leads
to abortions like Microsoft Bob. The ideal is to help the user manage the
complication created by the user interface because the computer itself is
too simple for them to interact usefully with. The interfaces, like
everything else, should be as simple as possible, but no simpler (to steal a
line from Einstein).

In a given user interface, efficiency and productivity are the most
important factors (possibly even collapsed into one factor), followed by
simplicity/discoverability.

Now, a well-designed user interface extends to all of its possible levels.
This means that as you continue working and extending your own knowledge,
you should never have to relearn what you already know about the interface
in order to continue.

In a *nix context, it means that if your GUI works in a particular way, then
the lower levels (like the command-line) must behave similarly to avoid
relearning concepts when applied to those parts of the system. It causes the
user to see the system as a single system instead of three or more different
systems that require massive amounts of relearning the deeper they go. That
is, you have one learning curve instead of two or three or six. Pick your
metaphors and stick to them, or your users will curse your name.

And this part is key -- the assumption that the user will indeed go deeper
in their learning, so you'd better make sure they learn the right lessons.
Why is this assumption a good and proper one to have? Because the concept of
the "typical user" is complete bollocks. We do not stop learning until we
die, and if you show that there is a faster, more productive way to do the
same things they already do, then as long as the learning curve is not too
steep, they will actually want to learn how to do it.

This is both the success and the failure of the original Mac interface. As
long as you have never used a computer before, you can sit down in front of
the machine and be reasonably productive in a very short amount of
time...but the level of productivity never rises very far beyond what you
were able to acheive in that first day, or week. Without additional depth
there is nowhere else to go, no way to be more productive. You don't have to
relearn anything, but there's really nothing more to learn.

That last part is where NeXT excelled. The interface is, at first, slightly
more challenging to the new user...but the depth that was there allowed you
to graduate from a new user to a Unix wizard without switching tracks...you
just keep advancing, gaining new abilities, becoming more productive without
leaving anything behind. This is what I mean when I say that the NeXT GUI
was the most Unix-like of all the GUIs built on top of Unix. It uses the
same concepts and generalizes them so that they are accessible right from
the beginning -- the user's knowledge is portable.

-- 
| Jeff Teunissen  -=-  Pres., Dusk To Dawn Computing  -=-  deek @ d2dc.net
| GPG: 1024D/9840105A   7102 808A 7733 C2F3 097B  161B 9222 DAB8 9840 105A
| Core developer, The QuakeForge Project        http://www.quakeforge.net/
| Specializing in Debian GNU/Linux              http://www.d2dc.net/~deek/




reply via email to

[Prev in Thread] Current Thread [Next in Thread]