
The Growing User and the Perennial Beginner - joshuacc
http://ignorethecode.net/blog/2011/08/09/the_growing_user_and_the_perennial_beginner/
======
Gigantt
Covering the entire triangle is probably impossible. I think it all boils down
to a few variables, like how many features are there and how many "things" can
attract the users's attention on screen. There's an inherent _contradiction_
between what pros and beginners need. A beginner doesn't want to be bombarded
with options, and he probably would enjoy being lead a little bit along the
way. A pro must be able to reach advanced options, and do so in a convenient
way and would absolutely hate being annoyed with advice.

So you basically have two modes and the problem is you can't really flip a
switch to move between them (i.e. "expert" mode is always a UI fail) or meld
them (UI that changes on you is unpredictable and thus annoying). Beginners
turn into pros. But it doesn't happen at an instant, it's gradual, and people
become more versed in certain aspects of a program and not others, so there
can't just be this global switch. And pros turn into beginners, given enough
time since last use or a change of focus. So the way I see it you can either
target one, or the other, or find a compromise in the middle - but realize
it's not going to be a win-win. I really can't think of a good win-win UI
example in the real world.

------
3pt14159
Excel truly masters being the full triangle. A simple list at first, a multi-
linear optimizer later.

So does Ruby.

    
    
      puts "hello world"
    
      # and later
    
      homing_missile.target_pos = some_monster.public_method(:pos)

~~~
ugh
I will have to disagree with your assessment of Excel. It’s a great tool,
especially for those who live in it, and it covers a large area of the
triangle but the start is very rocky.

Using it for simple lists of numbers – maybe even with a bit of arithmetic –
is indeed easy to pick up. I have, however, seen a lot of casual users of
Excel struggle with getting their finished lists look a certain way and with
printing them out. I think there is potential for optimization in that area.
Still, apps that cover the whole triangle will probably always be somewhat
intimidating for beginners.

I, for example, like InDesign (Adobe’s layout tool) a lot but it is completely
inaccessible to beginners. You basically need to read up on it before you can
even start putting the first word on a page, even if you are, say, versed in
using word processing software. I think that’s perfectly alright, InDesign is
an incredibly powerful tool that doesn’t need to be accessible to beginners.

~~~
LearnYouALisp
I couldn't believe MS was portrayed as "professional" in the sense of
preparing books and typesetting documents.

------
Detrus
I think it's a false choice.

The example of Acorn and Pixelmator is strange. Acorn is not much easier to
pick up, it has almost all the buttons. Personally found it harder to use and
understand what it's for. If you don't understand it's particular use case and
want to do a common task that it doesn't have, it suddenly becomes very hard
to use.

In the current app ecosystem pro and consumer apps are indeed divided but
there's no reason for this except tradition. You can present a full featured
app as a simple consumer app by changing its UI. Then slowly reveal buttons
and features if you detect it gets used everyday for example.

You could use a feature search UI, letting people use keywords to find the
features they need. Basically a modern skin on the old command line.

Just because apps are done a certain way now doesn't mean you should copy this
trend.

Programming languages are a good comparison. A full featured programming
language can be easy enough for beginners if it has good tutorials and
obviously serve serious users. A limited programming language will become hard
in many beginner cases. DSLs usually make it clear what they are, a GUI like
Acorn doesn't.

It's possible to make full featured programming languages look easy to
beginners. LISP does it in a way, although its syntax looks unpleasant the
fundamentals are easy to pick up. The same can be done for GUIs by introducing
fundamentals that repeat. That might seem hard because today we have a
mishmash of menus and buttons, where the only way to simplify is to have fewer
buttons and menus and make them bigger.

~~~
LukasMathis
Slowly revealing new buttons is probably not a good idea, since UIs that
change on their own are confusing; things are never the way you expect them to
be.

Similarly, searching doesn't work well for beginners, because they don't know
what to search for. If you only know what you want the result to be, and not
how to get there, or what features you need to achieve the desired result,
it's easier if you can just click on things you see, and undo changes if
they're going in the wrong direction.

Microsoft tried pretty much everything they could think of in Word, attempting
to do exactly what you're suggesting: make an app that works for
professionals, but is discoverable for beginners. This is where things like
Clippy came from. It's really, really hard to get this right.

~~~
Detrus
Clippy is plopping intrusive tutorials on top of a complex interface. It's not
a serious attempt at execution, it's bureaucratic incompetence.

What I'm talking about is more akin to Google and Wolfram, when they give you
an answer to a math problem. When you ask "how much water is in the oceans" it
would try to figure out if you meant volume, show you related formulas, etc.
Similarly for a photo editor you'd say "make the head bigger" and it would
list the features one would need, like the selection and resize tools.

So if you only know what the result should be, use keywords to find features,
then click to see if they're the right features. It's perfectly doable, just
hasn't been attempted.

------
n_evans
The conversation isn't about about simplicity vs complexity. It's about
complicated vs complex. Poorly managed complexity leads to complicated
interfaces and products that are difficult to figure out. Simple products are
often very straightforward and therefore very easily understood. Complexity is
good because it enables rich experiences, it just has to be understandable in
order to make it accessible. Simplicity gets lots of hype, but extremely
simple interactions are often less engaging experiences and less engaging over
time. So, go for understandable, accessible depth! Make complex offerings that
are usable by providing the right level of guidance for users along their way
to understanding and making the complex functions accessible to them.

~~~
LukasMathis
The "complex doesn't mean complicated" counterargument always feels like
people are just playing the semantics game, rather than making a real
counterargument. When somebody says "complexity is bad", he or she already
uses "complex" to mean "intricate, complicated".

If you can hide complex functionality behind a simple user interface, it's not
really a complex user interface, right?

------
adjwilli
I would be interested to hear other people think are some examples of good
software experiences that cover the whole curve.

Maybe Lion could be an example because of Launchpad, but not Snow Leopard.

------
6ren
His cases use only one dimension (depth).

