What I Have Learned in Human-Computer Interaction. Part 2

This is two one of multiple posts. Attempting to summarize the experience I’ve gained on HCI is just too much to produce on a single post.

This year started strong with a lot of personal changes. These changes are taking most of my time, so my apologies for the late post. However, I am excited to get back to things and jump into another helpful post about human-computer interaction. Welcome to the second post on a series where I attempt to give you a general overview of HCI. I’ve written these notes from my point of view with the hope of giving you a more related perspective of the course content. Getting a course overview from a professor is somewhat counterintuitive. I think that explanations are easier to understand if both people are within the same context. You can check out the previous post on the link below:

In any case, here is the next part of the human-computer interaction posts:

Cognitive Load is King

Do not over complicate the interface. Minimize clutter. The design should help the user “not think as much.” When possible, create shortcuts for expert developers, or automate as much of the interface as possible. At the same time, do not innovate to the point of confusion. Let the user know what the interface is doing at all times.

Making the user keep more information in mind creates something called “cognitive load.” The more tasks that the user has to worry about, the more frustrating the interface is. Making the interface clear and straightforward to new users while rewarding expert users by using shortcuts will return a better product. Memory is exceptionally scarce for people. We can only save 4-5 chunks of items at a time. This point ties in nicely with the next point.

Keep Human’s Limitations in Mind

We are far away from updating our information via a giant cable connected to the Cerebellum. Until then, the design has to target the ways that people currently input data.

  • Eyes: color and movement tracking. Keep in mind that our peripherals are not great for search.
  • Ear: great for alerts but not so right for direction or taking in details.
  • Skin: Excellent for feedback.
  • Memory: try to move the storage of data to the interface instead of the user. Typical setting setups and shortcuts are useful.

Thinking of the way we take input helps us focus our design towards manageable goals. For example, if we need our app to alert the user when an event happens, we might use sound instead of a visual alert. This small change can make a difference, as the user doesn’t need to pay attention to the application to get the signal.

Undestand the Design Principles

Interface design has been researched countless times before. From that research, we have gotten multiple iterations of principles that can be used to create more seamless and helpful.

  • Discoverability: Users should be able to see an interface and figure out what needs to be done. Options should be visible.
  • Simplicity: Since every extra unit of information competes for visibility, design should be easy regardless of the user expertise.
  • Affordance: Use items on the interface for which their function is already understood. Buttons should be pressable and switches should be toggled.
  • Mapping: Mapping connects data to manipulation. The interface should use plain-simple terms to make information appear naturally to the user.
  • Perceptability: Interfaces should constantly inform the user what is going on in the backend.
  • Consistency: Reduce the need of the user to rethink and remember by using lessons learned from one system and translating them into your system.
  • Flexibility: Interfaces should accomodate any type of user. Experts, novices, young, older, or disabilities of any kind.
  • Equatilty: Provide the same mean to all users whenever possible, without stigmatizing any user.
  • Ease: The interface should be used without fatigue.
  • Comfort: Appropiate size of and space should be given to the interface, regardless of the user.
  • Structure: The interface should be organized in ways that maximizes the mental model to act over a task.
  • Constraints: Make use of limits to guide the user towards the right course of action. Use contraints to eliminate possible errors. These constraints can be physical (3-prone outlets), logical(last screw on a furniture build), or semantic (read mirror should reflect the rear). Do not use cultural contraints.
  • Tolerance: Design with prevention of errors but allow quick fixing of accidents.
  • Feedback: Systems should tell the user how to recover from an error, or tell the user that an action was succesful.
  • Documentation: it is better have no documentation but, if required, make the documentation as simple as the interface and focused on user taks.