Why are HumanComputer Interfaces Difficult to Design and Implement

1
Why are Human-Computer InterfacesDifficult to
Design and Implement?
Oded Bar-El and Yariv Oren
2
A bit about the author

• Brad A. Myers
• Senior Research Scientist,Human Computer
  Interaction InstituteSchool of Computer
  ScienceCarnegie Mellon UniversityPittsburgh,
  USA
• http//www-2.cs.cmu.edu/bam/

Worked as a consultant for many companies in the
last 15 years Some of them are famous some of
them less, also wrote several books on creating
and designing User Interfaces.
3
Whats this about ?

• Everyone knows that designing and implementing
  human-computer interfaces is difficult but there
  is little discussion of WHY this is true

4
Overview

• Why are user interfaces important?
• What makes user interfaces difficult to design?
• What makes user interfaces especially hard to
  implement?
• Conclusions
• Reference
• Discussion

5
Why are user interfaces important?

• Time is valuable, computer users expect to be
  able to sit down and use software with little or
  no frustration and they want to spend their time
  accomplishing their goals, not learning how to
  operate a computer-based system
• Although industry has invested heavily in
  Information Technology, productivity has not
  improved as expected. Why? Usability!
• There is evidence that attention to usability
  decreases costs and increases productivity

6
Some numbers

• A study showed savings from usability engineering
  of 41,700 in a small application used by 23,000
  marketing personnel, and 6,800,000 for a large
  business application used by 240,000 employees.
• A mathematical model based on 11 studies suggests
  that software which has undergone thorough
  usability engineering will save a small project
  39,000, a medium project 613,000 and a large
  project 8,200,000

The source for the above values and estimations
is the article itself, and might be irrelevant
for todays calculations.
7
More numbers

• Predicting that a new workstation for telephone
  operators would decrease productivity resulting
  in the decision not to buy it is credited with
  saving NYNEX an estimated 2 million a year

The source for the above values and estimations
is the article itself, and might be irrelevant
for todays calculations.
8
How come?

• Decreased task time
• Fewer errors
• Greatly reduced user disruption
• Reduced burden on support staff
• Elimination of training
• Avoiding changes in software after release

9
What makes user interfaces difficult to design?

• 1. Designers have difficulty learning the users
  tasks
• 2. The tasks and domains are complex
• 3. There are many different aspects to the design
  which must all be balanced, such as standards,
  graphic design, technical writing, performance,
  internationalization, multiple levels of detail,
  social factors and legal issues.
• 4. The existing theories and guidelines are not
  sufficient
• 5. Iterative design is difficult

10
1. The difficulty learning the users tasks

• Specifications are usually wrong, ambiguous or
  incomplete. In part, this is because they are
  developed by people who do not understand the
  real problems faced by the end users
• In most cases, specifications are given by the
  designers, the implementation is done by the
  programmers while the actual day-to-day use is
  done by the customers
• Users may not know what they want, so having them
  on the design team is not a solution
• The users have little knowledge of what is
  possible and what is not in the application
  level, so they can have too low expectations on
  one hand, and too high ones on the other

11
The difficulty learning the users tasks (Cont.)

• Developing correct specifications may not be
  solvable, because a true understanding of a tool
  can only come through usage
• Sometimes you find out youre missing something
  only when youre looking for it.
• So you can find out that you missed something
  only when you actually find yourself trying to do
  this operation. The problem is that by then,
  adding this feature is a great overhead, if
  possible at all.
• Users are extremely diverse
• Some users would like one layout with a specific
  set of operations, others will prefer a different
  layout, with a different set of operations

12
The difficulty learning the users tasks (Cont.)

• Programmers have a difficult time thinking like
  end-users
• Whats obvious to the programmers, is not always
  obvious to the user who is not familiar with the
  system internals or the computer world at all.
• For example, when an office application (Word) is
  open with no documents presented, as a programmer
  you know that theres nothing to save and you
  might miss handling this kind of operation or
  disabling it.However, an inexperienced user,
  might try to click on Save.

13
2. The inherent complexity of tasks and
applications

• Complex and advanced applications with many
  functions will never have an interface which is
  as easy to learn and use as simple applications

The Cessna 172 Cockpit
The Concorde Cockpit
14
The inherent complexity of tasks and applications
(Cont.)

• A good example for an exception to the previous
  slide, is Segway company, who invented the Segway
  HT (Human Transporter), which is relatively
  complex, but still has a very simple UI, which
  consists of
• Steering Grip
• A key slot (which determines the performance
  level)
• A display in the shape of face, for general
  status.

Demo Movie
15
The inherent complexity of tasks and applications
(Cont.)

• A single, generic application must work for a
  variety of users and domains (Microsoft Word has
  dozens of ways to move the cursor)
• Some people will find it easier to use the mouse,
  other will feel better using the arrows keys on
  the keyboard, while other will get used to using
  shortcuts ( like End, Home, ShiftA in vi and
  more ).

16
3. The variety of different aspects and
requirements

• All design involves tradeoffs, but it seems that
  user interface design involves a much larger
  number of concerns
• Standards An interface will usually need to
  adhere to existing standard user interfaces such
  as Mac or Microsoft Windows.
• Graphic Design An important part of the user
  interface is the graphical presentation,
  including the layout, colors, icon design and
  text font.
• Documentation Clear messages and help text as
  well as good documentation has more impact on the
  usability than changing the interface style.

17
The variety of different aspects and requirements
(cont.)

• Internationalization Many products today will be
  used by people who speak different languages, but
  we need to translate more than plain text.For
  Example dates, currency symbols, time formats and
  new icons.
• Example Lets meet on the 11/12/2002Is it
  tomorrow or next month ?
• Performance Users will not tolerate interfaces
  that perform too slowly
• High-level and low-level details It is not
  sufficient to get the overall model, we have to
  make sure that the low-level details are perfect
  as well.

18
The variety of different aspects and requirements
(cont.)

• External factors Many systems fail for
  political, organizational, and social reasons. If
  the user will think that using the software will
  threaten their job or status, they will not like
  it, regardless of the user interface.
• So when designing a UI you must make it suitable
  for all people, regardless of sex, nationality,
  origin and other social aspects, so nobody will
  get hurt from your UI design.

19
The variety of different aspects and requirements
(cont.)

• Legal issues One way to get a good design is to
  copy a design that has proven to be workable and
  popular, the problem is that this is not always
  legal

• Lisa 2 was introduced in January 1985 by apple.
• The UI is strongly similar to MS Windows, but
  Microsoft released Windows 3.1 ( which is the
  basis for todays MS UI design) only in 1990.

20
The variety of different aspects and requirements
(cont.)

• Time to program and test There is a tradeoff
  between testing time and a perfect UI, and the
  time to release the product to the market. If you
  will spend more time on the UI design it will be
  better, but it will be on the shelf late .
• Others Interfaces that are aimed at special
  audiences have additional concerns, like special
  input devices (touch screens, writable surfaces),
  audio support and visual affects for people with
  disabilities

21
4. Theories and guidelines are not
sufficient

• There are many methodologies, theories and
  guidelines for how to produce a good user
  interface
• Although there are a number of reports of
  successful systems created using various
  methodologies, evidence suggests that the skill
  of the designers was the primary contributor to
  the quality of the interface, rather than the
  method or theory
• In Hebrew we say ??? ??? ???? ??????
• In English Theres a difference between knowing
  the path and following the path

22
Theories and guidelines are not sufficient (Cont.)

• In fact, there are important counter-examples to
  even the most basic guidelines
• So even if you adopt one of the many theories and
  methodologies it is not a guaranty to a perfect
  UI.
• Some things you can only acquire through good
  skills and experience.

23
For Example

• Most sources put consistency at the top of lists
  of guidelines, but there are many cases where
  consistency is not appropriate. For example, menu
  systems might have the default selection be the
  more recent or most likely selection, but still
  should not use this rule for questions confirming
  dangerous operations or actions that might cause
  data loss.
• So if we will follow the book recommendations, we
  might find ourselves causing distraction to the
  user, causing him to reboot his computer

24
(No Transcript)
25
(No Transcript)
26
5. Iterative Design is difficult

• Iterative design Getting something up quickly,
  analyzing the results, and making improvements
  based on that analysis

27
Iterative Design is difficult (Cont.)

• Imagine the type of conversations that would
  occur if cars were designed iteratively
• Designer So the steering wheel came off in your
  hands. Looks like we'll have to fix that one.
• Designer Your back tire blew out when you were
  going 60 miles an hour. Hmm... We'll have to
  solve that one in the next iteration.
• We can't predict how users will react.We see
  how the user reacts then we react to the user. -
  user friendly approach?
• I know how I react when I find a badly designed
  Web site. I leave and I don't come back. How does
  a designer react to that?
• (Garry McGovern Web consultant)

28
So what makes iterative design so difficult

• Can be quite long and expensive.
• Inputs on UI are endless, since what seems to be
  good for user X, will be bad for user Y, so when
  you fix something, you will most probably get
  inputs both in favor of and against the change.
• It will require to go back to the drawing table,
  over and over again, as well as causing delays to
  the products release.
• The designers intuition on how to fix an
  observed problem might be wrong, and cause the
  new version to be worse than the previous.

29
Iterative Design is difficult (cont.)

• Changes made to improve one usability problem,
  may introduce other usability problems.
• As opposed to bug fixing where the number of the
  bugs is decreased as you fix them, in the case of
  UI design when you change something in the design
  you introduce a number of new changes that need
  to be done, so instead of a convergence process
  you have a diversion process.
• Many iterations on a bad UI design will never be
  as good as a UI which was well-designed from the
  beginning
• The first design binds the designer, both when
  thinking on a new idea, and when trying to
  improve a previous UI design.
• Like the Peugeot 206 TV Commercial

30
Iterative Design is difficult (cont.)

• A usability lab may cost between 70,000 and
  250,000 in capital costs to set up, plus
  professional staff. When contracted out to a
  consulting firm, a single usability test may cost
  between 10,000 and 60,000, and when performed
  in house, 3000 to 5000.
• The costs are considerable and it can take a long
  time, which conflicts with the desire to get
  products out quickly.
• Using a lab is not a Magic Solution. Usually a
  lab will tell you what it wrong, and not how to
  fix it, which means going back to the drawing
  table
• The amounts indicated were calculated at 1993

31
So what?

• The implication of these requirements is that all
  user interface design involves tradeoffs and it
  is impossible to optimize all criteria at once.
• Unlike other SW design, some of the issues can
  not be solved by dedicating more time or more
  manpower to the project. This issues will be
  raised on any design of any UI probably at any
  time

32
What makes user interfaces especially hard to
implement?

• 1. They are hard to design, requiring iterative
  implementation
• 2. They are reactive and must be programmed from
  the inside-out
• 3. They inherently require multiprocessing
• 4. There are real-time requirements for handling
  input events
• 5. The software must be especially robust while
  supporting aborting and undoing of all actions
• 6. It is difficult to test user interface
  software
• 7. Limited language support for UI development.
• 8. The tools to help with user interfaces are
  extremely complex
• 9. Programmers report an added difficulty of
  modularization of user interface software

33
1.The need for Iterative implementation

• The first reason that user interface software is
  difficult to implement is the need to use
  iterative implementation
• Conventional software engineering according to
  the waterfall approach is specification -gt
  implementation -gt testing. In the case of UI we
  might need to go back to specification after
  testing.
• For example in the case when our UI is tested and
  we found out that its too complex to use, maybe
  we should change the specification

34
2. Reactive Programming

• inside-out the user should be in control
  and not the application.
• The program needs to be able to deal with a very
  large number of inputs operations by the user
• The programs execution is user dependent and
  requires frequent interaction with the user
• Requires many subroutines, each should complete
  execution before the user is ready to give the
  next command.

35
Reactive Programming (Cont.)

• Unlike usual programs, UI should be built from
  the low level operations of each widget to the
  complete UI and main program, and not from the
  high level procedures, to the low level.
• When building the program, we should start from
  the operations that each widget does, and then
  combine one widget to another, and to the
  application engine
• On non-UI program, you first build the main
  function, in pseudo code, and than start to build
  each one of the components.

36
3. Multiprocessing

• In order to be reactive, user interface software
  must be organized into multiple processes.
• Users expect to be able to abort and undo actions
• When the process ends its running and dies, undo
  might be complex.
• Application should be able to accept input events
  at all times, even while executing commands in
  the background of the application (printing,
  searching, global replace, re-paginating a
  document, repainting the screen)
• Window system itself often runs as a separate
  process than the application engine.

37
Multiprocessing ( Cont. )

• Using ongoing dialogs, running in different
  windows, requires multiple processing.
• The programmer must consider the application
  working environment and requirements from the
  system (both hardware and OS)
• In non-UI software, if the program will take 10
  more running time than expected its not
  critical, at least not in most cases.
• In UI software it can distinguish between good UI
  and unbearable UI.
• Suppose youre using Linux OS on a relative slow
  computer.
• If you will run Graphical Desktop (KDE for
  example) the response will be very slow, which
  can cause the user to abandon the system.
• If you need the system only to run simulation
  program of a chip, which usually take 6 hours,
  if it will take a bit longer, is not critical,
  since you will probably do something else, till
  it ends.

38
4. Need for Real-time Programming

• Some UI control applications function in
  real-time and contain controls over real-time
  objects, for example. Animation creating, or
  video Audio editing.
• Objects must be displayed between 30 and 60 times
  a second without uneven pauses.

Nero Wave Editor
39
Need for Real-time Programming (cont.)

• Any processing to calculate feedback must be
  finished in about 16 ms
• In non-UI application, the next procedure can run
  as soon as the program and the system is ready to
  run it, so the calculation time, is only part of
  the total running time.
• If one of the low-level procedures is not
  optimized in the mean of running time, the
  computer will wait for the calculation to end,
  before running the next command.
• In case of UI, the user will have to wait for the
  calculation to end which can be frustrating.

40
5. Need for Robustness

• All inputs must be gracefully handled
• Must always accept any possible input and
  continue to operate.
• Suppose your UI is controlling MRPV (Mini
  Remotely piloted vehicle ) or ???"?.
• If theres an error in the application, it will
  be unbearable that because of illegal input, the
  program will be shutdown and the MRPV will crash.
• When a user unintentionally enters an incorrect
  input which causes the application to shut down
  without any clear message but instead something
  like Sorry - a general error has occurred and
  therefore the application has shut down, its
  frustrating and the user will stop using this
  application, or do so only as a last option.

41
Need for Robustness (Cont.)

• When an erroneous input is discovered, interface
  must respond with a helpful error message, and
  allow the user to start over or repair the error
  and continue
• Need to allow the user to abort and undo any
  operation
• This means for the programmer that a log of all
  or at least latest actions, must be kept, and
  that all actions can be un-done or re-done.

42
6. Low Testability

• Automated testing tools are rarely useful for
  direct manipulation systems, since they have
  difficulty providing input and testing the output
  of the UI.
• Most operations are changes made to the screen
  and cannot be tested by automatic problems.
• The Interface layout may change, making the
  testing using transcript almost impossible.

43
7. Minor Language Support

• In the past, many programming languages did not
  contain the appropriate features for user
  interface such as graphical input and output and
  multiprocessing, and therefore large external
  libraries had be used instead
• Some language features were identified to make
  the creation of user interface software easier,
  like OOP
• One reason C is gained its popularity is the
  recognized need for an object-oriented style to
  support user interface programming, but C has
  no graphics primitives or support for
  multi-processing or reactive programming

44
Minor Language Support (cont.)

• The paper was written in 1993, before today UI
  languages were introduced.
• Although VB was introduced at 1991, only at the
  summer of 1993 VB gained its popularity.
• JAVA which has built-in packages for GUI design (
  AWT Swing ) was introduced at 1995
• Today these languages as well as other has an
  easy programmers interface for creating GUIs,
  both in the Microsoft Windows environment and in
  the Unix / Linux environment.
• However, even today, the UI languages, dont
  cover the entire space of computer systems, and
  some of the languages are still limited and
  complex.

45
8. Complexity of the Tools

• Back in 1993, since the programming languages
  were not sufficient, a large number of tools have
  been developed to address the user interface
  portion of the software. Unfortunately, these
  tools are notoriously difficult to use. Manuals
  for the tools often run to many volumes and
  contain hundreds of procedures. For example, the
  Macintosh Toolbox manuals now fill six books
• Some tools even required the programmer to learn
  an entirely new special-purpose programming
  language to create the user interface (e.g., the
  UIL language for defining screen layouts for
  Motif)

46
Complexity of the Tools (Cont.)

• Although technology has evolved greatly since
  1993, and more simple and intuitive UI tools were
  introduced, they still do not provide sufficient
  flexibility to achieve the desired results.

47
9. Difficulty of Modularization

• One of the most important ways to make software
  easier to create and maintain is to appropriately
  modularize the different parts.
• The purpose is that the software will be built
  from several Building blocks which can be
  combined and separated relatively easily.
• The standard demand in textbooks is that the user
  interface portion should be separated from the
  rest of the software, in part so that the user
  interface can be easily changed (for iterative
  implementation).

48
Difficulty of Modularization (Cont.)

• Unfortunately, programmers find in practice that
  it is difficult or impossible to separate the
  user interface and application parts.
• Each widget requires at least 1 procedure to run
  when the widget is activated.
• When you change the widget function, it usually
  requires a change in the Application Engine as
  well, which ties the application with the UI, and
  creates dependencies which are hard to break in
  most cases.

49
Conclusions

• While the design and implementation of all
  complex software is difficult, user interfaces
  seem to add significant extra challenges.
• While we can expect research into user interface
  design and implementation to continue to provide
  better theories, methodologies and tools, the
  problems discussed in this paper are not likely
  to be solved.

50
Conclusions (cont.)

• UI will continue to be difficult to design and
  implement. Furthermore, as new styles of
  human-computer interaction evolve, such as speech
  and gesture recognition, intelligent agents and
  3-D visualization the amount of effort directed
  to the design and implementation of the user
  interface can only increase.

51
Our comments on the paper

• Some of the ideas are obvious and well known (on
  the other hand the paper was written in 1993)
• The explanations on how some of the costs were
  calculated are missing, making almost impossible
  to adopt these estimations to today economy.
• The total approach of the paper is a bit too
  pessimistic

52
Our comments on the paper

• But, as we said in the beginning, the article
  emphasizes the why and not the how, which allows
  you to figure the how on your own.
• It leaves you with the trigger to think about
  future solutions to the problem
• In many cases, this is the best
• Last but not least, almost 10 years after it was
  written, most of its directions are still
  relevant and correct, although the technology has
  evolved dramatically.

53
References

• Why are Human-Computer Interfaces difficult to
  design and Implement ? Technical report
  CS-93-183, Carnegie Mellon University, School of
  Computer Science, July 1993.
• Brad A. Myers homepage
• Interface Hall of Shame
• The history of Apple Mac OS
• Iterative Design
• Segway homepage

54
Questions ?
55
(No Transcript)
56
After All, what can be done ?Point for discussion

• One way to try to overcome complexity is to use
  metaphors that exploit the users prior knowledge
  by making interface objects seem like objects
  that the user is familiar with
• More involvement of HCI experts in the design of
  UI.

57
Backup Slides
58
More about Segway

• Segway HT Demonstration Flash
• Segway HT Demonstration Movie