UX special Forgiveness Title Image

What is forgiveness?

Lets start out with a description of what the forgiveness design principle is! As usual someone described the topic greatly before, the quote below is from Usabilityfirst.com . Forgiveness is…

a design principle that says people should be able to recover from their inevitable mistakes. Dialog boxes should have a Cancel button. Operations should be undoable. Long operations should allow a user to stop them in the middle.

The most forgiving design is one which helps people avoid making mistakes, e.g. with an interaction style that doesn’t permit inconsistent states. If an operation is not reversible, then an appropriate warning should be given before an irreversible action is committed to.

How to build forgiving systems

There’s clear parallel to be drawn towards human interaction here: If there is nothing to forgive there is no need for it. So before we design a solution to an error, we should avoid the error all together.
With that said, forgiving systems are achieved with the help of good affordance that influences the user to use the product without doing wrong. If something has gone wrong the error should be reversible. If it is an impossible to design a solution that clearly directs the user in the right direction and if an action, where there could be critical irreversible consequences, is performed there should be a confirmation that verifies that the action should be performed. It is important that the confirmation messages and warnings clearly state the consequences of the action that is to be performed.

Forgiveness and programmers

Programmers work in an unforgiving envornment. Heck, most of the time if we accidentally do something wrong the application will spit out a harsh error and a huge stack trace leaving us in shame. Before we had code completion and continuous compilation there were hundreds of recompiles needed around the world just because we put a letter in the wrong casing.
Jeff Atwood put it well in his article over at his excellent blog Coding Horror while talking about two code examples where the difference is whitespace:

If you’re not a programmer, you may be looking at these two images and wondering what the big deal is. That’s fine. But I humbly submit that, well, you’re not one of us. You don’t appreciate what it’s like to spend every freaking minute of every freaking day agonizing over the tiniest details of the programs you write. Not because we want to, you understand, but because the world explodes when we don’t.

This might be a reason why we have not been the best at building forgiving systems.

Some examples of forgiving systems

The book Universal Principles of Design has a couple of good examples on forgiving systems in real-life. One is the electrical socket that only will allow you to plug in a connector that corresponds to the socket. What if this was not designed as a forgiving system?

Adobe Photoshop history panel, courtesy of photoshopcall.com

Universal Principles of Design also brings forward Adobe Photoshop’s history panel as a forgiving design. It allows users to freely revert changes way back without having to redo all the changes they did after the reverted one. If only you could have done that in woodwork class!
Where Adobe Photoshop fails however is when it crashes. If the user forgets to save data is lost. Try to google recover photoshop crash, there are a lot of people wishing this was a more forgiving system.

Google docs revision history

Compare this with google docs that automatically saves your document and keeps revision history that you easily can go back to. Microsoft Word also saves your last changes in a temporary document and allows you to go back to it when it has crashed.

Microsoft Word crash file recovery

Visual Studio 2010 has a couple of new features with good affordance that helps out to build a more forgiving system. The first one I will show is if you accidentally write a line of code that fails. VS (Visual Studio) will show the regular jagged red underline that shows you what line of code has the error. Whats new is if the user hovers the mouse over the line of code that fails; now VS will display information with headings that might help you find the error. Compare that to VS 2008 shown in the figure below. Someone over at Microsoft has been working out!

Visual Studio 2008 error preview

Now I might be too focused on VS2010 but another example of an improvement on forgiveness is the code completion dialog. Previously it would only match the results that start the same way as the user has typed. Now it searches for matches within the names. Many times this will help the user to find the correct function without knowing exactly what its name was.

Visual Studio 2010 error dialog


Visual Studio 2010 code completion

Further reading

Janko Jovanovic has written a really good article about forgiveness at his blog jankoatwarpspeed. His examples mainly focus on google products but there are a series of great examples in the comments section.
There is a great article about forgiving format over at the ui-patterns blog. It shows how to build a forgiving input field.
The usabilitypost blog also talks about forgiveness in their post 8 characteristics of sucessfull user interfaces.
Road signs are a great examples of forgiveness in the real world as Jinmi Lee shows.
Another great and funny example of forgiving systems is found in Gmail. Its called “Mail Goggles” and it tries to prevent you from sending mails you later will regret sending. Read about mail goggles at the official Gmail blog. Usability friction also has a post about mail goggles: Forgive users even when they are drunk.