[ANN] Release 8.1.6 RC-1
ambassador at fourthworld.com
Wed Jul 12 21:36:21 CEST 2017
Richmond Mathewson wrote:
> On 7/12/17 7:56 pm, Richard Gaskin via use-livecode wrote:
> for reasons too lengthy to indulge in here.
> Please could you indulge in them somewhere so we can understand your
> argument fully.
For future readers to better understand my reply here, it may be helpful
to include the relevant portion of the message so they can know what's
If the toggle is either in-window or in the SE's View menu that
would be great.
I would caution against adding more stuff to the Prefs window,
for reasons too lengthy to indulge in here.
Discoverability is part of this, and, once discovered, ease of access
becomes another important part.
If you want to change something you're looking at, it's often better to
provide the means to do so in the thing being looked at, rather than in
one of several panes contained in some separate window which may be
found by accessing an item tucked away at the bottom of a menu.
A user will be able to discover that something can be changed in
relation to the conceptual distance between the thing being changed and
the location of the control that makes the change.
Ideally (and admitting up front that we don't live in an ideal universe,
so there is no one-size-fits-all rule for every design problem), this
would translate to a hierarchy that favors, in order of discoverability:
1. The content region of the window (rare for View options, since that's
usually where the user puts their own stuff, but definitely at the
forefront of user consciousness).
2. A secondary pane within the window (such as the View options at the
bottom of many popular apps like Apple's TextEdit).
3. A menu item accessible while the window they want to change is in
front (most HIGs specify a View menu for exactly this purpose).
4. A separate window which can be opened from a menu item (typically
"Preferences" on Mac and "Options" on Windows).
(Side note: Context menus are not even considered here since they never
include options not also available through more evident means.)
This hierarchy of immediacy might tempt us to cram every option directly
in the user's window, but of course throwing all options in front of the
user often backfires with cognitive overload and visual clutter, so we
want to think carefully about what goes where.
Whether an option is part of the local view, or a menu, or better
handled through a separate Preferences window isn't always obvious with
complete confidence, and like most things can involve a bit of guessing
(though guessing can be mitigated with A/B user testing).
But there are some questions that can be helpful in making that choice:
- Might the user want to change the setting more than once?
Things like the script editing field's background color is
often set once and rarely if ever changed. It's a good
candidate for the Prefs window.
Things like ordering handlers either alphabetically or
sequentially may be changed several times per session,
a good candidate for a View pane at the bottom of the
window, or at very least a menu item with a memorable
I can envision wanting to toggle the visibility of
suggested handlers frequently during a session.
- Are there any potential downsides to leaving the default?
As handy as the new list is, it risks confusion at first.
Certainly not cripplingly so, and easily learnable, but
it must be learned. When a single control contains content
used two different purposes, it's not necessarily a red flag
but may be a yellow flag, requiring the designer to proceed
Providing some self-evident means of turning those off helps
communicate to the user that, handy as they are, they are of
secondary importance to the list of handlers actually in
the script being viewed.
It's helpful to keep in mind that a very large majority of
users never change any prefs in any app at all*, so anything
we tuck away from immediate view off into a Preferences
window should be the subset of options whose defaults are
completely without downside.
- Are there any potential downsides to providing control over
the setting directly in the context it applies to?
Clutter is always a risk.
And with anything involving reading or writing text,
vertical space is a VERY high priority, esp. given that the
most common screen size by far (roughly twice as many as the
second-leading size) is only 768px tall.
So while we always want to be mindful of clutter, we want to be
especially mindful of vertical screen space in any layout involving
Adding a new View pane would a poor choice for this reason. But
the LC SE has plenty of rarely-used space in the bottom-most group
already there, currently used for left-aligned notifications but
the rest usually empty.
Since the group already has space, there seems little
downside to considering a couple of the most frequently used
View options there, such as perhaps hiding the suggested
handlers and ordering of the handlers in that list.
If that's at all problematic (textual controls are likely too
long to fit, and icons too abstract to be worth using), having
those available in a View menu takes no screen real estate and
still keeps them in a more discoverable local context.
Extra bonus points that putting that in a menu is probably
the most cost-effective option in terms of development time.
There may be other reasons, but this has already gotten waaaay too long. :)
* In UX circles they bandy about "80% of users never change preference
settings" so often it's usually taken for granted, but this morning as I
noted that above I wondered about the actual research behind it.
Of course that rubric applies only to consumer apps. There are many
reasons why guidelines established from consumer research don't apply to
developer tools, given the very narrow and highly specific demographic
That caveat out of the way, for general app design it can be useful to
learn about, so I did a quick search this morning. My brief effort
didn't turn up that original "80%" figure (would be nice if someone here
has time to find it and provide a link), but along the way I found this
gem from Jared Spool @ User Interface Engineering:
What we found was really interesting. Less than 5% of the users
we surveyed had changed any settings at all. More than 95% had
kept the settings in the exact configuration that the program
(Big takeaway: If you’re a programmer or designer, then you’re
not like most people. Just because you change your settings in
apps you use doesn’t mean that your users will, unless they are
also programmers and designers.)
We’ve repeated this experiment in various forms over the years.
We’ve found it to be consistently true: users rarely change
Like everything else at UIE.com, the details there are worth reading.
That experiment has somewhat limited scope, but given how closely it
seems to match other findings it seems worth at least noting the
Consider your app's defaults very carefully, because for most users
they'll be the only options they'll ever experience.
Fourth World Systems
Software Design and Development for the Desktop, Mobile, and the Web
Ambassador at FourthWorld.com http://www.FourthWorld.com
More information about the use-livecode