onli blogging

direkt

Ich habe hier jetzt viel über Usability geschrieben und wer mir folgte weiß jetzt so einiges. Wir wissen, was Usability ist, können Usability von UX unterscheiden und haben Beispiele für diese Prinzipien anhand von Alltagsbeispielen gesehen. Vor einer Weile schrieb ich sogar schon über typische konkrete Hürden bei der Softwarenutzung. Aber wenn ich jetzt eine neue Anwendung bauen will, wie beachte ich dann dieses ganze Wissen und erbaue die Anwendung mit guter Usability? Die Antwort: Indem im wie auch immer gearteten Entwicklungsprozess Usability explizit berücksichtigt wird.

Eine Prozessblaupause

Es geht dabei ausdrücklich nicht darum, einen bestimmten Entwicklungsprozess vorzuschreiben. Es ist egal, ob das Wasserfall, Scrum, agile Entwicklung oder eine Mischform ist. Es gibt nur zwei Kernbedingungen, die meist hinzugefügt werden müssen: Die Nutzungsanforderungen müssen möglichst früh erhoben und die Usability der Software muss mit echten Zielgruppennutzern getestet werden.

In irgendeiner Form sollte dabei dieser modisch als Kreislauf gezeichnete Prozess abgebildet werden:

Den Kreislauf als Teil des eigentlichen Prozesses beginnt man möglichst früh und hört erst auf, wenn die Lösung sich in einer Evaluation bewährt hat. Für jeden dieser Schritte gibt es eine Menge an Werkzeugen, die üblichsten liste ich hier auf:

1. Nutzungskontext erheben

Wir erinnern uns: Den Nutzungskontext brauchen wir, weil wir Usability immer im Kontext einer bestimmten Nutzung für eine bestimmte Aufgabenerledigung betrachten. Ohne den Kontext können wir ins Blaue designen und testen, reduzieren damit aber eben erheblich die Chance für die Zielnutzung eine gute Lösung zu finden. Um den Kontext zu erheben greife ich üblicherweise auf Nutzerinterviews zurück. Was auch gehen könnte: Beobachtungen. Die sind aber meist schwer umzusetzen. Fokusgruppen wären auch denkbar, verleiten aber dazu, die tatsächliche Nutzungspraxis in der Diskussion durch Gruppendynamiken zu verdecken.

Bei Interviews ist es dann noch wichtig, tatsächlich mit Nutzern zu reden und nicht mit Leuten, die über Nutzer sprechen. Lass dir von ihnen ihre tatsächliche Praxis beschreiben. Aus den Interviews lassen sich dann die Nutzungsanforderungen ableiten.

2. Nutzeranforderungen spezifizieren

Wie das genau aussieht folgt aus dem vorherigen Schritt. Habe ich Interviews gewählt und transkribiert, leite ich aus diesen Texten Anforderungen ab und packe sie in ein Dokument. Oder man muss sich die Videos anschauen, oder die eigenen Beobachtungsnotizen durchforsten. Egal wie: Am Ende diesen Schrittes sollte eine Liste von Anforderungen an die Lösung stehen, die bei deren Entwurf zu berücksichtigen ist.

3. Lösung implementieren

Mit den Anforderungen in der Hand kann nun die Lösung gebaut werden. Je nachdem, in welchem Entwicklungsstand man ist und was man am Ende baut wird das völlig unterschiedlich aussehen. Bei Software starte ich eventuell mit einem Papier-Prototyp, oder einer Prototyp-Software. Später ist die Umsetzung schlicht Softwareentwicklung. Vielleicht aber stellt man mit den Anforderungen in der Hand fest, dass Software gar nicht die Lösung ist, sondern eine Prozessänderung oder ein Echtwelt-Artefakt bauen die beste Lösung wäre.

4. Lösung evaluieren

Am Ende des iterativen Prozess steht dieser allerwichtigste Schritt: Die Evaluierung der Lösung mittels Nutzungstests.

Dabei ist es völlig egal was gebaut wurde. Und selbst wenn alles andere ignoriert wurde: Echte Nutzungstests mit echten Nutzern bringen so viele Erkenntnisse, dass sie auf jeden Fall durchgeführt werden sollten. Dabei liegt die Betonung auf "echte". Es bringt nichts, mit Leuten zu testen die später die Lösung gar nicht benutzen sollen, beispielsweise anderen Softwareentwicklern eine neue Nähmaschine vorzusetzen. Es bringt genausowenig falsch zu testen, also nicht Nutzer die konkrete Aufgabenerledigung durchspielen zu lassen und dabei Probleme zu beobachten, sondern ihre Meinung zur Hintergrundfarbe der Titelleiste zu erfragen.

Nein, echte Nutzungstests spielen mit echten Zielgruppennutzern ihre Aufgabenerledigung nach. Dafür hat der Nutzer meist einen Testleitfaden, der die Aufgaben vorgibt. Der Tester sitzt daneben oder am anderen Ende der Telefonleitung und schaut mit auf den Bildschirm. Was ihn ausschließlich interessiert sind Momente, in denen der Nutzer irritiert ist oder nicht weiterkommt. Solche Critical Incidents (CIs) können immer auf die Verletzung von Dialogprinzipien zurückgeführt werden. Eine so generelle Aussage mag überraschen, aber die Prinzipien sind dafür wirklich ausreichend umfassend und aussagestark. Die CIs zu protokollieren und einzuordnen motiviert dann die nächste Iterationsrunde des Prozess. Mit besserem Verständnis des Nutzungskontexts bzw. der eigenen gebauten Lösung muss die nun angepasst werden, sodass die CIs beim nächsten Test nicht mehr auftreten.

Und wenn es keine CIs gab oder sie die Aufgabenerledigung nur unwesentlich behinderten? Dann sind wir mit der Usabilityarbeit fertig.

Der Prozess in der Praxis

Das oben beschriebene ist keine akademische Fingerübung. Es wird tatsächlich in der Praxis umgesetzt und es funktioniert wirklich. Klar: Niemand und kein Prozess kann garantieren, dass egal welche Hürden es gibt das Endergebnis super wird. Aber Usability mittels dieser Prozesselemente zu beachten vermeidet effektiv, am Ende Nutzern ein Produkt vorzusetzen, mit dem sie schlicht nichts anfangen können. Schon das richtige Testen alleine verhindert das. Denn wenn die Lösung nichts taugt, merkt man das in professionellen Nutzungstests zu 100%. Das Management darf diese Ergebnisse dann nur nicht ignorieren, aber das ist ein Thema für sich.

Praktisch läuft das so ab: Bei der Produktentwicklung gibt es immer ein Entwicklungsteam und Entwicklungsleiter. Dieses Team hat irgendeinen Prozess, mit dem es Lösungen entwirft und umsetzt. Diesem Prozess fügt man nun Usability-Experten hinzu. Man kann einen Usability-Experten als Consultant anheuern, eine Usability-Agentur beauftragen oder einen Usability-Experten einstellen – ob der dann Teil eines Designteam wird oder Teil des Entwicklerteams, gar ein vorheriges Entwicklungsteamitglied mit neuer Zusatzausbildung ist, ist erstmal egal.

Ich habe alle drei Lösungen in der Praxis erlebt. Meinem Eindruck nach funktioniert das Einbinden des Usability-Experten in das Softwareentwicklungsteam am besten, aber dafür muss man nunmal einen der seltenen Usabilityleute finden, die auch Softwareentwickler sind. Hier sollte ich erwähnen: Dieser mein Eindruck könnte daher kommen, dass ich eben selbst einer dieser Usability-Softwareentwickler bin. Die direkte Einbindung hat aber nunmal den Vorteil, dass in einer solchen Konstruktion die Usabilityexpertise sehr nah am Entwicklungsteam lebt und mühelos berücksichtigt werden kann. Wenn stattdessen eine externe Agentur die Usability-Analyse übernimmt, macht die ihre Arbeit und wirft schlimmstenfalls am Ende eine 300-seitiges Ergebnisdokument über den Zaun, von dem das Management nur die Zusammenfassung liest und das dann vom Entwicklerteamleiter im internen Wiki einer Unterseite als .doc angehängt wird, auf dass es keiner der praktischen Entwickler jemals auch nur aufmache. Aber vielleicht funktioniert es manchmal besser.

Egal welche Konstruktion es wird ist dies der Wunsch: Die Leute mit Usability-Expertise erheben den Nutzungskontext (wenn er noch nicht bekannt ist) und erstellen (oder ergänzen die bestehenden) Nutzungsanforderungen. Oberflächen und Funktionalität wird mit den Anforderungen vor Augen designt – prototypisch oder direkt in Zielform –, dann mit Nutzern getestet, schließlich wird auf die CIs reagiert. Und dann wird das wiederholt, wobei Kontexterhebung in späteren Iterationen meist übersprungen wird.

In irgendeiner Form muss das in jeden Entwicklungsprozess einzubauen sein. Am einfachsten ist es wohl bei echter agiler Entwicklung, bei dem die Entwickler zusammen mit den Designern je nach Prozessstand den nächsten Zeitabschnitt der anstehenden Aufgabe widmen. Also zum Beispiel nach der Entwicklung der ersten Alpha-Version im nächsten Wochensprint Nutzungstests durchführen, und im folgenden Sprint je nach Ergebnis entweder nochmal Designworkshops abhalten oder entdeckte Bugs wie Problemstellen in der Software reparieren.

Und das wärs. Usability mit all den dahinterstehenden Konzepten wird zu Prozesselementen, die Entwicklungsfirmen in den ihren einbauen können. Das zu tun verbessert ihre Produkte, vermeidet Kosten und hilft so der Firma. Nebenbei macht es die Entwicklung angenehmer: Bei Nutzungstests die Reaktionen der Nutzer mitzukriegen und Produkte daraufhin verbessern zu können, sodass Nutzer auf einmal mit ihnen gut zurechtkommen, ist auch für klassische Entwickler toll.
Usability im Entwicklungsprozess zu berücksichtigen ist eine wirklich gute Idee. Es ist wohl der einzige Weg, nicht einfach Glück haben zu müssen, sondern bei der Entwicklung einer neues Anwendung eine gute Usability gezielt herstellen zu können.

Meine Tastatur soll mit englischem Tastaturlayout laufen. Gleichzeitig muss das nervige CapsLock deaktiviert sein. Die Taste dient dann zusammen mit dem rechten Alt dem Setzen von Umlauten. CapsLock-q steht für ä, CapsLock-y für ü und CapsLock-p für ö. Um diese Belegung umzusetzen braucht es eine Mischung aus setxkbmap und xmodmap:

setxkbmap -variant altgr-intl -option -option compose:rctrl -option lv3:ralt_switch -option terminate:ctrl_alt_bkspc -option eurosign:e -option nbsp:level3n
xmodmap /home/onli/.Xmodmap

Wobei in der .Xmodmap nur das hier steht:

clear lock
keycode 66 = ISO_Level3_Shift NoSymbol ISO_Level3_Shift

Diese Befehle sendet meine ~/.icewm/startup bei jedem Login. Aber seit ich wegen der Heimarbeit regelmäßig die Tastatur zwischen Arbeitslaptop und eigenem PC wechselte, störte es mich langsam, dass ich nach jedem Wechsel bei angeschaltetem PC die Befehle neu ausführen musste. Das müsste man doch auch ohne Desktopumgebung automatisieren könnte. Desktopumgebungen wie KDE und Gnome könnten die Tastaturbelebung dauerhaft setzen, dafür ist dort meine Zielkonfiguration mit dem deaktivierten CapsLock und den erreichbaren Umlauten trotz US-Layout gar nicht so einfach umzusetzen.

Und tatsächlich gibt es für sowas udev. Damit können bei jedem Hardwarewechsel Berechtigungen gesetzt, Namen verteilt und eben auch beliebige Befehle ausgeführt werden. Doch leider ausgerechnet diese Tastaturumstellung nicht. Die Befehle werden einfach geschluckt, als ob nach udev nochmal der XServer auf den Hardwarewechsel reagiert und die Tastatur zurücksetzt. Zum Glück bin ich dann über diesen Artikel gestolpert, der zusammen mit einem Arch-Forenbeitrag beschreibt wie hier udev doch noch eingesetzt werden kann. Der Trick: Anstatt die Befehle direkt auszuführen schreibe in eine Datei, worauf ein inotify-Watcher reagiert daraufhin und im richtigen Kontext die Befehle ausführt.

Konfiguration udev

Wir starten mit udev. Zuerst gucken wir, wie die Tastatur identifiziert werden kann:

onli@fallout:~$ lsusb
Bus 003 Device 002: ID 8087:8001 Intel Corp. 
…
Bus 002 Device 007: ID 046a:a087 Cherry GmbH Wireless Mouse 
Bus 002 Device 009: ID 258a:1006 SINO WEALTH USB KEYBOARD

258a:1006 ist die gesuchte Kombination. Das packen wir nun in die udev-Regel unter /etc/udev/rules.d/80-ajazzmapping.rules (der Abschnitt vor .rules kann natürlich anders benannt werden):

ACTION!="add|change", GOTO="ajazz_rules_end"

ATTRS{idVendor}=="258a", ATTRS{idProduct}=="1006", RUN+="/usr/local/bin/keyboard-udev.sh"

LABEL="ajazz_rules_end"

Das Skript reagiert nur auf die Aktionen add oder change des Hardwaresystems, also wenn die Tastatur angesteckt wird. Per idVendor und idProduct schränken wir die Regel weiter ein auf genau die Hardwareidentifikatoren, die wir oben lsusb entnomment haben. Und dann soll ein Skript ausgeführt werden.

Aktion: keyboard-udev.sh

Und zwar dieses, gespeichert als /usr/local/bin/keyboard-udev.sh:

#!/bin/bash

# Path to lock file
lock="/tmp/keyboard.lock"

# Lock the file (other atomic alternatives would be "ln" or "mkdir")
exec 9>"$lock"
if ! flock -n 9; then
	notify-send -t 5000 "Keyboard script is already running."
	exit 1
fi

echo '' > /tmp/keyboard.lock &

# The lock file will be unlocked when the script ends

Das mit dem Lock ist gar nicht so ganz simpel, aber eigentlich müssen uns die Details hier nicht weiter interessieren. Wichtig ist: Nach /tmp/keyboard.lock wird geschrieben, und darauf können wir nun reagieren.

Die Reaktion

Dafür wird bei Start des Xservers der inotify-Watcher gestartet. Dafür kommt ein Aufruf zu file-inotify.sh in die $HOME/.xinitrc, sodass sie bei mir nun so aussieht:

/usr/local/bin/keyboardMapping.sh
file-inotify.sh /tmp/keyboard.lock /usr/local/bin/keyboardMapping.sh &  # Triggered by udev rule
xrdb -merge -I$HOME ~/.Xresources
exec dbus-run-session /usr/bin/icewm-session --notray

file-inotify.sh müssen wir noch anlegen, ich erstellte es als /usr/local/bin/file-inotify.sh:

#!/bin/bash
# Usage: file-inotify <file> 
# Command is run when file is written.

path=$(realpath "$1")
job="$2"
#basename=$(basename "$1")
dirname=$(dirname "$1")

inotifywait -m -e close_write --format '%w%f' "$dirname" \
	| while read file
do
	if [[ $(realpath "$file") == "$path" ]]; then
		sh -c "$job"
	fi
done

Und die /usr/local/bin/keyboardMapping.sh? Das sind einfach die Tastatursetzbefehle von oben:

#!/bin/bash
echo "remapping keyboard"
setxkbmap -variant altgr-intl -option -option compose:rctrl -option lv3:ralt_switch -option terminate:ctrl_alt_bkspc -option eurosign:e -option nbsp:level3n
xmodmap /home/onli/.Xmodmap

Die Tastatur sitzt

Jetzt steht das ganze System. Bei Systemstart wird per xinitrc der inotify-Watcher gestartet, der auf Dateisystemaktionen reagiert. Wenn udev das Einstöpseln der Tastatur mitbekommt schreibt es in die beobachtete Datei, woraufhin das Tastaturlayout gesetzt wird. Das funktioniert verlässlich und verursacht beim Warten keine Systemlast.

Die keyboardMapping.sh und damit die setxkbmap- und xmodmap-Befehle nicht manuell ausführen zu müssen ist an sich nur eine Kleinigkeit. Aber das automatisiert zu haben ist eine sehr angenehme Kleinigkeit. Ich vergaß es doch immer mal wieder, tippte daraufhin Unsinn zusammen und musste das Umschalten dann nachholen. So brauch ich nicht mehr dran zu denken.

Uberspace hat PHP 8.0 aktivierbar gemacht. Da dort meine Entwicklungsinstallation lebt habe ich mir angeschaut, was da genau auf die Blogsoftware zukommt. PHP 8.0 ist zwar schon draußen, PHP 7.4 wird aber noch eine ganze Weile unterstützt, es eilt also nicht. Andererseits gibt es viel zu tun. Zumindest ist das meine Einschätzung.

Die inkompatiblen Änderungen von PHP 8.0

PHP 8.0 ist inkompatibel mit einigem Code, der in den letzten 20 Jahren bei Serendipity zusammengekommen ist. Vor allem diese Änderungen (von hier) machen der Software zu schaffen:

A number of notices have been converted into warnings:

Attempting to read an undefined variable.
…
Attempting to read an undefined array key.
…

Serendipity macht beides sehr, sehr oft. Und noch öfter, wenn man die Smarty-Templates hinzurechnet, die nun ebenfalls bei Zugriff auf undeklarierte Variablen solche Warnungen werfen. Werden Warnungen geworfen ist das im Zweifel im Blog sichtbar, kann generiertes HTML und CSS kaputtgehen, bei Entwicklungsversionen bricht die Ausführung ab.

Der Code schaut zum Beispiel oft, ob in $serendipity ein gesuchter Key gesetzt ist, oder switcht sogar über diesen Wert:

switch($serendipity['POST']['adminAction']) {
    …
}

Wenn $serendipity['POST']['adminAction'] nie gesetzt wurde, wirft das jetzt eine Warnung. Vorher war das Ergebnis einer solchen Abfrage einfach null und machte entsprechend nichts. Wir können das reparieren, mit isset oder dem ??-Operator:

switch($serendipity['POST']['adminAction'] ?? '') {
    …
}

Aber will man die Warnungen nicht verstecken muss das eben durch den gesamten Code hindurch gemacht werden.

Der aktuelle Stand

Warnungen zu unterdrücken halte ich wirklich für keine gute Option. Tatsächlich wurden durch dieses neue Verhalten jetzt schon einige Bugs sichtbar, als ich die Warnungen nachverfolgend durch den Code ging. Es ist zwar unangenehm bei altem Code wie diesem – tatsächlich ist Serendipity kein toller Kandidat für die Portierung auf PHP 8 – aber die Änderungen sind grundsätzlich gut. Serendipity sollte da mitgehen.

Ich habe einen ersten Pull-Request vorbereitet. Den will ich so nicht mergen, er ist zu groß geworden, aber ich werde ihn aufsplitten (der erste Folge-PR ist hier). Mit diesen Codeänderungen kann der Blog mit Standardplugins schon wieder fehlerlos dargestellt werden, auch alle Hauptseiten im Backend werfen keine Fehler mehr. Mit etwas mehr Arbeit wird wahrscheinlich bald der Rest des Kerns wieder gehen.

Anstehende Entwicklungen und Entscheidungen

Es würde wohl in ein Serendipity 3.0 münden. Die von PHP 8.0 diktierten Änderungen werden s9y teilweise zu inkompatiblen Änderungen zwingen. Zum Beispiel bei der Redeklarierung von Konstanten, was nun ebenfalls einen Fehler wirft, aber für das Fallback bei den Sprachdateien genutzt wird.

Aber ich könnte mich täuschen. Vielleicht lassen sich solche Änderungen durch Ideen anderer Entwickler vermeiden. Vielleicht sollte man temporär an dieser Stelle doch die Fehlermeldungen unterdrücken, wo wir da doch wirklich wissen, dass davon kein Bug versteckt wird. s9y versucht ja auch sonst immer, inkompatible Änderungen zu vermeiden. Ich hoffe, die jeweilige Änderung in den PRs mit den anderen zu besprechen.

Dann bleiben aber immer noch die alten Themes und Plugins.

Bei den Themes ist es möglich, dass die genutzte Template-Engine Smarty eine neue Version herausbringt, die besser auf PHP 8.0 ausgerichtet ist und die Warnungen bei undeklarierten Variablen vermeidet. Wenn nicht, werde ich die empfohlenen Designs reparieren (und natürlich auch dieses hier im Blog genutzte), wäre dann aber sehr dafür die alten Themes ohne eigenen Maintainer aufzugeben.

Bei den Plugins ist die Situation ähnlich. Auch die werden wahrscheinlich fast alle repariert werden müssen. Die wichtigsten werde ich bei meiner Arbeit an Serendipity selbst mitreparieren, wenn mir niemand zuvorkommt. Man könnte es beim Rest mit automatisierten Tools wie rector versuchen. Und nachbessern falls Nutzer Probleme melden. Dabei sollten wir aber die Plugins markieren, die bereits repariert sind, damit ein etwaig unbedarfter Nutzer nicht unwissentlich ein eventuell inkompatibles Plugin installiert.

Wie gesagt, das ist nur meine unabgesprochene Einschätzung. Durchaus möglich, dass ich gute Alternativen übersehe und mein Ansatz arbeitsintensiver ist als nötig. Aber so oder so schadet es nicht, wieder durch den Code zu gehen und den von Hand geradezubiegen. Das werde ich in nächster Zeit immer mal wieder machen, dabei auf Github PRs vorbereiten und einsenden.

Das positivste: Der für PHP 8.0 angepasste Code lief problemlos mit PHP 7.4, sicher auch mit 7.3. Die Änderungen dürften also nicht zu einem harten Bruch führen. Wenn das Projekt den hier beschriebenen Weg weitergeht sollte die nächste Serendipity-Version mit allen aktuellen PHP-Versionen zugleich funktionieren.

Heute ist OVH in Straßburg ein Rechenzentrum abgebrannt. Die Bilder sehen nicht so aus, als ob da Daten überleben könnten:

Und während auf Hackernews die Leser über ihre Notfallpläne diskutierten ging ich im Kopf auch die meinen durch. Lokales Backup via pogo, externes Backup via rsync. Selbst wenn da ein Datenzentrum abbrennt, kann nichts wirklich passieren. Oder? Um zu überprüfen, dass die Backups wirklich durchgeführt werden, ging ich meine Server durch. Auch den dieses Blogs. Und sah: Nichts.

Kein Backupskript. Kein Eintrag in der crontab. Keine aktuelle Backupdatei auf dem Backupserver. Selbst die Backupoption des Hosters (die 0.50€ kostet!) war aus.

Ich hatte bei meiner Blog-Migration von scaleway zu vultr Backups schlicht vergessen. Ich weiß noch, dass ich kurz dachte, das einen Moment später machen zu können weil ich wegen des Umzugs ein lokales Backup hatte. Ein Fehler. Es war eine stressige Zeit und ich habe da nie wieder dran gedacht. Bis heute.

Die Einträge eines Jahres wären verloren gewesen. Klar, mancher steckt vielleicht noch in Caches, aber garantiert nicht alle. Dieser Blog lebt seit 2008, es ist meine wichtigste Webpräsenz, auch nur Teile davon zu verlieren wäre furchtbar ärgerlich gewesen. Ich habe Unmengen Glück gehabt, dass die Daten auf dem Server ohne Backup überlebten. Backups, die jetzt wieder aktiviert sind.

Rennt da nicht rein: Überprüft eure Backups, macht welche wenn ihr noch keine habt.

Auch wenn Endless Space von 2012 und damit aus diesem Jahrtausend ist: Der 4X-Vertreter ähnelt trotz modernen Ansätzen mehr den Klassikern des Genres, wie Master of Orion und Ascendancy, als neueren Varianten wie Stellaris. Das gibt ihm anfangs den gleichen Reiz, aber macht das Endspiel auch ähnlich ermüdend.

Kolonisieren mit Aliens

Doch zuerst beginnt man mit einer Stärke des Spiels, der Rassenauswahl. Es gibt zwar wie üblich mit den Menschen eine wenig aufregende Standardzivilisation, aber die anderen sind interessanter. So spielte ich meine Hauptpartie mit den Amöben, zur Weltraumzivilisation hochentwickelten diplomatisch begabten Einzellern. Ich hätte auch eine Rasse von narzisstischen Klonen oder weltenfressenden Insekten wählen können. Einerseits sind die detailreichen Beschreibungen nach Spielstart weg, selbst Beschreibungstexte gibt es kaum. Andererseits geben sie spielverändernde Modifikatoren und Spielmechaniken vor, wenn zum Beispiel eine Rasse permanent mit allen anderen im Kriegszustand ist und von Planet zu Planet ziehen muss.

Daher bleibt es auch nicht bei dem einen Startplaneten. Die Sternensysteme sind verbunden, in jedem können mehrere Planeten sein, die mit der richtigen Technologie alle kolonisiert werden können. Je nach Planetenklasse werden dann pro Siedler vier Ressourcen produziert (Nahrung, Industrie, Forschung und Dust, die Währung). Gewichtigen Einfluss haben neben der Planetenklasse auch noch die Anomalien; Eine Wasserwerwelt mit einem unglücklich machenden schwerem magnetischen Feld ist gleich weniger attraktiv, der eigentlich komplizierte Lavaplanet kann dagegen ein tolles Ziel abgeben, wenn dort vor Urzeiten ein Relikt der Endless errichtet wurde.

Einzelne Gebäude und Zuordnung der Einheiten zu diesen Gebäuden gibt es nicht, nur eine generelle Spezialisierung pro Planet. Dafür können sternensystemweite Verbesserungen gebaut werden, die teils massiv die Produktion verbessern oder die Verteidigung erhöhen. Alternativ können in jedem System Schiffe gebaut werden, die in einem Schiffsdesigner selbst zusammengestellt werden. Die Elemente dafür muss jedoch erst die Forschung freigeschalten.

Forschen

Jede Rasse hat einen leicht abgewandelten Forschungsbaum. Die meisten Technologien sind gleich. Aber die Starttechnologie ändert sich und es gibt Spezialtechnologien, die der Ausrichtung entsprechen. So haben meine Amöben mit ihrem Schwerpunkt auf Diplomatie passende Technologien, wie durch Kooperationsabkommen einen großen Zufriedenheitsbonus auf allen Systemen zu bekommen.

Der Forschungsbaum ist dabei in vier Kategorien aufgeteilt. Völlige Spezialisierung ist praktisch nicht möglich – der rechte Forschungsbaum schaltet z.B. Ressourcen frei, die bei den oberen Militärtechnologien gebraucht werden. Aber ein Fokus lässt sich schon setzen.

Die durch die freigeschalteten Technologien immer breiter werdenden Möglichkeiten machen Spaß, dann kommen manchmal noch Zufallsereignisse mit Entscheidungen dazu.

Kriege

Die Möglichkeiten werden irgendwann wahrscheinlich in einen Krieg münden. Irgendwann ist jedes freie System besiedelt, die nahen Grenzen verärgern die Nachbarn. Oder – das passierte mir – man schließt eine Allianz, worauf eine andere Alienrasse sich bedroht fühlt und den Krieg erklärt. Dann kommen die Schiffe zum Einsatz.

Die Schiffe können zu relativ kleinen Flotten zusammengefasst werden, wobei immer eine Flotte gegen eine andere kämpft. Klar, hier spielt wieder die Forschung rein, der Technologiefortschritt bestimmt wie groß die Flotte sein kann. Neben Schiffen mit normalen Waffen und Panzerung für den Schiffskampf gibt es auch Belagerungsausrüstung wie Bodentruppen, mit denen die Planeten der Feinde übernommen werden.

Kämpfe zwischen den Flotten werden entweder berechnet oder in einer 3D-Ansicht angezeigt, wobei auch dann der Kampf automatisch abläuft. Es gibt drei kurze Phasen, in denen die Schiffe aufeinander einschießen, für jede Phase kann per Karte eine Strategie ausgewählt werden.

Diese Karten kommen teilweise auch von den Helden, das sind dann Spezialvarianten mit entsprechenden Boni. Jede Zivilisation hat nur wenige Helden. Sie können auf Planeten dienen und steigern dort dann teils massiv die Produktion, oder sie wirken als Flottenkapitän in Schlachten mit. Bei Aktionen sammeln sie Erfahrung, dann kannst du ihnen neue Fähigkeiten geben. Ein nettes Rollenspielelement.

Aber bei den Kämpfe selbst ist der Spieler notgedrungen sehr passiv. Ähnlich wie in Stellaris geht es im Grunde nur darum, genug Schiffe an die richtige Stelle zu packen. Ausgerechnet hier fehlt die Orientierung an die Klassiker, wo doch in Ascendancy noch Schiffe einzeln in Echtzeit gesteuert und in Master of Orion tolle Rundenkämpfe ausgetragen wurden. Immerhin, die Begrenzung auf viele kleine Flotten macht das System etwas taktischer als bei Stellaris, aber ideal ist es nicht.

Spielbarkeits- und Interfaceprobleme

Einschränkungen bei den Kämpfen hin oder her, die Spielelemente greifen wie im Genre üblich gut zusammen. Das Errichten eines erst kleinen, dann langsam größeren Sternenimperium ist supermotivierend, die immer wieder dazukommenden Technologien halten das Spiel lange frisch. Aber irgendwann kippt es, und teils hängt das schlicht an der Bedienung.

Ein großes Imperium zu verwalten artet in Arbeit aus. Gleichzeitig will ich meine Planeten nicht von der KI verwalten lassen, weil ich der keine genauen Bauvorgaben machen kann und viele Planeten mit guten Upgrades zu haben im Grunde das Spielziel ist. Hier könnten moderne Komfortfunktionen helfen, aber dafür ist wohl die Anlehnung an die Genreklassiker zu stark, oder sie sind zu versteckt.

Zwei Probleme potenzieren sich:
Ersten, das Bauen der Sternensystemupgrades läuft via fuzzelig kleinen Icons, die aus einer immer länger werdenden Liste ausgewählt werden. Das ist extrem unkomfortabel, vor allem wenn man es bei einer längeren Partie bei zig Sternensystemen machen muss. Und nicht vergessen: Dazu kommen die Planeten, auf denen auch mehrere Upgrades ausgewählt werden müssen.
Zweitens, Systeme können auch nichts tun und das Spiel warnt dann nicht. Es gibt jede Runde eine Benachrichtigung wenn eine Konstruktion fertig ist, in ihr sieht man wenn keine weitere vorgesehen ist. Verpasst man diese Chance aber, dann muss man selbst in der Sternenkarte auf das System klicken oder in der immerhin vorhandenen Übersicht das inaktive System entdecken. So muss im Grunde regelmäßig die Konstruktion überprüft werden.

Das Interfaceproblem wird noch verschlimmert, weil Systeme ohne bessere Option auch einen Teil ihrer Industrieproduktion in Forschung oder Dust umwandeln können. Sie produzieren dann ein unendliches Upgrade im Konstruktionsslot. So verpasst man aber natürlich die Chance, neu freigeschaltete Upgrades bauen zu lassen wenn die vorherigen fertig sind, das gerade gebaute wird ja nie fertig. So wird jeder entsprechende Forschungserfolg zu einem Anlass, wieder durch die Sternensystem durchgehen zu müssen...

Fazit: Ein klassischer Genrevertreter

Mit den Steuerungsproblemen wird das ansonsten gute Endless Space weit weniger spaßig. Damit ist es aber in bester Gesellschaft, die wenigsten 4X-Spiele schaffen es große Imperien angenehm kontrollierbar zu machen. Fast alle schwächeln daher am Ende, obwohl dann die vielen Handlungsmöglichkeiten erst so richtig zur Geltung kommen. Stellaris hatte das Problem damals erkannt und mit den Zwangs-KI-Gouverneuren gegengesteuert, was aber auch keine tolle Lösung war, vor allem weil die KI in verschiedenen Patchversionen immer wieder versagte. Endless Space lässt die KI-Unterstützung offen, aber eigentlich sind es Interfaceverbesserungen und Komfortfunktionen die ich mir wünschen würde – die unendliche Produktionsumwidmung hätte nicht sein müssen, Sternensysteme mit neuen Upgradeoptionen bräuchten ihre eigene Benachrichtigungsliste, und insgesamt müsste das Interface schlicht größere Bedienelemente haben. Denn auch wenn ein Spiel von 2012 nicht neu ist, ist es doch kein DOS-Klassiker und braucht sich gerade in der Bedienung nicht so geben.

Aber der obere Absatz klingt negativer, als ich das Spiel eigentlich empfand. Die Rassen mit ihren unrerschiedlichen Spielstilen machen einen erneuten Durchgang reizvoll, die Kolonisierungsphase war klasse, insgesamt greifen die Spielmechaniken bis kurz vor Ende wunderbar ineinander. Es hat schon seinen Grund, warum dieses Genre trotz der typischen Macken immer wieder aufgegriffen wird. Gerade dass Endless Space so klassisch angelegt ist sorgt eben auch dafür, dass es zwischendurch ähnlich fasziniert wie die Spiele, die das Genre in den Neunzigern geformt haben. Und dabei hat es ja schon ein paar moderne Elemente und eigene Ideen. Anspielen lohnt sich daher – es ist derzeit sogar kostenlos, wenn man sich auf der Herstellerseite registriert und einen Steam-Account verbindet.

Feedtragon war für mich der perfekte Feedreader – kein Wunder, baute ich ihn doch selbst. Als Schwachstelle entpuppte sich Superfeedr, als der als Backend genutzte Service die Preise anhob hätte ich feedtragon auf ein eigenes Backend umbauen müssen. Stattdessen benutzte ich mehrere Fertig-Feedreader: BazQux (hervorragend, aber damals wollte ich nichts bezahlen), den Digg Reader (abgeschaltet) und bis zuletzt Feedly (gut, aber etwas umständlich). Nun bin ich bei FreshRSS gelandet, was auf meinem uberspace von mir selbstgehostet wird.

Eindruck nach ein paar Wochen

FreshRSS ist freie Software (AGPL) und funktioniert einwandfrei. Die Installation ist im Uberspace-Wiki dokumentiert, uberspace bietet sich für sowas immer als unproblematischer und fähiger Hoster an. Meine Installation ist jetzt schon ein bisschen her, aber es muss gepasst haben, sonst würde ich mich an Probleme erinnern.

Das Interface ist das eines klassischen RSS-Readers. Links ist die Liste der Feeds, rechts die Artikel. Mit der Toolbar oben können diverse Aktionen mit den Artikeln durchgeführt (z.B. als Favorit markieren) und zwischen den verschiedenen Ansichten umgeschaltet werden.

Kleinigkeiten empfinde ich als nicht optimal. Das automatische Markieren als gelesen durch Scrollen der eingeklappten Artikelliste war extrem stressig, zum Glück kann die Funktion deaktiviert werden. Die Taste M sollte den Gelesen-Status von Artikel umschalten, aber bewirkt nichts. Und das Warnungsicon bei Uncategorized in der Feedliste links ist nervig, wenn wie bei mir alle Feeds nicht in Kategorien sind und das auch so bleiben soll.

Aber das sind wirklich Kleinigkeiten. Der Rest passt. Insbesondere habe habe ich den Eindruck, dass die Infrastruktur sehr gut funktioniert. Damit meine ich, dass die Software einwandfrei per Cronjob die Feeds liest und neue Artikel entdeckt. Die Darstellung der Artikel selbst ist gut, die wichtigsten Tasten J und K zum Weitergehen in der Artikelliste sind belegt. Der eingebaute RSS-Feed gibt die Option der Weiterverarbeitung. Mehr braucht es nicht.

Es tut gut, wieder einen selbstkontrollierten Feedreader zu haben. Und noch dazu einen, den ich nicht selbst bauen muss, auch wenn feedtragon wieder zum Laufen zu bringen immer noch als gutes Projekt in meinem Hinterkopf herumschwebt. Feedly hatte schon okay funktioniert, aber mir waren die Limitierungen unangenehm und es nagte auch der Gedanke, warum ich nicht freie Software benutze wenn es denn gute Optionen gibt.

Als nur tt-rss mit seinem problematischen Autor auf meinem Radar war sah das nicht so aus, aber FreshRSS füllt die Rolle gut. Unter anderem Dirk hatte die Software in seinem Blog erwähnt. Auch wenn ich nicht mehr genau weiß, welcher Autor und welcher Artikel den Ausschlag gab: Danke für den Hinweis.

Auch wenn Usability normalerweise die Benutzbarkeit von Software meint: Man muss es wirklich nicht auf Software beschränken. Die Dialogprinzipien passen auch sehr gut zu Gegenständen, Usability als Konzept sowieso. Und bei Alltagsgegenständen finden sich viele Designprinzipien, die entweder gut angewandt werden oder eben merklich fehlen. Mein Haushalt hat ein paar schöne Beispiele. Natürliches Mapping ist eines davon.

Beispiel 1: Der Herd und das Mapping

Natürliches Mapping habe ich in dieser Artikelserie noch gar nicht erwähnt. Es ist ein Konzept, um die Funktion von Knöpfen zu vermitteln. Findet sich oft bei Software, aber ist im Haushalt schöner zu erklären. Zum Beispiel mit dem Herd. Der hat ja meistens 4 oder 5 Kochfelder, die in einem Rechteck angeordnet sind.

Wenn dann das Bedienfeld so aussieht:

Welcher Regler kontrolliert dann welches Kochfeld? Das bleibt völlig unklar. Man kann es erlernen, Symbole könnten es erklären, aber es ist nicht intuitiv direkt ersichtlich.

Wenn die Bedienknöpfe dagegen in der gleichen Logik angeordnet sind wie die Kochfelder selbst, also so:

Dann wird auf einen Blick klar, welcher Regler welches Kochfeld kontrolliert. Vorausgesetzt, man schafft es zu ignorieren, dass sich in diesem Foto des Kochfelds die Dunstabzugshaube spiegelt.
Touchscreens in der Küche mag ich eigentlich nicht, aber hier wird ihr Vorteil – der geringe Platzbedarf – effektiv genutzt.

Natürliches Mapping ist eines der wenigen universellen Instrumente, mit denen klar verständliche Oberflächen und Kontrollelemente geschaffen werden können.

Beispiel 2: Dunstabzugshaube und Designerknöpfe

Der Herd macht eine Sache richtig, die Dunstabzugshaube bei uns in der Küche ist dagegen ein Negativbeispiel. Sie hat diese Knöpfe:

Auf den ersten Blick komisch ist die Einreihung des Lichts ganz rechts. Da der Knopf etwas ganz anders macht wäre es hilfreich, wenn er sich anders anfühlte oder nicht mit den anderen drei in einer Reihe angeordnet wäre. Etwas Abstand dazwischen wäre gut. So würde die verschiedene Funktionalität getrennt werden.

Richtig seltsam aber wird es, wenn man die Knöpfe drückt:

1, 2 und 3 regelt die Stärke, das ist soweit klar. Aber statt dass es exklusive Radiobuttons sind, können sie zusammen gedrückt werden. Richtig wäre, wenn ein eingedrückter Knopf wieder hochgeht sobald der nächste gedrückt wird. Stattdessen bleibt er hier einfach in Position. Und es zählt immer der stärkste. Im Beispielbild ist also welche Stärke ausgewählt? 2, denn 1 und 2 sind beide gedrückt.

Es sei nur Stärke 3 ausgewählt. Will ich jetzt von Stärke 3 auf 1 wechseln kann ich nicht einfach auf 1 drücken, sondern muss auch auf 3 drücken um diesen Knopf zu deaktivieren. Wie umständlich!

Eine Umsetzung ohne Sinn und Verstand, bei der nur darauf geachtet wurde, dass das Bedienfeld schön symmetrisch ist. Statt Produktdesign und Usability stand visuelles Design im Fokus. Das mag ein Aspekt der Benutzererfahrung sein, aber wenn Usabilitykriterien so komplett missachtet werden ist die Gesamterfahrung trotz eines ansehnlichen Aussehens immer negativ. Diese Dunstabzugshaube hätte ich mir nie ausgesucht.

Beispiel 3: Mikrowelle und Konventionen

Unsere Mikrowelle habe ich selbst ausgesucht und ich hatte ein ziemlich simples Auswahlkriterium: Ich will sie bedienen können.

Die billigsten Mikrowellen machen das oft am besten. Sie haben einen Scheibenregler für die Stärke und einen zweiten für die Dauer. Natürliches Mapping ist da kein Thema, aber es ist schnell erlernbar und einfach zu verstehen. Stärke einstellen, Dauer einstellen – ich muss nur wissen wie lange mein Essen normalerweise braucht. Und das weiß ich, bei 900W sind die Nudeln etwa in zwei Minuten aufgewärmt. So sieht das bei unserer aus, die ich selbst gebraucht gekauft und dann in die Küche getragen habe:

Der Stärkeregler ist leicht verkompliziert wegen der Grillfunktion, aber selbst das wird durch die Symbole verständlich und die Bedienung bleibt simpel genug.

Ich hätte auch so etwas kaufen können:

Und hätte mich bei jeder Benutzung geärgert, warum ich nicht einfach und schnell Stärke und Zeit auswählen kann.

Mikrowellen sind ein Beispiel dafür, dass simple Konventionen die besten sein können. Sie sind leicht erlernbar und gute Konventionen führen zu einer effizienten Bedienung. Aber der Markt ist erstaunlich fähig, sie zu ignorieren. Um eine 200€-Mikrowelle zu verkaufen darf die ja nicht so aussehen wie die 20€-Mikrowelle vom Supermarkt, entsprechend werden Funktionen draufgepackt. Dann passen die simplen Scheibenregler nicht mehr. Ergebnis: Die Produkte werden ohne Studieren der Bedienungsanleitung unbenutzbar, jede normale Benutzung dauert länger.

Beispiel 4: Waschbecken und fehlende Aufgabenangemessenheit

Ich habe noch ein Beispiel für Verschlechterung – unser Waschbecken:

Und zwar geht es um den Stöpsel. Normalerweise – so kenne ich das – wäre hinter dem Wasserhahn ein Metallhebel, mit dem der Verschluss gesenkt oder gehoben werden kann. Es gibt aber (seit einer Weile?) auch dieses Prinzip, bei dem der Stöpsel selbst bewegt wird. Meiner Wahrnehmung nach besonders häufig in schicken Hotels, aber eben auch bei uns im Bad.

Das hat ja seinen Reiz: Anstatt dass ein völlig entferntes Bedienelement erlernt werden muss, ist das zu bewegende Teil direkt beweglich. Das ist noch besser als natürliches Mapping. Der Stöpsel vermittelt durch den Greifer in der Mitte auch direkt, dass er beweglich ist – bei Interfaces spricht man da von der Affordance. Ein Button muss die Affordance haben klickbar zu sein, der Stöpsel hier, senk- und hebbar zu sein. Die Selbstbeschreibungsfähigkeit ist dadurch gegeben, der Aspekt funktioniert.

Doch ist die Lösung völlig aufgabenunangemessen, was das wichtigere Prinzip ist. Wenn das Wachbecken voll ist, muss der Nutzer jetzt in die Drecksbrühe greifen um das Wasser ablaufen zu lassen. Der Greifer hinter dem Wachbecken mag nicht schick sein, er kann kaputt gehen und die Metallverbindung unter dem Wachbecken würde Platz kosten. Aber er ist trotzdem insgesamt die viel bessere Lösung, weil nur er die Aufgabe richtig löst: Das Wasser im Waschbecken ablassen zu können, ohne ins Wasser greifen zu müssen.

Usability betrifft unseren Alltag öfter als man vielleicht zuerst glaubt. Selbst Alltagsgegenstände können in ihrer einfachen Benutzbarkeit stark variieren. Dabei ist absolut nicht gegeben, dass teure Produkte eine bessere Usability haben.

Küchen sind da besonders anfällig, weil die Leute sie basierend auf einem Ersteindruck kaufen. Aber auf den ersten Blick werden ungeschulten Augen Usabilityprobleme selten direkt auffallen. Und dann ärgert man sich jahrelang mit schlechten Lösungen rum – zum Beispiel mit der Mikrowelle, die keiner im Haus wirklich bedienen kann. Und sucht dann im Zweifel die Schuld bei sich selbst, anstatt zu erkennen, dass die Mikrowelle einfach schlecht gemacht ist.

Da beim Kauf mehr drauf zu achten lohnt sich. Einem Produkt mit guter Usability den Vorzug zu geben kann für viele Jahre einen kleinen Aspekt des Alltags etwas angenehmer machen.