x

Einloggen

Hast du noch keinen Account? Jetzt registrieren!

Großartig scheitern: Der richtige Umgang mit Userfehlern

Großartig scheitern: Der richtige Umgang mit UserfehlernDas erlernen eines Musikinstrumentes ist ein großartiges Beispiel dafür, wie Fehler dabei helfen können sich -vielleicht sogar bis zum kompletten Erfolg- zu verbessern (oder aber aufzugeben). Immer wenn ein Pianist falsch spielt hört er die falschen Töne heraus und versucht es noch einmal; so verfeinert er seine Methode bis er das Stück richtig spielen kann oder aufgibt. Diese Reaktion ist die Grundlage für viele Modelle des Informationsaustausches zwischen Mensch und Computer. Der User macht einen Fehler. Der User erkennt den Fehler. Der User ändert seine Vorgehensweise, um den Fehler in Zukunft zu vermeiden. Fehler sind ein unabdingbarer Teil des Lernprozesses. Das gilt im Besonderen für die Entwicklung von Software Applikationen. Musikinstrumente und die Verständigung zwischen Mensch und Computer basieren auf derselben Lernmethode, es gibt aber einen wichtigen Unterschied: dem Klavier ist es egal ob der angehende Pianist am Ende auf ihm spielen kann oder nicht; das ist aber ein Punkt über den sich Programmierer hingegen sehr wohl Gedanken machen müssen. Wenn der angehende Klavierspieler nicht richtig zu spielen lernt wird er wahrscheinlich, von seinen Misserfolgen zermürbt, irgendwann aufhören zu üben. Ähnlich werden Menschen, die in einem Computersystem immer wieder auf Fehler stoßen, einfach entscheiden es nicht mehr zu benutzen oder es gegen ein besseres einzutauschen. Ein gutes Entwicklungskonzept für das neue System wird die User an es binden. Wenn die User auf Fehler stoßen (was unvermeidbar ist) sollte das für sie nicht so schmerzvoll sein wie ein schriller falscher Ton auf dem Klavier.

Das 3-teilige System
Laut Donald Norman gibt es bei einem System drei Teile: Die Vorstellung im Kopf des Entwicklers, die Vorstellung im Kopf des Users und das System selbst. Wenn der Entwickler dem User seine Vorstellung des Systems nicht richtig übermitteln kann kommt es häufig zu Anwenderfehlern. Im Folgenden werden hier drei Wege vorgestellt wie man es den Anwendern erleichtern kann sich in einem System zu recht zu finden.

1.) Den Anwender verstehen und ihm den Weg des geringsten Widerstandes zeigen.
Ein Entwickler kann nie ganz genau vorhersehen wie seine Applikation verwendet werden. Am Erscheinungsdatum einer neuen Anwendung gibt es immer eine Menge Anfragen zu deren Eigenschaften und Fehlerberichte, die dadurch entstehen, dass die Applikation auf eine vorher unvorhergesehene Art benutzt worden ist. Gerhard Fischer ist Professor der Computerwissenschaft an der Universität von Colorado und Mitglied des Institutes für Kognitionsforschung. Er hat in seiner Studie „User Modelle in der Verständigung zwischen Mensch und Computer“ ausgeführt:   

„Ein kluges Systems erkennt man daran, dass der Handelnde Mensch (oder Computer) Fehler instinktiv erkennen kann und dass vom User nicht gern gesehene Änderungen heimlich durchgeführt werden. Bei den gängigen Systemen hat der User oft nicht die Möglichkeit oder auch nur die Transparenz, „kluge“ Eigenschaften auszuschalten, die oft mehr stören als helfen… Systeme, auch wenn sie noch so klein sind, erkennen nur einen Teil des ganzen Prozesses der Problemlösung, dem sich ihr menschlicher Gegenpart unterziehen muss und können eine Situation nicht mit ihm zusammen erfassen oder erkennen wie weit seine Lösung des Problems schon vorangeschriten ist.“

Man kann nicht jede mögliche (falsche) Anwendung voraussehen. Stattdessen sollte man die gängigste Art der Nutzung für die Mehrheit der Nutzer festlegen und die Oberfläche dafür optimal gestalten. Das ist ein Teil dessen, was Fischer in einer späteren Arbeit „Kontext erkennende Systeme“ nennt. Wenn man die Nutzer und ihren Hintergrund und ihre Grundsätze versteht, kann man Systeme entwickeln, die besser an ihre Bedürfnisse angepasst sind.

Wenn man eine hauptsächliche Nutzung festlegt teilt man den Usern damit ganz klar mit, wie sie mit der Applikation umgehen sollten. Man sollte zweitrangige Eigenschaften, die von der hauptsächlichen Eigenschaft ablenken könnten reduzieren. Die Haupteigenschaft sollte in einem einfachen Satz zusammengefasst werden können. So eine Haupteigenschaft könnte zum Beispiel lauten: „Der User bestellt spezielle Donuts“.   

Das Ziel ist jetzt, die User im Sinne dieses Hauptanliegens optimal durch die Applikation zu führen. Man beginnt damit, die Minimalanforderungen, die der Nutzer benötigt um sich Donuts nach Hause zu bestellen festzulegen. Also ungefähr so:

  • Eine Bildschirmseite, die das Angebot an Donuts zeigt.
  • Die Möglichkeit, einen Donut anzuklicken und ihn in den Einkaufswagen zu legen.
  • Eine Seite, die den gesamten Einkauf anzeigt und eine Löschfunktion hat.
  • Eine Seite zur Zahlungsabwicklung.
  • Eine Seite für die Bestätigung der Zahlung und ein „Danke für Ihren Einkauf“ zum Abschluss des Vorganges 

   
2.) Sicherheitsvorkehrungen für Sonderfälle zur Verfügung stellen. 
Die Haupteigenschaft ist also: der Nutzer bestellt spezielle Donuts. Was passiert aber wenn der User Donuts mit Eis oder Streuseln bestellen möchte? Oder was ist wenn 22% der Nutzer die Donuts mit Gold überzogen bekommen und sie als Halskette tragen wollen? Man möchte ja sein Gesichtsfeld nicht so eingrenzen, dass man gute Geschäfte liegen lässt. Die User könnten den angebotenen Service auf unerwartete Art – an die zu programmieren der Entwickler nicht einmal im Traum gedacht hatte – nutzen wollen. Deshalb muss eine Applikation auch unerwartete Bedürfnisse der Nutzer befriedigen können. Aber wie kann man das erreichen und sich trotzdem auf die Entwicklung für den Hauptzweck konzentrieren? Ganz einfach: Durch die Einrichtung von Sicherheitsnetzen.

Viele der User, die sich nicht für den Hauptnutzen interessieren kommen aber auch nicht auf die Idee, das System auf andere Art für sich zu nutzen. Mit einem Sicherheitsnetz kann man auch sie kriegen und wenn möglich zu den für sie passenden Nutzungsmöglichkeiten geleiten. Mit intelligenten Metriken kann man Daten über das Verhalten seiner Nutzer sammeln und feststellen wo man sie eventuell verliert. Google Analytics ist ein phantastisches Hilfsmittel um Anwenderfehler zurückzuverfolgen – ein Artikel des Smashing Magazine aus dem Jahr 2011 bietet übrigens ein Tutorial zur Nutzung solcher Tools.  

3.) Userfehler gnädig herunterspielen. 
In der Zukunft wird es sehr wichtig sein Applikationen von Anfang an so zu programmieren, dass sie Zusammenhänge erkennen können und Sicherheitsnetze haben um sich an eventuelle Sonderwünsche der Nutzer anpassen zu können. Aber auch wenn ein System optimal für seine hauptsächliche Nutzung aufgestellt ist und die Sicherheitsnetze halten werden die User trotzdem noch Fehler auslösen. Das ist unvermeidbar. Der Prozess Fehler – Fehlererkenntnis – Anpassung verlangt zwei Dinge: man biete in der ganzen Applikation durchgängig Hilfen für eventuelle Fehlermeldungen an und man stelle Fehler weniger als das Versagen des Nutzers als vielmehr als Anpassungshilfen dar.

Entwickler übergehen Fehlermeldungen oft ganz oder sie werden in der letzten Minute ohne gute Ausarbeitung in Aussehen und Wortwahl hinzugefügt. Fehlermeldungen sind ein letztes Hilfsmittel um die User in der Applikation zu halten. Unklare Fehlermeldungen der Nummer 404, Seitenfehler oder andere Formanpassungsfehlermeldungen, ohne genaue Erklärung der Fehlerursach, verwirren und frustrieren die Nutzer.

Man kann Fehlermeldungen zu seinem Vorteil nutzen. Sie müssen klar in ihrer Aussage sein und überall dort wo der User tätig werden muss klare Maßnahmen zur Behebung des Fehlers anbieten. „Twitter Bootstrap“ ist ein hilfreiches UI Kit um diesen Prozess zu erleichtern. Es bietet schön gestaltete Meldungen, die man leicht in eine Applikation einbauen kann. Die Meldungen sind einfach und elegant. Es ist auch wichtig, daran zu denken die Nutzer für erfolgreich abgeschlossene Aktionen zu belohnen. Der menschliche Geist reagiert trotz allem besser auf Erfolg als auf Misserfolg. Man kann Twitter Bootstrap auch für schön anzusehende Erfolgsmeldungen nutzen. Gut gestaltete und erklärte Fehlermeldungen helfen nicht nur dabei, die User dazu zu bringen, das System auf die vorgesehene Art zu nutzen sondern helfen ihm dabei sich nicht dumm vorkommen.

Die Verantwortung des Entwicklers
Die Nutzerfreundlichkeit eines Systems hängt davon ab wie gut der Entwickler arbeitet. Der Grad des Verständnisses für die Nutzer, die Methoden ihre Aktionen zu bewerten und die Hilfen zur Fehlerbewältigung, die er anbietet, tragen direkt zur Nutzerfreundlichkeit bei.

Man sollte immer mit dem Fall einer klaren Hauptnutzung beginnen, das System so entwickeln, dass es diese Handhabung unterstützt und das Handling von Fehlern mit einbinden. Dann sollte man sich über andere Arten der Nutzung des Systems Gedanken machen und sich entscheiden ob und wie man diese in den Griff bekommen kann; man sollte dabei nicht zu viele Schritte auf einmal machen. Man sollte für jede weitere hinzugefügte Funktion ein Fehlermanagement einbauen. Man sollte darauf achten, die Wege der User durch das System überwachen zu können und es immer besser auf deren Bedürfnisse abzustimmen.
1465 Mal gelesen
+1
1. Aug 2012, 23:59

Kommentare

(0)
RSS

Kommentieren

Fett Kursiv Unterstrichen Durchgestrichen   Link Zitieren Code
Ich bin mit den Nutzungsbedingungen einverstanden.
Zukünftige Kommentare zu diesem Beitrag abonnieren (abbestellbar).
 
Bitte klicke jetzt auf den Bestätigungslink in deiner E-Mail.