Class notes for BIT-III semester

Chapter-1 The Goal.

AIM
Aim is to implement the basics and in-depth knowledge about user interface design. It enables
the students to take up the design the user interface, design, menu creation and windows creation and
connection between menu and windows.
OBJECTIVES
• To study the concept of menus, windows, interfaces.
• To study about business functions.
• To study the characteristics and components of windows.
• To study the various controls for the windows.
• To study about various problems in windows design with color, text, graphics.
• To study the testing methods

1.1 Goal directed design

1.1.1. The user’s goals:
The main goals are different from system to system and are depends up on the requirements of
the software owner. Some common goals of user are:
 Not looking stupid
 Not making any big mistakes
 Getting an adequate amount of work done.
 Having fun
In case of much higher aspirations, there are some much personal goals than work related:
 Be the best at what I do.
 Get onto the fast track and win the big promotion.
 Learn all there is to know about this field.
Even for the sociopath, goals don’t diverge from the focus on the individual:
 Learn the boss’s password
 Embezzle a million rupees.
Software that is rude:
Software is often rude to the user. It blames the user for making mistakes that are not the user’s fault.
Error message may occur repeatedly. It is difficult for the user to concentrate on the task when irritated
by set of interruptions that required acknowledgement by managing dialog boxes. Due to this, the user
might forget what he did just moment ago.

Software that is obscure:

Software is frequently obscure, hiding meaning, intentions and actions from the user. Features are
hidden behind dialogs and windows. How can the user know that the answer lies in the help system if he
can’t find the help system? Even when the user finds the right dialog box, he might find it populated
with obscure commands and components.

Software with inappropriate behavior:

- Software product will often forget the past history of set of commands and its effects.
 - Some software product will ask “Do you want to save it?” when we finish printing the document
and try to close it as if the contend of the document is changed due to printing.
- Appearance of obscure software products results in a situation called window pollution. With
pop ups, popping up all over and making navigation difficult.

1.1.2. The essence of user interface design: The quality that determines the character of user interface
design
- Good design makes the user more effective.
User Interface Design:
It is the parts of the computer and its software that people can touch, feel, talk to, or otherwise
understand and direct. It is a sub field to Human-computer interaction study.
User interface design is a subset of a field of study called human computer interaction (HCI). HCI is the
study, planning and design of how people and computers work together. User interface has 2
components: Input, Output. Input is how a person communicates his or her needs or desires to the
computer.
Ex. Keyboard, mouse.
Output is how the computer conveys its results of its computations and requirements to the user.
Ex. Display screen

Importance of good design:

It’s very important to our users. It is the window to view the capabilities of the system. The
reasons for inefficient and confusing design is,
No care on design
not enough time
not knowing what really makes good design
not possessing common sense.

A well designed interface and screen is very important to the users. It is the main window to view the
capabilities of the system. A screen design affects a person in a variety of ways. If the design is confusing
and inefficient, people will have greater difficulty and make more mistakes, Chase some people away
from the system. It also leads to aggravation, frustration and increased stress.

Benefits of good design:

 Poor clarity forced screens force the users to take more time to process. The screen clarity and
reability is done by making screens less crowded. Separate items are placed in separate lines.
 Reformatting enquiry screens with good design principles
 Increase productivity
 Good recognition of the system
The source for determining whether or not a feature should be included in a product. The driving force
behind the decision should not be that “

1.1.3. Features
 Most software that we run on our personal computers today is feature centric. A wildly
successful program like Microsoft word for windows offers hundreds of functions like paragraph
formatting, field insertion and so on. We could easily be considered as an expert user of word and we
know how to use each of these features in creating many different documents for running our business.
But not of these features are goal centric. If we have to write business letter, then we can find template
for it but if we want to write personal letter to our special person, then we could not. This is the demerit
of features centric user interface. In a goal centric user interface, user tells the program their goals and
it would tell each written features and how to behave to achieve them.

1.2 Software design:

1.2.1 Introduction:
If we look at mechanical devices, we can easily trace out that they have been carefully design
and engineer. On the other hand, if we carefully look at software product which is far more complex
than mechanical devices, we find out that such software products are not carefully designed.
For example, MS-Excel consists of 10,00,000 lines of code but complex fighter aircraft consists of only
10,000 parts. Such aircraft are found to be designed by professionals but there is still lack of such
professional when we come across the point of software design.
Minor errors introduce into the software products due to improper design can easily be tolerate by
experts and programmers.

The profession of software design:

More and more developers are thinking about design and viewing it as a separate discipline of
programming. Many observer of digital programming are being to see the professional software
designer and this train is very encouraging. Those who design software are called software designer.

1.2.2 Software design vs. interface design:

Software design is that portion of development process that is responsible for determining who the
program will achieve the user’s goal. The questions answered by this phase into:
1. What the software program will do?
2. What it will look like?
3. How it will communicate with the user?
User interface design is a subset of software design that encompasses items two and three, although it
is often difficult to separate them from item one.

1.2.3. Disciplines related to software design:

- There are some groups of professionals called usability professionals” who are not programmers,
however they specialized in the field of how people interact with software. They primarily conduct
interviews and focus groups with users, observe them using software observe them using software and
them evaluate the quality of user interfaces make recommendation.
- There is another discipline called “Human factor engineering or human computer interaction”,
research s the behavior of how people interact with computer.
- Another discipline is “cognitive psychology”. This discipline looks at how people think and understand
the world around them, particularly the technical artifacts they work with.
Human Computer Interface: The human–computer interface can be described as the point of
communication between the human user and the computer. The flow of information between the
human and computer is defined as the loop of interaction. The loop of interaction has several aspects to
it including:

1.3 Models of user interface design:

There are three different types of models in user interface design. They are:
1. Implementation model
2. Mental / Conceptual model.
3. Manifest model.

1. Implementation model (Programmer):

Implementation model deals directly with how things work. It describes the method of working of
the problem from technical and implementation point of view.
Examples:
a. A motion picture projector which is used in cinema hall to project movie on the screen uses
moving parts to create and illusion of moving picture. It shines very bright light, sometimes it
blocks out the light for split for fraction of movements and then it unblocks the light for another
movement. It repeats this process with a new image 24 times / per second.
b. Implementation models for electric wire plugged into the wall consist of reversal of electrical
potential 120 times / per second coming out from the outlet to the electrical appliances.
c. Implementation models for cellular phone conversation describe the fact that cellular telephone
swaps connections between a number of different cell antennas in the course of 2 minute
telephone call.

2. Mental / Conceptual model:

People don’t need to know all of the details of how some complex process actually works in order to
use it, so they create a mental short hand for explaining it that is simple and easy. A mental model does
not necessarily have to be true or accurate, and what it enables the user to work effectively. Mental
model describe the thing from the designers prospective. In other words, mental model reflects user’s
vision.
Examples:
a. In case of motion picture projector, users are not interested on the complex operation
mechanism of the projector. The user’s imagines that the projector merely throws onto the big
screen, a picture that moves. This is what called user’s mental model or conceptual model.
b. People imagine that when they plugged their electric wire into outlet, electricity travels upon
them through little black wires.
c. Cellular phones conversation users imagine that the sound they hear is coming through air.

3. Manifest model (Designer):

Computer software has behavioral face; which is made up by designer. Designer’s represent
software functioning independent of its true action through a model called manifest model. With the
help of manifest model, designer is able to hide some of the facts of how the software is really getting
the job done. This disconnection between what is real and what is offered gives rise to third model
called manifest model.

Designer

User understand Design User

complex objects easily
Hides complexity of
Example:
An operating system can make a network file server look as though it were a local disk, even
though the physical disk may be miles away which the users are not aware of.

1.4 Visual interface design:

Although GUI is greater than character based user interfaces, the vast majorities of GUI
programs irritate and annoy us in spite of their graphical nature. This is due to improperly designed user
interfaces. It is very easy to create program with a graphical user interface (GUI) that has same extreme
difficulty of use as DOS or UNIX application. The quality / Graphicness that make a user interface well
are user centric rather than technology centric. The two important user centric qualities that make user
interfaces good are: visual-ness of the software (Patterns) and the programs vocabulary.

Visual processing:
When we look at the complex seen out of the window, our brain gathers big chunks of the view
into manageable pieces building, street, sky, etc. called patterns. Unconscious mind is constantly
reducing visual input to patterns and conscious mind is constantly ordering those patterns into
hierarchies.

1.4.1. Visual patterns:

If our conscious minds have to deal with every data of what our eyes saw, we would be
overwhelmed with meaningless detail. The ability of our unconscious mind is to group things into
patterns based on visual clue what allows us to process visual information so quickly and efficiently. We
built effective visual interface from visual patterns. The visual interfaces most have recognizable visual
patterns. We create patterns in very simple ways. Possibly the simples is by creating recognizable
graphics symbol and giving them certain value. In visual interface, we create patterns by associating
symbols for the objects in the interface. If we are going to develop user interface for the restaurant, we
identify the fundamental elements in the user interface wand create the recognizable visual symbols for
each of these fundamental.
We must use the symbol everywhere the object is represented on the screen wherever the
object is, it must be accompanied by symbol. Due to this unconscious mind of user gets trained. This is
called “Visual fugue”.

1.4.2. Vocabulary:
The popularity of GUI is that they restrict the range of their vocabulary for communicating with users.
The input that GUI could aspect from the user is to reduce merely a three set of actions (click, double-
click, click-drag). In command line interface (CLI), the user can enter infinite number of commands
through virtually large number of character combination. In order for the user’s entry to be correct, he
needs to know exactly what the program aspects he must remember the letters and symbols with exact
precision the sequence can important. The capitalization can be vital. The 26 letters, 10 digits and
couple of dozen of other keys on keyboard are used for data entry purpose only in case of GUI based
program instead of infinite number of commands in case of CLI.
A properly formed vocabulary is shaped like inverted pyramid and is called canonical vocabulary. GUI
offers canonical vocabulary.

Idioms
Scrolling, Sorting
Application specific commands and feedback
Delete, create, Dialogs
draw
Compounds
Generic input and output actions and Edit Fields, Check boxes,
Double click, button symbols Highlighting
click, selection
Primitives
Smallest indivisible
actions and
Click, Drag, Key press feedback Cursor, Text
mechanism

Input Output

Fig. Canonical Vocabulary

The bottommost segment contains primitives the atomic elements of which everything the language is
comprised. This set should be as small as possible
The middle trapezoid contains compounds, which are more complex construct created by combining
one or more of the primitives. They are built from the elements below the pyramid. In GUI, it contains
actions like double click, click drag and manipulator objects like push buttons and check boxes.
The upper most layer contains idioms. Idioms combined compounds with knowledge of the problem
under consideration, domain knowledge. Domain knowledge is information related to the user’s
application area. The set of idioms opens the vocabulary to information about particular problem the
program is trying to address. In GUI, it would include things like OK buttons, caption bar, list boxes, file
icons and so on.
Any language or program that does not follow canonical vocabulary will be very hard to learn. Many
effective communication systems outside the computer would follow canonical vocabulary.
Chapter - 1 End
 Chapter 2. The form

2.1. Interface paradigms

There are three different paradigms for use interface design. They are:-
a. Technology centric paradigm: based on how thing works (a difficult proposition)
b. Metaphor paradigm: based on intuiting how things works (a risk method)
c. Idiomatic paradigm: based on learning how to accomplish things (a natural human process)

a. Technology centric paradigm:-

These interfaces are expressed in terms of their construction of how things are built. In order to
successfully use them, the user must understand how the software works internally. Following the
technology centric paradigm means our user interface design is entirely based upon implementation
model.
Most of today’s software is technology centric. It means there is one button per function, one dialog for
module Opcode and the commands in the interface reflects internal data structures and algorithm.
Engineers want to know how things work, so the technology centric paradigm is very popular among
them. Such interfaces helps engineers understand what is going on inside. But users may not be
interested on how thing are going on inside, they are interested on just using the software. Hence, even
though technology centric interfaces are popular among engineers, they are not popular among users.

b. Metaphor paradigm:-
Metaphoric interfaces relay on intuiting (guess) connections that the user makes between the visual
components in an interface and its function. When we talk about metaphors in the context of user
interface design we really mean visual metaphor.
A picture used to represent purpose: tiny scissors image on toolbar indicating cut function. We
understand metaphors intuiting although metaphors make thing easy to use and easy to understand,
they have following limitations.
i. Metaphors don’t scale very well. A metaphor that works well for a simple process in a
simple program will often fail to work well as that process grows in size or complexity.
ii. If the user doesn’t have the same cultural background as the designer, it is easy for
metaphor to fail. Even in the same or similar culture, there can be significant
misunderstanding.
iii. It may be easy to discover visual metaphor for physical objects like printers and document.
It can be difficult to find metaphors for the process, relationships and transformations, even
though they are frequently found to be used in most of the software. It can be extremely
difficult to find visual metaphor for buying a ticket, purchasing an icon, searching record,
setting format, changing resolution and so on.
iv. User interface which relies in metaphor for each and every aspect is called global metaphor
global metaphors indeed restrict the designers / users thinking.

c. Idiomatic paradigm:-
It is based on the way we learn and use idioms. Idiomatic user interfaces solve the problem of
previous two types of interfaces by focusing not on technical knowledge or institution but rather on
learning of simple non-metaphorical visual and behavioral idioms to accomplish goals and tasks.
Idiomatic interfaces don’t have associative connections the way metaphors do. The human mind has a
truly amazing capacity to learn and remember large number of idioms quickly and easily without relying
on comparison to know situation or an understanding of how or why they work.
 Graphical interfaces are largely idiomatic. Most of the elements of GUI are actually visual
idioms. Windows, title bars, close boxes, hyperlinks and drop down are things we learn idiomatically
rather than metaphorically. The mouse input device is not metaphoric but rather is learning
idiomatically. We don’t know or care how mouse work, and at even small children can operate that just
fine this is idiomatic learning.
Identically many of the familiar GUI elements that are often thought of metaphoric are actually
idiomatic. Visual elements like resizable windows, nested files and folders are not really metaphoric as
they have no parallel in the real world. They derive their strength only form their easy idiomatic
learnability.

“All idioms must be learned, Good idioms need to be learned only once.” Justify.
Graphical interfaces are largely idiomatic, understanding how to use interface is hard because of
implementation centric interfaces. These interfaces are hard to learn because we need to understand
how the software works internally to use them effectively most of we learn without understanding
things like faces, social interactions caste of people, attitudes, names, arrangement of rooms, furniture
in our house and offices and so on. We don’t understand why someone’s face is composed the way it is,
but we know the face we recognize it because we have looked at it and automatically memorized it. The
key observation about idioms is like that although they must be learn, they are very easy to learn and
good idioms needs to be learn only once. It is quite easy to learn visual idioms like title bar, menu bar,
drop down, pop up menu. The human mind is capable of understanding idioms like these on a single
hearing. It is similarly easy to learn idioms like radio buttons, close boxes, list boxes and combo boxes.

Idioms and branding:

Marketing professional know this idea of taking a simple symbol and then associate with meaning and
then advertise in idioms are found to be used in product branding , which company takes a product or
company name and gives it a desire meaning. WAIWAI by itself a meaningless word, an idiom the
chaudhary group has spent millions of rupees to make us associate that with that word tasty, simple,
hygienic and trustworthy. Of course idioms are visual too. Microsoft’s find windows the five interlocking
rings of the Olympics are idioms that are instantly recognizable and understood with common meaning.
Idioms are just as powerful as visual metaphors. The power comes from how we use them, rather than
from any connection to the real world objects.

Affordance:
Affordance is defined as the perceived properties of the things, primarily those fundamental properties
that determine just how the things could possibly be used.

Example:
- If a push button is placed on the gate of our house, its affordance is 100% door bell, while
pushing it, if we immediately fall into a huge hole then it doesn’t change its affordance to one.
We know it is a door bell simply because we have learned this type of push-able things by our
exposure to electrical and electronic devices in our environment.
- If we see a push button in an unlikely press like the hood of a car, we can’t imagine what it
purpose is but we can recognize that it is a finger push-able objects. We recognize it as a push-
able object because of our tool manipulating nature. We, as species see things that are finger
sized, placed at finger height, and we automatically push them, we see things that are long and
round, we wrap our fingers around them and grasp them. This instinctive understand of how
things are manipulated with our hands is called manual affordance.
2.2 usages of windows spaces and windows pollutions:
Our programs are constructed of two kind windows and subordinate windows like documents
and dialog boxes. If we imagine our program as a house, we can picture each window as a separate
room. The house itself is represented by the programs main window and each room is a document
window or dialog box. In real life we don’t add room to our house, unless it has a purpose that cannot
be served by other rooms. Similarly, we should not add window to our programs until and unless they
have a special purpose that cannot or shouldn’t be serving by existing windows.
Some designer’s take the approach that each dialog box should embody a single function. What
they end up with window pollution. Achieving many user’s goals involve executing a series off functions.
If there is single dialog box for each function, things can quickly get visually crowded and navigationally
confusing.
Example:-

Fig. Windows pollution.

The designer of the navigator was on a mission to put more windows in an interface. They have
one misunderstanding that “many windows are inherently good.” Moreover, the navigator was the
result of a large team of programmers working without an integrated frame work for the design. Thus
each modules function is expresses in a separate window or dialog box.
In the example shown in above navigator examining a saved piece of email from user’s point of view is
not three set of functions, but rather a single activity. A much better solution to the navigator problem
would have been to create a single mailbox with its tools strategically positioned in the top row- a
toolbar would be perfect for managing searches. Intermediate results of the search could be shown in
the window along with the final message itself. One goal finding and reading a message should be
implemented as a single dialog box.
2.3. File system:
The part of modern computer systems that is most difficult to understand is the file system, the facility
that stores programs and data files on disk. Every program exists in two places: in main memory and on
hard disk. The same is true for every file. However, most of the users are not aware of the difference
between memory and disk storage. The file system along with disk storage facility it manages is the
primary cause of dissatisfaction with computers among non-computer professionals.
Even though file system is an internal facility they have created a large problem because the influence of
the file system on the interface of most programs is very deep. Currently most software treats the file
system in much the same way that the operation system does.
Example:
When we close the file after editing it, MS-word prompts us the following dialog box:

The origin of this dialog box is not the user’s mental model, but rather programmer’s imagination of
implementation model. In other words, physical characteristics of the disk systems are imposed on the
user’s work habits. This dialog is so unexpected that new user’s often say “Don’t Save”.

Question: In what way does file system force user interface to follow implementation model instead of
user’s mental model? Explain.
 The implementation model of file system runs just opposite of the mental model. In other
words, users visualize two salient facts about all documents: first, there is only one document,
and second, it belongs to the user. The file system implementation model, violets both of these
rules. There are always, at least two copies of the document, and both belong to the same
program.
Every data file, every document and every program, while in use by the computer exists in a minimum
number of two places at once, on hard disk and in main memory. The user though imagines his resides
on the user’s hand. On the computer, the hard disk is the desk and main memory is the place where
editing text place, and equivalent to user’s hand. As the user makes changes to the document, he is
actually making changes to the in-memory copy, while the original remains untouched on the disk.
When the user is done and closes the document, the program is faced with a decision. It must decide
whether to replace the original on the disk with the changed copy from the main memory. From either
programmer’s or software implementation model point of view, there can be same such two choices.
But from the user’s point of view such choice is little upward. This is because user has already made
changes to the document and user is confused whether to replace original with the one from main
memory. It is as if taking of book from desk, underlining some paragraph on it and then replacing the old
book with the new one on desk, this is really awkward.

Question: what are the advantages when the user interface does not reflect underlining file system
complexity and follow user’s mental model instead?
 If file system follows users mental model we achieve significant advantages:
i. The non-computer literate professional can easily understand how to work on the
document and upon completion; they can store the document of the disk as though it was
book on the desk.
 ii. Software user interface designer won’t have to incorporate complex file system awareness
into their products; we can structure the commands in our program according to the goals
of the user instead of according to the needs of the operating system.
iii. We no longer need to call the left-most menu the “file menu”. This kind of older historic,
traditional culture shows how programs reflect technology and follows implementation
model. We can label this menu after the type of document we are processing.

Unified file model:

Properly designed software will always treat documents as single instances, never as copy or disk and
copy on memory. This is called unified file model. This model modifies the traditions saving, closing and
archiving operations on file in following ways;
Saving:-
In traditional model, saving means taking whatever changes the user has made to the in memory copy
and writing them on the disk copy of the document. In the unified file model, we eliminate all user
interface recognition of the two copies. So the save function disappear completely from the main
stream interface. Of course, this doesn’t mean that it disappear from the program.
The program will automatically change the document, when the user is done with the document and
request those function, the program will merely go ahead and right the changes out to disk without
stopping to ask for confirmation with the save changes dialog box.
In situation when user is editing the document and before he request close operation and in the mid
time if computer / software crash, power fails and other unpredictable happens, then our work will get
erased in such situation. If the power fails before we have pressed close, all of our changes will be lost.
The original copy on the disk will be all right but hours of work can still be lost. To prevent disk from
happening, the program must also save the document at certain intervals during the user’s session.
Ideally, the program will save every single little change as soon as the user makes it. In other words,
program will save after each keystroke.

Closing:-
There doesn’t exists any connection between closing and saving in a unified file model because there is
no concept of saving. We often close the document for abandoning unwanted changes we make in the
document. But this is not good idea. The UNDO function is the proper facility for eradicating changes.

When we answer “Yes” to the save changes dialog box, virtually every program then presents us with
the save as dialog box, functionally this dialog offers two things. It lets us name our file, it lets us choose
which directory we wish to place it in. both of these functions demand intent knowledge of the file
system. The user must know how to formulate a file name and how to navigate through a directory tree.
Many users easily know how to name files but it is difficult for them to understand directory tree
structure. They put all their documents in whatever directory the program chosen for default.
Occasionally, some action will cause the program to forget its default directory, and the user must call
an expert to find their files for them.
If the purpose of “Save as” dialog box is to name and place files, then it does a very bad job of it. For
renaming a file, experience user first closes the document, goes to the explorer, rename the file, return
to the application and ultimately with the help of file open dialog, reopen the document. If the user tries
to rename the file in the explorer without first closing the document in the application then he is
presented with a threatening error message “can’t rename, access is denied”, trying to rename and
open file is a sharing violation and the operating system rejects it with ta threatening error message.
Archiving: (to copy document): Archiving means making copy of a document. The user must accomplish
this with either “save as” dialog or the “copy command.”

Document management:

Let us design an application that manages document according to the user’s mental model. The
application will have following functions and each of these functions will try to meet user’s mental
model as far as possible.

- Creating a copy of document

- Naming and renaming documents
- Placing and repositioning documents
- Specifying the stored format of documents
- Reversing some changes
- Abandoning all changes
- Creating milestone copy of document

Creating a copy of document: There should be an explicit function called make snapshot copy, which we
create copy of the document which is identical to the original. The new copy should be given a name
with the standard form like “copy of first” where first is the name of the original document. If there is
already a document with that name the new copy should be named second copy of first. The copy
should be placed in the some directory as the original.

Naming and renaming documents: The name of the document should be shown right on the
applications toolbar. If the user decides to rename the document, he can just click on it and edit it.

Placing and repositioning document: Most documents that are editing already exist. Their position in
the file system is already established. The file in fact should be placed somewhere reasonable where the
user can find it again. If the user wants to explicitly place the document somewhere in the file system
hierarchy. He can request this function from the menu. The dialog boxes appear with the current
document being highlighted. The user can then move the file any desired location with the help of that
dialog box. The dialog boxes will thus reposition files.

Specifying the stored format of documents: There is an additional function implemented on the “save
as” dialog box. The combo box at the bottom of the dialog box allows the user to specify the physical
format of the file. This function should not be located there. By trying the physical format to the act of
saving, the user is confronted with additional complexity. Saving should be a very simple act. In MS-
word, if the user innocently changes the format, both the save function and close action are
accompanied by a frightening and unexpected confirmation box.

Reversing some changes: If the user make some changes to the document that must be reversed, the
tool already exist for correcting those sorts of actions: UNDO. The file system should not be called for
undo.
Abandoning all changes: There might occurs situation when user’s decide that he wants to discard all of
the change he has made since opening or reading a document, so this action should be explicitly
supported. Rather than forcing the user to understand the file system to achieve this goal, a simple
“abandon” function on the main menu should be provided. Because this function involves significant
data loss, it should be protected by clear warning signs.

Creating milestone copy of document: Making a milestone is very similar to using the copy command.
The difference between copy and milestone is that milestone is managed by the application after it is
making whereas copy is not. The milestone dialog box lists each milestone copy along with various
statistics about it, like the time the document was created and its length with a click, the user can select
a milestone copy and by doing so, immediately make it as the active document.

The new file menu looks like as following:

The revised file menu now reflects the user mental model instead of the programmer’s mental model.
There is only one file and the user owns it. If user want, can make copy of it, discard a changes he has
make to it or change its format. He doesn’t have to worry about the copy in RAM and the copy on disk.

Storage and Retrieval system

In order to find the particular document, we must have to store it first.

Storage system: It is a tool for placing goods into a reposition for safe keeping. It is composed of physical
contains and the tools necessary to put objects in and take their back out again.
Retrieval system: it is a method of finding goods in a repository. It is a logical system that allows the
goods to be located according to same abstract value, like its name, position or some aspect of its
contained.

Retrieval method:
There are three fundamental ways to find documents:
1. Positional retrieval: find a document by remembering where we save it.
2. Identity retrieval: finding a document by remembering its identifying name.
3. Associate retrieval: find a document based on some inherent quality of the document itself.
For example:- finding a book with red color, or one that contains photographs of Himalayas or one that
describes VB in detail is associative retrieval.
Positional and identity retrieval are applicable and storage system whereas associative retrieval is
applicable for storage system. Associative search is entirely based upon the user’s memory. He must
know what information he wants and where it is stored in order to find it. In order to find any document
in whi8ch he has calculated salary of employees, he has to know that he stored that inside the directory
named “payroll” and the name of the file is “pay.xls” if he does not remember either of these facts,
finding the document car becomes quite difficult.
An associative retrieval system would enable to find the documents by their contents. For example we
could find all documents that contain the string “BIT-4th”. An associative retrieval system would also
help user create groups of document system would also enable the user to browse by synonym or
related topics or by assigning attributes to individual documents.
The system can learn a lot about each document just by keeping its ears and eyes open. If the
associative retrieval system remembers of the following information, much of the user’s burden will get
eliminated. The program could, for example, remember things such as:
- The date and time the document was last open.
- The amount of information that was added or deleted during the last edit.
- Whether the document has been edited by more than one type of program.
- If the document is frequently edited.
- Whether the document has been printed and where.
- Whether the document has been faxed ad to whom.
- Whether the document has been emailed and to whom.
- If the document is frequently viewed but rarely edited.
The retrieval system could find documents for the user based on these facts without the user ever
having to explicitly record anything in advance.

2.4 Platform Dependence:

Before designing an interface for our software product, interface designer must decide which platform
the products will ultimately going to operate on. Designer must decide whether to write software for
UNIX, the Macintosh or the Microsoft platform or for all of them. They must also decide whether to
support the older, weaker hardware out there. We must replace the entire desktop computers that are
based on older technology with new one before we install newer software product in our business.

Development platform:
Developers generally develop software that is compatible with all existing hardware. Due to the fear of
too many expenses to replace all of the computers, the management team encourages developer to
support the five-six or even seven years old computers. Poor management team doesn’t know the fact
that developing software that supports both older and newer hardware is greater than developing
software that supports more powerful newer hardware. Hence management team spends more money
on software thinking that it will save more money in spite of spending on new powerful hardware;
which could have saved more money for them. Hence it is the responsibility of the management team to
assure that the computer’s on desktops throughout the organization are as modern as possible when
the software is ready.
We must develop software product focusing on those hardware that will come in market in near future
in coming one-two years of time duration. This is because usually it takes six or twelve month of time to
develop a software product and when our software will get released in the market, more new hardware
would have already come. Moreover, we must first purchase the right software before we buy the
computers that run on it and not vice versa.

Multiplatform development:
As it is difficult to kill two birds with one stone simultaneously, we should not develop software that
simultaneously supports more than two platforms. We can develop software that by making source
code more complex or making interface homogeneous.
Anything that increases the complexity of source code should be avoided. This is because it will magnify
the time it takes both to write and debug. Each design decisions must now be make for two different
platforms. The primary responsibility of software developer is to reduce the delay and complexity. Since
simultaneous multiplatform development causes more delay and complexity this results in poor quality
software.
There are several commercial libraries available, which helps to develop software on multi-platforms.
We generally develop user interface for these generic GUI, which the library runs for each platform. The
primary drawback of this approach is that, GUI in each platform will have consistent look and feel.
Instead, libraries user demands GUI to have their own Linux have look and feel, windows user’s demand
their own and so on. Hence there will be more dissatisfaction among users.

Interoperability:
Many applications are brought to windows after they had a long run on DOS, windows programs must
support their predecessor DOS. Thousands of satisfied customers on DOS wants to move on windows.
They will be in fact disappointed if the program is different from what they already know and love. Many
of the corporate customers work in heterogeneous environment and they want the window version to
work the same way as their DOS system. These concepts are called interoperability.
People demand interoperable system because of fear. They worked so much hard to learn DOS version
that they fear going through the process again on windows. By demanding interoperability they hope
that they will be able to take their hard-earned expertise straight across the new system. It is in fact not
that much difficult to run application in windows than DOS. Since people don’t believe this, they
demand interoperable system. Interoperable system is bad ad we must avoid them.
If we are going to create windows version of a program, go ahead and create windows version don’t
develop its corresponding DOS counterpart to please DOS users. If DOS user wants run it, then they
must have to learn the windows system to know how to use it. It is that much simple.

Chapter – 2 End
Chapter:- 3 Software behavior

3.1 Flow:-

When people are able to concentrate whole heartedly on an activity, they loss awareness of peripherals
and distractions. The state is called flow. Flow can be described as a condition of deep, nearly meditative
involvement. Most significantly, a person in a state of flow can be extremely productive, especially when
engaged in some process oriented task such as engineering, design, development and writing. Today
these tasks are typically performed on computers while interacting with software. Therefore, we have to
develop software interaction that promotes and enhances flow rather than one that includes potentially
flow breaking or flow disturbing behavior. If the program consistently makes the user out of flow, it
becomes difficult for him to regain that productive state.

Techniques for maintaining and making flow:

To create flow, our interaction with software must be transparent. In other words, the interface must
provide service to the user; provide what he needs at right time and in the right place. There e several
techniques for maintaining flow. They are:

1. Flow mental model

2. Direct, don’t discuss
3. Keep tools close at hand
4. Provide modeless feedback
1. Flow mental model:

Different users will have different mental models of process. Each user naturally form a mental image
about how the software perform its task. The mind looks for some pattern of cause and effect to gain
inside into the machine behavior.

If we look at hospital information system, doctors and nurses will have their own mental model of
patient information. Similarly, the business clerk will have their own mental model of patient
information. Doctors and nurses will like to find the patient information by using names of patient as an
index. Each doctor and nurse has certain patients, so it makes additional sense to filter the patient in the
clinical interface, so that each physician can choose from a list of their own patients, organized
alphabetically by name. on the other hand, business clerk want patient information on the basis of
overdue bills. The business clerk interface sort patient information first by overdue bills and patient
names secondly.

2. Direct, don’t discuss:

Most people like to interact software in the same way a carpenter interacts with nail. When the
carpenter hits the nail, he doesn’t discuss the nail with the hammer; he directs the hammer on to the
nail. In a car, the driver gives car a direction. The car neither asks any question to driver nor does the
driver answer any questions raised by car. One of the main reason software upsets user is that it doesn’t
act like a car or hammer; instead software presents user so many dialog boxes to inform users of their
short comings and to demand as answers from them. The better and more flow inducing interfaces are
those with direct manipulation capabilities.

3. Keep tools close at hand:

Many program offer variety of tools in order to deliver its functionality effective and efficiently to users.
Using tools provided by software user can perform their work such that their flow will not get disturbed
and these tools support in maintaining users flow while interacting software suing these tools. Tools
should be close at hand, preferably on toolbars. This way, the user can see them easily and can select
them with a single click. If the user must divert his attention from the application to search out a tool,
his concentration will be broken and ultimately his flow will get disturbed.

4. Provide modeless feedback:

When the program has feedback or information for the user, it has several ways to present it. The most
common method is to pop up a dialog box on the screen. The dialog box is usually model; it puts the
program into a mode that must be deal with before it can return to its normal state; and before user
continue with his task. A better way to inform it to use modeless feedback.

Feedback is modeless whenever information for the user is built in to the normal interface and doesn’t
stop the normal flow of system activities and interaction. In MS-word, we can see what page we are on,
how many pages are there in the current document just by looking at the status bar at the bottom of the
screen. Similarly, find, replace dialog boxes are example of modeless dialog box wherever save, save as
dialog boxes are modal dialog box.

Sensible interaction:

One of the essential parts of a good interface is interacting with the user in a sensible or practical
manner. But most user interface violets this statement. The file manager program in windows 3.1
violated the above statement. Every time when we want to rename a file it displays following dialog box.

The above dialog box suffered from following limitations:

i. The first field in the dialog box is unnecessarily place there as it has no role while renaming a
file. It unnecessarily creates problem only.
 ii. If we forget to type extension “.doc” in the second field and type only file name, next time
we can’t open that file with windows file manager program.
iii. The program doesn’t alert us about the failure.

Flow of states:

Microsoft windows normally have three different states:

a. Minimized
b. Maximized
c. Pluralized (Restored)

Need to minimized window:-

- We minimize windows to switch from one application to another. We minimize the active
program, and then maximize the icon of the desired program. To switch back, we reverse the
sequence. However, we can do this with Alt-Tab key sequence.
- We minimize program to reduce clutter or our screen. If we run several applications in a
pluralized state then our screen will become clean and then clear if we minimize all windows
except one that we are currently working with.

Need to pluralized windows:-

- Sometimes there might require situation when we want to run two or more windows side by
side, then in such cases we must have pluralized such windows. However if we want to run
application and transient application on top of it, then in such cases pluralization may become
unnecessary.
- If the user want program to program drag and drop facility then both program must be
pluralized. Normally transient programs are used in pluralized state.

Multiple document interface (MDI):-

MDI is a new method for organizing the functions in a windows application. If satisfied the need of most
categories of applications, mainly those that handled multiple instances of the single type of document
simultaneously word, excel. If we want to copy the content of one MS-word document and paste it to
another we must have two MS-word program that can contain two or more MS-word instances inside of
it. Or we can have multiple instances of the entire MS-word program. The second option is good though
demands high performance equipment. Earlier version of windows chooses the first option but modern
windows are equipped with lager option due to their high performance in nature. MDI is finding as long
as there are not more than one type of document in a single program, otherwise confusion might arise.

3.2 Overhead:-

There are two different types of task, one is revenue task which solves the problem directly and other is
excise task which don’t solve the problem. The excise is in fact the extra world that we must have to do
achieve our goal. The problem with excise task is that the effort we put in doing them does not directly
reach towards goals, rather increases overhead only. Excise must be eliminating as soon as possible,
they are same as infections.

GUI excise:-

With windows system user’s must open various folders looking for the desired file or program before
they can launch it; then one it appears in the screen, they must stretch and drag the window until it is at
the desired location and configuration. Extra window manipulation task such as these are indeed excise.
They don’t lead the user towards his goals rather they are overheads that the programs demands before
they actually assist the user. With a command line system, user just type few commands and the
computer responds it immediately. Command line interface puts a lot of excise on user. For example
user must first memorize all commands in using them and the command line screen occupies the whole
screen making it dirty.

Visual metaphoric excise:-

Designers bring excise into user interfaces by relying too heavily on visual metaphors like desktop with
telephones, file cabinets etc. these visual metaphors may make it easy to understand the relationship
between program elements and behaviors, but after these fundamentals are learn, and the
management of metaphors becomes pure excise. The more we become familiar with the interface day
by day, we will get bore by these visual metaphors.

Pure excise:-

There is number of actions that are excise of such purity that nobody needs them from power users to
first time users for e.g.:- telling the program which COM port to use.

How to determine which task is excise?

If any task doesn’t lead directly to users goal, than it can be consider as an excise task.

Removing feebleness:-

Factors that will help to eliminate excise from user interface:

1. Don’t force the user to go to another window to perform a function that affects these window.
2. Don’t force the user to remember where he put things in the file system.
3. Don’t force the user to resize, move windows. Don’t make it small or big such that it requires
scrolling.
4. Don’t force the user to re-enter personal settings.
5. Don’t let user’s actions result in an error.

3.3 Task coherence:-

The idea that we can predict what a user will do by simply remembering what he did last time is based
upon a simple principle called task coherence.

Function he uses and the way he use them will be very similar to what he did last time when he used
that program. Certainly, he won’t be doing the exactly the same thing each time, but it will likely be
variants of a small no. of repeated patterns. With significant reliability, we can predict the behavior of
our users by simply remembering what he did the last several times when they used that program. This
allows us to greatly reduce the number of questions that programs must ask to the user. This is benefit
of applying task coherence principle to our software product.

The way to determine what information the program should remember is guided by a simple rule. “If it
is worth asking the user, it is worth the program remembering”. Any time our program finds itself with
choices and especially when that choice is being offered to user, the program should remember this
information instantly. Instead of asking the user to make a determination, the program should go ahead
and make the same. Let the user changes it if it was wrong. Whatever options the user set should be
remember so that options remind in effect until manually changed. If the user ignores the facility of the
program or turns them off, they shouldn’t offer to user again. The user will seek them again when he is
ready for it to use. The program must remember more than just the last place the files were accessed.

Decision set streamline:-

In order to apply task coherence principle in user interface our software must have memory. We tend to
reduce an infinite set of choices down to small, finite set of choices. Even when we don’t do the exact
thing same time, we will tend to choose our actions from a small, repetitive set of options. This principle
is called decision set streamline.

Example:-

Although most people choose drive home from work the exact the same way, every evening, some
people drive home different way every night. However, these people will choose from a set of 4 or 5
routes that rarely changed. Computer’s in-fact can remember 4-5 things without any difficulty.

Decision set streamline guides us to the idea that pieces of information that the program must
remember about the user’s choice tend to comes in groups. Instead of their being one right way, there
will be several options that are all correct. The program must have the capacity to differentiate which
one of the smallest set is correct. Hence, decision set streamlines principle supports task coherence
principle by minimizing the decision set and thereby enabling our program to decide from this smallest
set.

Preference thresholding:-

The decision that we make are of two types: important decision and non-important decision. Usually
any activity involves 100s of decisions but very few of them are important. Most of them are non-
important. This principle is called preference thresholding.
If we ask the user to make a lot of decisions to perform any task in our software, then such unnecessary
decisions will indeed not satisfy the user. Once the user asks to print, we don’t have to ask him how
many copies he wants or whether the document should be printed in landscape or portrait format. We
can make an assumption about these things the first time and then remember these things for all
subsequent future actions. If the user wants to change them, he can always request through the printer
options dialog box.

Using preference thresholding, we can easily track which facilities of the program the user likes to adjust
and which are set once and ignored. With this knowledge, the program can offer choices where it has
pretty good expectations that the user will want to take control, while simultaneously not bothering the
user with decisions they won’t be interested in.

Chapter – 3 End