Usability

unhappy story

Various parts of the Linux Environment need some help with the usabilty... Generally there are geeks who want to solve a particular problem, they quickly hack together a program that does what they want.. but it requires uber geek knowledge to use..

then when the product is shared to other uber geeks, they can't figure it out, but they don't want to have their uber geek status revoked, so they read tons of documentation, finally analizing the source code, and program behavior, using debug tools, and use the software... without complaining.. so they keep their uber geek status.

Then when a mere mortal geek comes along, and asks the uber geeks for advice, or help, because the documentation was not very good, he gets an RTFM type response... and goes to an inferior, or expensive computing environment.

Occasionally uber geeks reveal this little story to the public, and everybody goes *oh, yeah, that's what's happening* and then, sometimes, the software gets made usable...

there is hope

Many people really get a kick out of writing highly usable software. It's not actually that hard, for the basic stuff.. but some things are non-trivial.
 See: non-trivial usability and trivial usability for lists of requested enhancements.

The non trivial enhancements are things that require hard work, like implementing zoom exactly perfectly, compiling a database of every printer known to man, and orchestrating the collection of said info.

Trivial enhancements are things that just need to be disabled, or an extra hyperlink at the top of a page, or condensing the super ugly needlessly wordy documentation of some linux distributions.

short-term memory

Short-term memory refers to the human memory that holds information in short-term (also referred to as working memory). Through much research, it has been identified that the human mind can't hold more than 6-7 chunks or distinct entities at any time.

For an easy test to demonstrate this try the following mental exercise. While multiplying, close your eyes or avoid looking at the screen. Otherwise, the numbers in the screen will be aiding your short-term memory.

Multiply 17 * 7. Most should be able to do it. Now try 178 * 7. Most people will find it difficult. If you could do that, then try 1756 * 7.

This exercise typically requires our working memory and as the digits increase, the working memory needs to hold more chunks and we can feel that we can't hold the digits of results beyond a certain point in our memory.

This is an important consideration to be taken when designing man-machine user interfaces. For example, the number of digits in a base telephone number is limited to 7 digits in the U.S.

(This brings up an interesting point regarding what constitutes a 'chunk' and how some 'chunks' can be removed from the count of objects. For instance, the 1 prefix and the area code does not excessively strain short term capacity, because of the familiarity and uniformity of the convention. If a randomly varying set of 3 to 5 numbers were prefixed, it would be much more difficult to remember.)

When the situation forces us to process more entities than this limit, we typically use external aids to supplement our working memory limits. For example, to multiply 1756 * 7, we may use paper and a pencil/pen. A piece of paper is another form of memory that can hold information.

Any interaction with computers involves an enormous amount of information exchange between the computer and the user. This human cognitive limit plays a key role in the usability of an application and the comprehensibility of a document. When complexity at one level increases beyond this limit, abstraction mechanisms are used to hide the complexity at that level.

Hierarchical structuring of information or systems is one popular abstraction mechanism of limiting the complexity at each level. This enables human beings to process the information within the limitation of their working memory.

Computers typically don't have this limit. So a file that is read solely by a program and not by a human being may not be structured hierarchically. So a user trying to understand a file which is in a format meant to be directly read by a program may experience discomfort, depending on the format used.

Typically GUI users may not encounter this but CLI users may encounter this more often.