The Growing User and the Perennial Beginner | Hacker News Reader

The Growing User and the Perennial Beginner

ignorethecode.net

44 pointsjoshuacc14 comments

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.

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)

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.

Yeah excel seems easy when you've been using it since age 3. But I work with hundreds of creative-types - artists, designers, writers, etc - who couldn't figure out what to do with an excel beyond opening it and reading it like a document.

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

I think many programming languages fall into another category not mentioned in the article, a category where they serve both the beginner and the expert, but not the intermediate user.

That is, they're fairly easy to pick up for a beginner, as there are tons of "hello world" tutorials and with all of the libraries and frameworks available can be used to make large production applications but moving from one to the other requires incredible amounts of work.

That being said, I don't think many of the typical user interface guidelines apply to programming languages anyway, so the point is probably moot.

The number of tutorials has to do with the popularity of a language and the general level of competence.

The author is talking about a user interface, not how-to books, so it's hard to apply the principle to programming. (How a PL implementation is documented is a a little similar but not the same.)

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.

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.

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.

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.

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?

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.

His cases use only one dimension (depth).

Reply on news.ycombinator.com