If an error is possible, someone will make it. The designer must assume that all possible errors will occur and design so as to minimize the chance of error in the first place, or its effects once it gets made. Errors should be easy to detect, they should have minimal consequences, and, if possible, their effects should be reversible.
This chapter of The Design of Everyday Things introduces and formalizes basic concepts and principles of design from observations of everyday objects. Why some objects, as simple as doors, please their users while others frustrate them.
If a task appears simple or trivial, people blame themselves rather than faulty design.
People tend to find causes for events
blame based on little or erroneous information ⇒ blame/credit can be asserted independent of reality
if everyone perceives the fault to be their own, nobody wants to admit to having trouble This creates a conspiracy of silence, maintaining the felling of guilt and helplessness among users
In general, people attribute
Learned Helplessness: people experience failure at a task, often numerous times ⇒ conclude that they simply cannot do the task; they are helpless
Taught Helplessness: failure at a task ⇒ generalization of failure at all tasks ⇒ not even trying at a task ⇒ failure at a task
Each gulf reflects one aspect of the distance bteween the mental representations of the person and the physical components and states of the environment. These gulfs present major problems for users.
“measure of how well the system allows a user to perform the intended action”
Ex. how well does the system provide actions that correspond to the intentions of the person?
“measure of how much effort a user must exert to interpret the physical state of the system and how well the expectations are met”
Ex. Does the system provide a physical representation that can be directly perceived and that is directly interpretable in terms of the intentions and expectations of the person
The human mind is exquisitely tailored to make sense of the world. Give it the slightest clue and off it goes, providing explanation, rationalization, and understanding.
This chapter of The Design of Everyday Things introduces and formalizes basic concepts and principles of design from observations of everyday objects. Why some objects, as simple as doors, please their users while others frustrate them.
Visibility: correct parts must be visible, they must convey the correct messages; indicates the mapping between intended actions and actual operations
Affordance: the perceived and actual properties of the thing, primarily the fundamental properties that determine how it can be used. Affords = “is for”
Examples:
System Image: the visible part of a device or system
Mental Models: the models people have for themselves, others, the environment, and things with which they interact. Formed through experience, training, instructions, or by interpreting perceived actions and the System Image
Mapping : the relationship between two things Example: controls ⇒ their resulting movements and the effects in the physical world
Natural Mapping: mapping that takes advantage of physical/spatial analogies and cultural standards Examples:
- Additive Dimensions: add more to show incremental increases Examples: amount, loudness, weight, length, brightness, etc.
- Substitutive Dimensions: substitute one value for another to make a change Examples: pitch, taste, color, location
Feedback: sending back information to users about what actions have been performed Example: - Tactile feedback of buttons - Tones mapped for each button - Clicks, tones, to inform state and progress of a call or operation - Sidetones, the voice signal feedback into the ear to help regulate loudness
Provide a good conceptual model - The proper System Image and immediate feedback for each operation can help users form a clear, concise, and correct mental model
Make Things Visible
The Designer must balance the conflicting needs of others that help realize a product design:
The same technology that simplifies life by providing more functions in each device also complicates life by making the device harder to learn and use
]]>Ever since I setup my Octopress blog, I’ve wanted to use it with GFM. I searched around the web and found how to switch the markdown processor for Jekyll. I came across this post with instructions on switching to Maruku, which extends Markdown with the ability to create tables, footnotes, custom header ids, etc. I gave it a shot, but quickly realized that there’s no option to enable hard warp linebreaks. Back to searching.
I then came across this post on Stackoverflow that compared Maruku, BlueCloth, and RDiscount, none of which offered what I wanted. However, I discovered RedCarpet, the open source Markdown processor tha Github uses to render Markdown and GFM pages. Seems like exactly what I was looking for.
Maybe it’s because my Google-Fu is not up to par, but I could not find any instructions on using RedCarpet with Octopress. It turned out that I was just not looking for the correct terms. I found a Stackoverflow answer on how to configure Jekyll with RedCarpet. Perfect!
Below are the instructions for getting Octopress to render Github Flavored Markdown using RedCarpet.
gem 'redcarpet', '~> 2.1.1'
to Gemfile
in the Octopress directorybundle install --no-deployment
to install RedCarpetredcarpet2_markdown.rb
in the plugins
folder1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
|
markdown: rdiscount
in _config.yml
with the following 1 2 3 |
|
That should be it! Now the lines should be hard wrapped. I also have a few other extensions turned on. Below is my extension settings: 1
extensions: ["hard_wrap", "no_intra_emphasis", "fenced_code_blocks", "autolink", "tables", "with_toc_data", "strikethrough", "superscript"]
no_intra_emphasis
: Multiple_underscores_in_words
=> Multiple_underscores_in_wordsfenced_code_blocks
: Don’t need to indent to embed codeautolink
: URL autolinking => http://google.com test@email.comtables
: allow tableswith_toc_data
: add HTML anchors to each headerstrikethrough
: ~~strikethrough text~~
=> ~~strikethrough text~~superscript
: normaltext ^(superscript)
=> normaltext ^(superscript)More options are described in RedCarpet’s Documentation.
]]>Everyday tasks are not difficult because of their inherent complexity - they are difficult only because they require learning arbitrary relationships and mappings, and because they sometimes require precision in their execution.
Design is something that I’ve always wanted to learn, but never received a formal introduction to. It’s something I’ve always emulated but always fail to create. With Design and UX of products becoming increasingly important as a differentiator for startups and a means to establish a memorable brand image or memory of a product, it’s become even more imperative for me to learn Design.
Unfortunately, the Computer Science department does not offer any courses in Human-Computer Interaction. Through a series of considerations, weighing the benefit of completing my graduation requirements this semester and having the option of graduating early, versus not having to suffer through yet another class that fails to interest me and using my extra class slot for something of my own choosing. I decided to go with the latter, due to many factors I will not get into here. Regardless, I definitely think I’ve made the right choice.
Per one of my friend’s suggestion, I decided to pursue an Independent Research Study in Human-Computer Interaction with a focus on Interface Design and Data Visualization under Professor Duvall.
To build the foundations in Design, Professor Duvall suggested that I read three books, The Design of Everyday Things, Universal Principles of Design, and Interaction Design, as an introduction to the vocabulary and language of Design. The Design of Everyday Things, the seminal work in Design by cognitive scientist and usability engineer Donald Norman from the 1980s, is a particularly enjoyable read. It formalizes design principles from careful observations of mundane everyday objects. Below are the 7 main principles discussed in the book to transform a difficult task into a simple one.
For first time or infrequent users, knowledge required for a task should be available either explicitly in the world or derived from constraints in the environment. There should be a natural, easily interpreted relationship between the knowledge and the information it’s intended to convey.
For frequent users, Design should not impede action and allow users to be more efficient at a particular task, especially for people who have internalized the knowledge. It should be easy to go back and forth between using knowledge in the world and knowledge in the head and the two should coexist without interference.
Eliminate or restructure complexities, minimizing the planning and problem solving a task requires. Pay attention to the psychology of a user and the limits on memory and attention.
Easy to see what’s visible: what can be done and what their effects are.
Actions should match intentions
It’s important to make the correct things visible so the users for the correct interpretations and mental models through the system image
Natural Mappings (“response compatibility”): the the spatial relationships between the controls and the system components or objects they control should be as direct as possible, with the controls and the objects themselves or have an analogical relationship
The movements of the control should be similar or analogous to the expected operation of the system.
feedback must be timely and easy to understand
Reduce the number of possible alternative actions at each step to a few or ideally just one
Assume errors will be made. Allow for recovery. Use forcing functions
Each user action is an attempt to a step in the right direction
An error is incompletely or improperly specified actions
Standardize the problem and processes, so arbitrary mappings only have to be learned once
It maybe difficult to obtain an agreement, early enough to save trouble later on, and late enough to take into account of the existing technologies and procedures
Standardization is only essential when all necessary information cannot be placed in the world or when normal mapping cannot be exploited
Users must be trained for this