User Interface Design

Chapter 3 Software Behavior

Software Behaviour
Software behavior is about collection of all the executions in a software.

3.1 Flow
In this section, we study how the flow occurs in the form of execution of different
steps involving interactions from user.
Sensible Interaction
A good user interface must include interacting with the user in a sensible manner. But
programs violate it constantly.
Following considerations must be made for sensible and meaning interaction:
1. Follow user’s mental models
2. Enable users to direct, don’t force them to discuss
3. Keep tools close at hand
4. Less is more
5. Provide modeless feedback on user actions
6. Design for probable, provide for the possible
7. Reflect objects and application status
8. Avoid unnecessary reporting
9. Ask for forgiveness, not permission
10. Provide choices, don’t ask questions (dialog box ask questions, toolbar offers choices)
Flow of States
Posture is a program’s behavioural instance. It is the way the program presents
itself to the user.

There are four categories of postures:

1. Sovereign Posture
2. Transient Posture
3. Daemonic Posture
4. Parasitic Posture
Sovereign Posture
● A sovereign posture application is a
program that is the only one on its
screen, monopolizing the user’s
attention for long period of time.
● e.g. word processors and
spreadsheets.
● These programs are usually used
maximized.
● Sovereign users are experienced
users.
Transient Posture
● A transient posture application is a
single function application.
● The program manipulates a
document but only does some very
simple, single function.
● The program is called when
needed, appears, performs a job,
then quickly leaves, letting the user
continue his more normal activity
which is usually working with a
sovereign application.
Daemonic Posture
● The daemonic posture programs do
not normally interact with the user.
● These programs serve quietly and
invisibly in the background,
performing possibly vital tasks
without the need for human
intervention.
● e.g. A printer driver.
Parasitic Posture
● These programs that blend the
characteristics of sovereign and
transient programs.
● The parasitic program is continuously
present like a sovereign, but it performs
only a supporting role, is small and is
superimposed on another application
the way a transient is.
● E.g. windows clock, Microsoft office
manager.
● Silent reporters of ongoing processes.
Window States
● Minimized
● Maximized
● Pluralized (Restored)

Multiple Document Interface (MDI)

● MDI was introduced by Microsoft to organize the functions in a windows
application.
● It satisfied a need apparent in certain categories of applications.
● Those categories had to handle multiple instances of a single document
simultaneously.
● e.g. Excel
MDI (Contd.)
If we want to copy a cell from one spreadsheet to another, we have do following:
● Open, copy and close first spreadsheet.
● Open, paste and close second spreadsheet.

Better way is to open two spreadsheet simultaneously.

There are two ways to handle such case:

1. MDI (Multiple Document Interface)

2. SDI (Single Document Interface)
MDI
● Multiple instances of spreadsheet
inside one spreadsheet program.
● Microsoft choose it.
SDI
● Multiple instances of spreadsheet
program with single instance of
spreadsheet.
● Superior but costly.

● This one-program-multiple-documents model violated a fundamental design

rule.
● Only one window can be active at a time.
● The need was to have one program active at a time along with one document
window active at a time within it.
 ● In MDI, we go to “Window” menu to change from spreadsheet to spreadsheet
but go to start bar to change from Excel to word.
● In SDI, we go to start bar to change both.
● SDI is clearly better just for this fact, but it’s still not a lot better.

Overhead
To find overhead in softwares, we need to identify different tasks that are found
while developing some software.
1. Revenue Tasks
- Work to solve the problem directly.
2. Excise Tasks

● Don’t contribute directly to solving the problem but are necessary to

accomplishing it just the same.
● Extra work that satisfies the needs of our tools as we use them to achieve our
objectives.
● Distinction is sometimes hard to see because we get so used to the excise
being part of our tasks.
Software excise tasks
- are trivial.
- performing them is no great hardship.
- configuring networks.
- making backups.
- connecting to online services.
- Installing sound cards. etc
Problems
● Effort we spend in doing them doesn’t go directly towards accomplishing our
goals.
● It goes towards satisfying the needs of the tool we use to accomplish our goal.
● It is overhead.
● Excise tasks must be eliminated in order to make the user more effective, and
productive and improve the usability of the software.

Virtually all windows management tasks are excise tasks. Dragging, reshaping,
resizing, reordering, tiling & cascading windows are excise actions.
GUI Excise
● One of the major criticisms leveled at GUIs by experienced computer users –
notably those trained on command-line systems is that getting to where want
to go is much slower and more difficult by the extra effort that goes into
manipulating windows and icons.
● These complaints are well-founded. Extra window manipulation tasks like
these are indeed, excise.
● But GUIs are easier to use than command-line systems, Who is right then?
● Confusion is because the real issues are hidden.
● Command-line interface forces even more expensive excise budget to the
user.
● Must remember command.
GUI Excise (Contd.)
● No option to configure screen to own personal requirements.
● This excise is reduced when the user has invested significant time and effort
in learning it.
● For the casual or first time user, the visual explicitness of the GUI helps him
navigate and learn what tasks are appropriate and when.
● The step by step nature of GUI is great to new users.
● Useful to those users who have more than one task to perform.
● One person’s excise task is often another person’s revenue task.
Meta Question
● It means asking if you can ask the question.
● Meta Questions are pure excise and there is no reason for them in user
interface decision.
● If we want to change some value, we should go ahead and change it.
● We shouldn’t have to ask permission to ask.
● Choosing and changing installation directory while installing programs.
○ Verify validity
○ Assure installation occurs correctly.
Error & Confirmation Messages
● Probably no bigger excise elements than error messages boxes and
confirmation message dialogs.

We must eradicate them in order to reduce the excise tasks in our program.

Eliminating Excise Tasks

● Don’t force the user to member where he put things in the hierarchical file
system.
● Don’t force the user to go to another window to perform a function that affects
this window.
● Don’t force the user to resize windows when a child window pops up on the
screen, the program should size it appropriately for its contents. Don’t make it
big and empty or so small that it requires constant scrolling.
● Don’t force the user to move windows. If there is open space on the desktop,
put the program there instead of directly over some other already-open
program.
● Don’t force the user to re-enter his personal settings.
● Don’t force the user to still fields to satisfy some arbitrary measures of
completeness.
● Don’t force the user to ask permission to ask a question.
● Don’t ask the user to confirm his actions.
● Don’t let me user’s actions result in an error.
Task Coherence

● The idea that we can predict what a user will do by simply remembering what
he did last is based on a simple principle called task coherence.
● This idea is that we do is generally the same from day to day, and this is not
only true about how we brush our teeth and eat our breakfast, but also about
how we use our word processors and email programs.
● When we apply the task coherence principle to our software, we can realize
great advantage from it. When a user uses our program, there is a
very-percentage chance that what he does will be the same as what did the
last-time he used our program.
● This helps to reduce the number of questions in our program that we ask the
user.
● If we are asking the user, in our program, our program must remember the
answer of user.
● Intelligent and self-motivated.
● Regular tasks can be remembered like file saving locations.
● Memory management.
A new way of thinking
The popping of dialog box in program gets replaced by a more studied process,
where the designer starts asking questions like:

1. How much should the program remember?

2. Which aspects should be remembered?
3. Should the program remember more than just the last setting?
4. What constitutes a change in pattern?
Different situations are imagined like-

● Which date format should the program use if the user accepts the same date
format 50 times in a row, then manually enter a different format?
● The 50-times format or the more-recent one time format?
● How many times the new format must be specified before it becomes the
default?
● The program shouldn’t ask the for his ambiguity.
● The program must make a reasonable decision.
● The user is free to override the program’s decision if it is the wrong one.
● We can use characteristic platform in the way people make changes to help
us resolve these more complex questions about task coherence.
Decision-set streamlining
● People tend to reduce an infinite set of choices down to a small finite set of
choices.
● Even when we don’t do the exact same thing each time, we will tend to
choose our actions from a small, repetitive of options.
● This principle is called decision-set streamlining.
● If the decision set consists of precisely two alternating elements, the concept
is no useful.
● e.g. if we alternatively read file from one directory and store them in another,
each time the program offers me the last directory, it will be guaranteed to be
wrong.
Decision-set streamlining (Contd.)
● The solution is to remember more than just one previous choice.
● Decision-set streamlining guides us to the idea that pieces of information the
program must remember about the user’s choices tend to come in groups.
● These will be several options that are all correct instead of only one way
being right.
● The program should look for more subtle clues to differentiate which one of
the small set is correct.
Preference thresholding
● The decisions people make trend to fall into two primary categories: important
and unimportant.
● Usually, any given activity will involve hundreds of decisions, but very few of
them are important.
● All of the rest are insignificant.
● This principle is called preference thresholding.
● e.g. if we want to buy a car, we don’t really care who finances it as long as the
terms are competitive.
● Preference thresholding can guide us in our user interface design by showing
us that asking the user for successively detailed decisions about a procedure
is unnecessary.
Preference thresholding (Contd.)
● Once the user asks to print, we don’t have to ask him how many copies he
wants or whether the image is landscape or portrait.
● We can make an assumption about these things the first time out and then
remember them for all subsequent invocations.
● If the users want to change them, he can always request the printer options
dialog box.
● With this principle, we can easily track which facilities of the program the user
likes to adjust and which are set once and ignored.