Grundsätzliche Voraussetzungen

Die grundsätzlichen Voraussetzungen sind:

• passende Schriftart und Zeilenabstand
• der Bildschirmhardware und Umgebung angepasste Schriftgröße
• Zeilen nicht länger als 60 bis 70 Zeichen
• bequemer Fortschritt (“Blättern”), kein horizontales Scrollen

Passende Schriftart und Zeilenabstand

Die Schriftart (der Font) sollte optimiert sein für die Bildschirmdarstellung. Ich konnte bislang serifenlose Schriften besser lesen als jene mit Serifen aufgrund der relativ geringen Bildschirmauflösung (Pixel pro Millimeter): Die Serifen benötigen extra Pixel, nur bei größerer Auflösung/Darstellung kann ich die Serifenschrift gleich gut lesen wie eine serifenlose, klein wirkt sie auf mich unscharf, “schlierig”. Am besten ist, mir die Wahl zu lassen, mit welcher Schriftart Texte dargestellt werden: Ich teile der Darstellungssoftware die mir passende mit und diese wird fortan benutzt.

Der Abstand zwischen den Zeilen sollte größer sein als vorgegeben durch die Schriftart aufgrund der geringen Auflösung. Stehen die Zeilen eng zusammen, ist der Text einer Zeile weniger klar voneinander getrennt von darüber oder darunter stehendem. Schön wäre, ich könnte den Zeilenabstand passend für den benutzten Bildschirm einstellen, so lange das unüblich ist, ist das 1,25 – 1,5-fache der Vorgabe meist in Ordnung.

Der Bildschirmhardware und Umgebung angepasste Schriftgröße

Die Hardware limitiert:

• Auflösung: Die Auflösung sind die Pixel pro Millimeter. Mit den Pixel werden die Buchstaben/Zeichen dargestellt, je weniger Pixel pro Längeneinheit zur Verfügung stehen, desto gröber, ungenauer, schlampiger erscheinen die Buchstaben/Zeichen.
• Kontrast/Schärfe: Der Kontrast ist der Helligkeitsunterschied zwischen Buchstaben und Hintergrund. Der höchste Kontrast ist jener zwischen Schwarz – kein Pixel leuchtet – und Weiß – alle drei Farben eines Pixel leuchten in voller Stärke. Gute Monitore haben einen hohen Maximalkontrast, dieser kostet Energie und Geräte, die ihre Energie aus Akkus beziehen, liefern ihren Bildschirmen meist weniger Energie, sollen die Akkus lange halten pro Ladezyklus. Die Schärfe hängt eng zusammen mit dem Kontrast, ein niedriger Kontrast wird weniger scharf empfunden als ein hoher. Es gibt weitere Faktoren, die die Schärfe bestimmen und die ich hier nicht behandle, beispielsweise die Oberfläche des Bildschirms (Material, spiegelnd, matt), der Font (Schriftart) und die Qualität des Font-Rendering.

Die Umgebung bestimmt, wie hell es außerhalb des Bildschirms ist und ob und wie stark sich auf dem Bildschirm etwas spiegelt. Hinzu kommt, aus welcher Entfernung ich auf den Bildschirm schaue, ob ich meine Lesebrille benutze und in welcher Tagesform ich mich befinde. Da all diese Faktoren nicht programmatisch berücksichtigt werden können (zumindest in der Gegenwart), ist vorherzusehen: Ich vergrößere kleine Schrift, bis ich den Text ohne Anstrengung lesen kann.

Zeilen nicht länger als 60 bis 70 Zeichen

Sind Zeilen sehr lang, ist es schwierig, die Folgezeile schnell zu finden. Nach meinen Recherchen sind um 60 bis 70 Zeichen die Obergrenze. Kürzer dürfen Zeilen sein, wo die Untergrenze liegt, weiß ich nicht, ich könnte mir die Hälfte des Maximalwerts vorstellen, das heißt etwa 30 Zeichen. Zu kurze Zeilen sind auch nicht ergonomisch: Ich bin gezwungen, die Augen ständig zu neuen Zeilenanfängen zu bewegen und dieser Weg ist länger als jener zum nächsten Wort. Außerdem habe ich häufiger zu “blättern”.

Bequemer Fortschritt (“Blättern”), kein horizontales Scrollen

Bequem ist für mich, nur eine Taste zu drücken, damit der Text fortschreitet, nach unten rollt. Diese Taste will ich möglichst selten drücken, deshalb sollte der Fortschritt möglichst groß sein, das heißt, die erste Zeile nach danach ist jene, die der letzten zuvor folgt. Am liebsten ist mir die Leertaste, zur Not geht auch die Bild-nach-unten-Taste (Page Down).

Konsequenzen

Der Text ist einspaltig, nicht mehrspaltig

Mehrspaltiger Text ist sehr unergonomisch zu lesen, falls er nicht vollständig auf dem Bildschirm dargestellt wird: Ich bin gezwungen, pro Seite ein- bis mehrmals nach oben zu blättern, dann wieder nach unten, dann wieder nach oben, je Spalte wiederholend, in schlimmen Fällen habe ich auch noch zusätzlich horizontal zu scrollen, da Spalten weiter rechts andernfalls nicht sichtbar wären. Kurz: Statt dass ich den Text fließend lesen kann, bin ich beschäftigt mit der Navigation durch den Text und habe unfreiwillige Lesepausen, die ich nicht zum Überdenken des Texts nutze, sondern zum Steuern des Computers.

Die Zeilenlänge ist als maximale Zeichenanzahl definiert

Eine Angabe von maximal 60 (70) Zeichen sorgt dafür, dass ich schnell Folgezeilen finde und nicht zu häufig zu diesen springen muss. Das Maximum ist erforderlich: Falls der Bildschirm keine 60 oder 70 Zeichen darstellen kann – bei kleinen Bildschirmen oder großer Schrift – sollte früher umgebrochen werden, andernfalls müsste ich horizontal scrollen.

Keine PDF-Dateien

PDF-Dateien sind für ein bestimmtes Ausgabemedium vorformatiert. Alleine für den Ausdruck auf Papier ist dies zufriedenstellend möglich, die Unwägbarkeiten der Bildschirmausgabe habe ich oben angerissen. Ein PDF-Dokument für beispielsweise einen Tablet-Computer ist besser als eines für den Papierausdruck, jedoch unterstellt dies implizit heutige Hardware und ist vielleicht schon morgen überholt. Auch für den Publizierer ist es aufwändig, fortlaufend zahlreiche PDF-Dateien zu erstellen: Eine für den Papierausdruck, eine für riesige Desktop-Bildschirme, eine für Tablet-Computer, eine für Smartphones usw. Und der Benutzer hat die “Qual der Wahl”; kann/darf er nicht alle Formate auswählen und wechselt seine Hardware, hat er eine ungeeignete PDF-Datei.

Diesen Text schreibe ich, weil mich die PDF-Dateien schon immer ärgerten: Auf meinen 27 Zoll-Desktop-Bildschirm mit 2.560 × 1.440 Pixel Auflösung habe ich in der Regel keine Probleme, egal mit welchen PDF-Dateien, auf einem Notebook sieht das anders aus, über Netbooks und Smartphones kann ich nichts aussagen, aber ich wage die Prognose, dass es hier noch problematischer ist.

Ich halte folgende für die Hauptursachen, dass PDF Dateien “grassieren”, die hauptsächlich oder ausschließlich am Bildschirm gelesen werden (bei PDF-Dateien kann der Ausdruck gesperrt werden):

• Die Ersteller kommen aus dem Druckbereich (Print-Sektor) und erstellen PDF-Seiten wie Buchseiten ohne sich intensiv damit beschäftigt zu haben, wie Texte auf Bildschirmen gut zu lesen sind, wie viele unterschiedliche Bildschirme es gibt, sie wissen nicht: Es gibt nur wenig gesicherte Erkenntnisse über das Ausgabemedium im Gegensatz zum Druckbereich, bei dem Papier und Druckmaschinen von vorneherein bekannt sind und wo der Ausdruck vorher über Proofs sichergestellt/optimiert werden kann
• Die Seite soll unbedingt im Gesamtbild gut aussehen, überhaupt herrscht noch der ungeeignete Seitenbegriff vor: Computertexte sind eher altägyptische Papyrusrollen und keine zwischen zwei Buchdeckeln gebundene Seiten; Buchseiten sind optimiert für das schnelle Auffinden von Textstellen, Computer können beliebig Sprungmarken setzen und den Text komplett durchsuchen, sodass (nummerierte) Seiten überflüssig sind
• Die Seite auf allen Computern gleich aussehen, das im Voraus festgelegte Aussehen darf/soll nicht variieren
• Es wird so erledigt, weil es “Gang und Gäbe” ist, jeder geht so vor

Lösung: Adaptive Layouts benutzen

Ich kann nur über Hypertext schreiben: Hier lässt sich über die Cascading Style Sheets (CSS) die Zeilenbreite definieren basierend auf der Buchstabengröße (em) und eine Maximalbreite so vorgeben, dass horizontales Scrollen nicht nötig ist (max-width). Auch können Bilder mit CSS so skaliert werden, dass sie vollständig dargestellt werden und nicht rechts oder unten abgeschnitten.

Ich gehe davon aus, für E-Book-Reader ist ein ähnliches Format definiert.

Der Artikel bezieht sich hauptsächlich auf Programme, die mit dem Benutzer interagieren. Er gilt aber auch für Programme, die ohne Aufsicht (im Hintergrund) ablaufen: Diese können in der Regel zwar keine Benutzereingaben anfordern, die eine Fehlerbehebung anbieten, jedoch haben sie Fehler in eine Logdatei (Protokolldatei, Windows-Ereignisanzeige) zu schreiben in der gleichen Qualität.

Qualitätsabstufungen: Wie melden Computerprogramme Fehler?

Die Qualität der Fehlermeldungen steigt mit jedem Aufzählungspunkt, den letzten Punkt sollten wir von Programmen einfordern, den vorletzten hat ein Programm mindestens einzuhalten.

• Keine Fehlermeldung bei Fehlern: Leider gibt es noch Programme, die Fehler nicht melden und ich habe unter Umständen nachzuschauen, ob das Programm die Arbeit richtig erledigte. Reagierte das Programm nicht wie beabsichtigt und ich habe Glück, schreibt es eine gute Fehlermeldung in eine Logdatei. Habe ich Pech, kann ich nur durch Intuition, Versuch und Irrtum das Programm zum Funktionieren überreden.
• "Es ist ein unbekannter Fehler aufgetreten": Hier weiß ich, etwas lief schief, aber nicht was. Vor zwei Tagen wollte ich Daten auf eine Blu-ray-Disc brennen und das Brennprogramm zeigte genau diesen Text an. Ursache war, dass im gleichen Verzeichnis der gleiche Dateiname einmal mit großem Anfangsbuchstaben stand und einmal mit kleinem (text.txt und Text.txt), was anscheinend die benutzte UDF-Version nicht erlaubt (prinzipiell ist dies möglich) bzw. das Brennprogramm nicht akzeptiert. Diese Ursache musste ich selbst herausfinden und das war nicht einfach, für ein Computerprogramm hingegen ist dies kein größeres Problem, beispielsweise kann es intern alle Dateinamen eines Verzeichnisses in Kleinbuchstaben umwandeln und zählen wie häufig jeder klein geschriebene vorkommt.
• Falsche Fehlermeldung: Die Fehlermeldung hat nichts zu tun mit der Ursache. Durch (Web-) Recherche habe ich herauszufinden, unter welchen Umständen diese Meldung bislang auftrat und alle Lösungsvorschläge der Reihe nach so lange durchzuführen, bis das Programm richtig läuft.
• Fehlernummern: Statt einer Beschreibung des Fehlers erscheint eine Meldung in der Art: "Es ist ein Fehler aufgetreten. Fehler-Code 0x47110815B2312". Durch (Web-) Recherche führt der Fehlercode zum tatsächlichen Fehler oder auch nicht. Die misslungenen automatischen Updates von Windows 7 lieferten mir bislang nur solche Fehlercodes, deren Erklärung ich dann auf dem Microsoft Website anschauen musste. Dort waren für den gleichen Code in der Regel mehrere mögliche Ursachen aufgelistet und ich durfte die Lösungsvorschläge je Ursache der Reihe nach durchprobieren. Das kostete sehr viel Zeit und führte selten zum Erfolg.
• Richtige Fehlermeldung: Nur in diesem Fall kann ich den Fehler ohne viel Stress beheben. Voraussetzung ist eine gute Formulierung, beispielsweise: "Die Datei abc.txt kann nicht in das Verzeichnis xyz geschrieben werden, da Sie keine Schreibrechte im Verzeichnis xyz besitzen".
• Richtige Fehlermeldung inklusive Lösungsvorschlag: Um beim letzten Beispiel zu bleiben, könnte ergänzend erklärt werden, wie ich Schreibrechte erhalte. Eigentlich sollte eine Schaltfläche "Schreibrechte erlangen" auf der Fehlermeldung existieren mit guter Usability, keine kruden Dialoge, bei denen ich mehrfach auf weitere Schaltflächen zu klicken habe, die erneut Dialoge öffnen, wie beispielsweise bei der Rechtevergabe über den Windows-Explorer.

Fazit: Kann das Programm den Fehler nicht beheben, hat es zumindest eine präzise Beschreibung der Ursache zu liefern, damit ich ohne Zeitverschwendung weiß, ob ich etwas tun kann und was ich tun sollte. Kann es den Fehler beheben, sollte die Fehlermeldung eine Schaltfläche enthalten, die dies durchführt ohne dass ich hierbei unnötig viel zu unternehmen habe (gute Usability/Gebrauchstauglichkeit), im besten Fall ist das ein (einziger) Mausklick oder Eintippen eines Buchstabens auf der Kommandozeile.

Wir schreiben das Jahr 2012 und noch immer halte ich diesen Artikel für nötig aufgrund täglichen Herumärgerns mit schlechten Fehlermeldungen. Weshalb sollen viele Benutzer enorme Zeit aufwenden und Fehlerursachen häufig erraten anstelle dass sich wenige Programmierer etwas mehr Zeit nehmen beim Programmieren?

Programmiertechnik grob angerissen

Ein Programmierer sollte es als “Ehrensache” betrachten, gute Fehlermeldungen zu liefern. Darüber freuen sich nicht nur die Benutzer, auch der Programmierer kann so Bugs schneller beheben.

Oft entstehen Fehler in “unteren Schichten”, in Methoden (Funktionen, Prozeduren, Subroutinen) die durch Methoden aufgerufen werden, die durch Methoden aufgerufen werden usw. Falls die Programmiersprache Ausnahmen (Exceptions) werfen kann wie beispielsweise C++ und Java, sollte eine Methode davon bei Bedarf Gebrauch machen.

Ein Fehler, über den ich mich häufig an dieser Stelle ärgerte, ist, der Exception nicht alle verfügbaren Daten zu geben, die helfen können, den Fehler möglichst genau zu identifizieren und zu beheben. Das sind neben dem Wortlaut des Fehlers (Fehlernachricht, Error Message) unter anderem die Methodenparameter und die präzise Systemzeit (Millisekunden oder genauer). Ich warf in einem C++-Programm eine Exception, falls beim Öffnen einer Datei das Dateiformat ungültig war, vergaß jedoch den Dateinamen in die Meldung zu schreiben. Da die Datei nicht durch Benutzerauswahl geöffnet wurde, hatte ich bei Fehlern immer viel Arbeit, den Benutzern zu erklären, wo er sie finden kann.

Kann eine Methode eine Exception nicht beheben, reicht sie diese weiter oder wirft eine Exception mit dem Exception-Objekt als Ursache und mit zusätzlichen dienlichen Informationen. Das geht so weiter bis hin in die oberste Schicht, die den Fehler protokolliert und die Fehlermeldung anzeigt.

Die Meldung richtet sich nach der Aufgabe der obersten Schicht, sie lautet beispielsweise "Die Datei Blafasel.txt konnte nicht geöffnet werden!". In einem Detailabschnitt stehen dann alle Meldungen vorheriger Exceptions wie beispielsweise "Die Datei Blafasel.txt existiert nicht" oder "Im Verzeichnis xyz fehlen Leserechte" oder "Die Datei Blafasel.xml hat ein ungültiges Dateiformat: Zeile 25 hat ein schließendes Tag </blubb> ohne dass vorher ein öffnendes Tag <blubb> existiert".

Falls es möglich ist, sollte in der Logdatei der gesamte Callstack stehen, so weiß der Programmierer, von wo aus es im Quellcode zum Fehler ging wo genau er auftrat und kann Bugs manchmal sekundenschnell beheben.

Ich integriere in Fehlermeldungen eine Schaltfläche zum Schicken einer E-Mail, das Benutzen eines Bugtracking-Systems führt garantiert zu viel weniger Feedback, da es wissenden Programmbenutzern eine Menge Arbeit aufbürdet und die unwissenden ausschließt.

Hat eines meiner Programme Bugs, stehe ich in der “Schuld”, diese zu beheben und ich finde es unschön, falls der Benutzer neben dem negativen Erlebnis auch noch viel Arbeit hat, Fehler zu melden. In der Regel werden Benutzer diese Arbeit unterlassen, sofern sie für das Programm nicht Geld bezahlten und statt dessen ein anderes benutzen, falls es Alternativen gibt.

Siehe auch: "Über meine Buchempfehlungen".

]]> http://www.elmar-baumann.de/blog/2011/12/19/buchempfehlungen/feed/ 0 http://www.elmar-baumann.de/blog/2011/12/19/uber-meine-buchempfehlungen/ http://www.elmar-baumann.de/blog/2011/12/19/uber-meine-buchempfehlungen/#comments Mon, 19 Dec 2011 19:42:08 +0000 Elmar http://www.elmar-baumann.de/blog/?p=1231 Empfehle ich Bücher, verzichte ich in der Regel auf Inhaltsbeschreibungen. Diese können Sie auf den Webseiten der Verlage oder Anbieter lesen. Für eine Rezension fehlt mir vermutlich die Zeit. Daher liste ich nur die Autoren, Titel, Verlage, Jahr der Ausgaben und ISBN auf.
]]> http://www.elmar-baumann.de/blog/2011/12/19/uber-meine-buchempfehlungen/feed/ 0 http://www.elmar-baumann.de/blog/2011/11/10/ist-in-ferner-zukunft-zu-lesen-was-ich-heute-im-web-veroeffentliche/ http://www.elmar-baumann.de/blog/2011/11/10/ist-in-ferner-zukunft-zu-lesen-was-ich-heute-im-web-veroeffentliche/#comments Thu, 10 Nov 2011 20:30:20 +0000 Elmar http://www.elmar-baumann.de/blog/?p=1188 Schreibe ich im Folgenden von Daten, verstehe ich darunter Texte, Bilder, Filme – prinzipiell alles, das sich digitalisieren lässt.


Kopien

Kopien meiner Daten können auf verschiedenen Computern existieren, beispielsweise kann jeder meine Texte auf die Festplatte seines Rechners speichern, Suchmaschinen und Wayback-Maschinen erledigen dies fortlaufend. Im Gegensatz zum eigenen Site, der alles enthält, das ich veröffentliche, können die Daten dort unvollständig sein, Wayback-Maschinen speichern beispielsweise keine Bilder. Vermutlich werden Ausdrucke meiner Texte auf Papier am längsten bestehen.

Speicherung der Daten

Speichere ich meine Daten auf einem Server eines Internet Service Providers, sind sie so lange zu erreichen, wie ich den Provider bezahlen kann oder will, vorausgesetzt, er ist ausreichend kompetent bezüglich der Internetanbindung.

Prinzipiell sollte ich damit rechnen, dass Daten, die ich auf Rechnern von Providern speichere, die ich nicht dafür mit Geld bezahle, von heute auf morgen verschwunden sein können. Facebook, das ich nicht nutze, könnte entscheiden: Dieser Benutzer klickt zu wenig auf Werbung oder zu wenige schauen an, was er schreibt, deshalb wird von ihm nichts mehr veröffentlicht. Es könnte, wie jeder andere Anbieter, der das Geld zum Betrieb seiner Webserver aus anderen Quellen bezieht, aus Geldmangel sein Angebot einschränken, zukünftig Geld dafür verlangen oder es einstellen.

Sicherung (Backup)

Was ich nicht auf meine privaten physikalischen Datenträger gespeichert habe, entzieht sich meiner Kontrolle. Ist eine Cloud, deren Hardware mir nicht zugänglich ist, die ich nicht besitze, der einzige Speicherort meiner digitalen Daten, sollte ich damit rechnen, dass diese unwiederbringlich verloren gehen können, wie das beispielsweise bei Amazon geschah.

Meine statischen HTML-Seiten schreibe ich ohnehin auf meinen lokalen Computer, was in Datenbanken auf Webservern gespeichert wird, wie dieser Blog-Artikel, lasse ich automatisiert auf meine Rechner übertragen, das tägliche Backup sichert die übertragenen Daten zusätzlich.

Die automatisierte Sicherung von Datenbankinhalten auf lokale Rechner und von dort auf Backupmedien dürfte weniger technikaffinen vermutlich zu kompliziert sein.

Ein Backup, das sich automatisiert auf eigene lokale Datenspeicher übertragen lässt, wird vermutlich eher selten von Anbietern wie Facebook zu erwarten sein. Falls doch, stelle ich mir die Frage: Ist das Backup in einem Format, das anderswo – nicht bei diesem Anbieter – zugänglich wiederhergestellt werden kann? Dazu kämen eigentlich nur (X-) HTML infrage sowie XML inklusive relativer Verlinkung, halbwegs akzeptabel wäre ein Format, das sich so konvertieren lässt, dass es verbreitete Content Management-Systeme wie TYPO3 oder WordPress nutzen können.

Wiederherstellung (Restore)

Habe ich meine Daten gesichert, bereitet die Wiederherstellung von HTML-Dateien wenig Probleme. Komplizierter ist das Wiederherstellen dynamischer Inhalte von Content Management-Systemen oder Blogs und Wikis, wobei sich darüber streiten lässt, ob Blogs und Wikis nicht Content Management-Systeme sind, wohin ich tendiere, jemand der Spezialist auf diesem Gebiet ist, sieht das vielleicht anders. Die Datenbank einschließlich Inhalt sollte sich mit wenig Aufwand wiederherstellen lassen.

Was ist jedoch, falls das Programm, das diese Inhalte an den Webserver liefert – TYPO3, WordPress, MediaWiki, …– ein anderes Datenbankformat erwartet – zusätzliche/andere Tabellen/Spalten, falls es eine relationale Datenbank nutzt? Ich glaube nicht, dass eine WordPress-Version in 10 Jahren die heutige Datenbank dieses Blogs benutzen kann. Die Konvertierung in ein neues Format funktioniert bei vermutlich allen Content Management-Systemen nur über ein paar Versionen hinweg. Anders ausgedrückt: Ich sollte fortlaufend Updates durchführen, das hat WordPress von den mir bekannten Programmen am besten gelöst.

Programme, die dynamisch Inhalte an den Webserver liefern

Ich könnte auf die Idee kommen, stets die gleiche Programmversion zu benutzen, damit ich die Datenbank nicht anpassen muss. Abgesehen davon, dass dies wenig zu empfehlen ist, da praktisch jedes Programm Sicherheitslücken hat, die in den neuen Versionen behoben werden, kann folgendes geschehen: Das Programm läuft nicht mehr, zeigt nichts mehr an. Beispiel: Auf dem Webserver wird eine neuere PHP-Version installiert – damit laufen viele Programme wie WordPress, TYPO3 oder das MediaWiki. Je nach Programm oder Programmfunktion wird nun mit der neuen PHP-Version nichts mehr angezeigt oder nur Teile des Inhalts. Auch könnte die Schnittstelle zur Datenbank sich ändern, damit käme das alte Programm nicht mehr zurecht.

Einer der Gründe, weshalb Programme, die ich heute schreibe, morgen nicht mehr funktionieren könnten, ist die stetige Weiterentwicklung von Programmiersprachen, Programmbibliotheken und Betriebssystemen – den Wirten der Programme: Meine Programme rufen Systemfunktionen auf, die morgen vielleicht nicht mehr existieren und wie alle umfangreicheren Programme nutzen sie Bibliotheken, Module, DLLs, Klassen etc.. Diese könnten zukünftig nicht mehr zur Verfügung stehen, nicht mehr alle Funktionen anbieten oder sich anders verhalten.

Deshalb sind statische HTML-Seiten – HTML-Dateien – am langzeitstabilsten, aber sie sind auch mühseliger zu erstellen als ein Blogartikel.

Anzeigeprogramme

Unter einem Anzeigeprogramm verstehe ich in diesem Zusammenhang beispielsweise den Webbrowser, in dem Sie vermutlich diesen Artikel lesen. Es gibt andere Möglichkeiten, den Text zu lesen, diese dürften eher selten in die Praxis umgesetzt werden, beispielsweise Herunterladen mit wget und Öffnen der heruntergeladenen HTML-Datei mit LibreOffice, … Das Anzeigeprogramm kommuniziert auf bestimmte Weise mit einem Webserver, der die Daten auf bestimmte Weise ausliefert.

Der genaue Ablauf wird sich nicht so schnell ändern, aber falls das geschieht, falls das Internet beispielsweise ein anderes Protokoll als TCP/IP benutzt und die Kommunikation zwischen den verbundenen Computern anders gelöst ist, dürfte gelten: Statische HTML-Seiten werden auch dann einfach auszuliefern sein; ohne Hinzutun werden dynamische Inhalte wie dieser Blog-Artikel wohl nicht mehr abzurufen sein.

Weitere Probleme bereiten proprietäre Formate wie beispielsweise Flash anstelle HTML: Diese können eher nicht mehr in Gebrauch sein, als man denkt, beispielsweise will Adobe Flash nicht mehr weiterentwickeln, das mobile Plugin ist nur exemplarisch, es ist eher wahrscheinlich, dass es komplett nicht mehr weiterentwickelt wird.

Kurz: Was ich nicht als Text im (X-) HTML-Format veröffentliche, ist weniger zukunftssicher, Bilder gängiger Formate wie PNG oder JPEG sollten auch in fernerer Zukunft von Computerprogrammen dargestellt werden können.

Zusammenfassung

Will ich mich lange im World Wide Web präsentieren, erreiche ich das am besten so:

• Ich veröffentliche die Inhalte bei Internet Service Providern, die ich dafür bezahle und die mich den Webserver ausreichend steuern lassen. Nur so habe ich Kontrolle darüber, was genau wie lange unter einem URI abgerufen werden kann; ich setze voraus, ich bin der Inhaber der Domain des URIs.
• Alle Inhalte sind auch lokal bei mir gespeichert, sodass ich diese bei Providerwechsel ohne größeren Aufwand übertragen kann.
• Ich weiß: Statische HTML-Seiten – HTML-Dateien – sind am langzeitstabilsten
• Dynamische Seiten:
  • Die dynamischen (Datenbank-) Inhalte lasse ich automatisiert lokal sichern
  • Ich aktualisiere permanent die den Inhalt generierenden Programme – Content Management-Systeme, Blogsoftware etc. – inklusive deren Umgebung – Module, Bibliotheken etc.
  • Mit dem Update der Programme aktualisiere ich das Format der Inhalte – die Datenbank, falls erforderlich, damit die neuen Programmversionen den Inhalt interpretieren können

Wer will meine Texte zukünftig lesen?

Ich habe nur die Oberfläche angekratzt, Datenpersistenz ist nicht trivial, Computer und Programme sind komplex. Trotzdem bin ich nicht beunruhigt: Wer will morgen lesen, was ich heute schreibe? Es ist nicht einfach, die permanent wachsende Datenmenge zu filtern und auszuwerten, da bleibt kaum Zeit, in Altem zu stöbern. Vielleicht präsentiert eine Suchmaschine älteres erst so nachrangig, dass es ohnehin niemand mehr findet.

Die Frage, welche meiner Texte morgen zu lesen sein sollen, ist mir zu philosophisch. Ich gehe nur kurz auf technische Themen ein, unter die ich die überwiegende Mehrzahl meiner Texte einordne.

Texte über Technik werden wohl nur so lange interessant sein, wie die Technik gebräuchlich ist. Die Eigenheiten eines fotografischen Films dürften die wenigsten interessieren, da praktisch jeder mit Digitalkameras fotografiert, wie ich im RAW-Konverter der Version 1 etwas bewerkstellige, ist für mich uninteressant, wenn ich die Version 3 benutze und dort anders vorzugehen ist.

Ich sollte mich eher fragen: Welche Texte lösche ich oder kennzeichne diese als veraltet, sodass sie weniger stören.

]]> http://www.elmar-baumann.de/blog/2011/11/10/ist-in-ferner-zukunft-zu-lesen-was-ich-heute-im-web-veroeffentliche/feed/ 0 http://www.elmar-baumann.de/blog/2011/09/26/das-netbeans-lookup-fur-nicht-rcp-projekte-benutzen/ http://www.elmar-baumann.de/blog/2011/09/26/das-netbeans-lookup-fur-nicht-rcp-projekte-benutzen/#comments Mon, 26 Sep 2011 17:35:53 +0000 Elmar http://www.elmar-baumann.de/blog/?p=1128 Im Artikel Java-Aktionen richtig benutzen überlegte ich, wie Java-Actions ihre Daten erhalten und sich aktivieren oder deaktivieren abhängig davon, ob es relevante Daten gibt. Ich wollte nicht Swing-Components nach Daten befragen, die Actions dort als Listener registrieren und auf Statusänderungen des GUI reagieren. Als Lösung schlug ich Lookups vor – Container mit Elementen, die Beobachter benachrichtigen, falls sich ihr Inhalt ändert.

Ein solches Lookup benutzen NetBeans Platform-Anwendungen, es kann in Nicht-Platform-Anwendungen eingesetzt werden. Die Projekte integrieren dazu das JAR org-openide-util-lookup.jar, es ist unterhalb des NetBeans-Installationsverzeichnisses im Verzeichnis platform/lib.


Zugrunde liegende Idee

• Ein Anwendungsmodul hat einen oder mehrere Lookups
• Wird im GUI etwas ausgewählt oder abgewählt, gelangen relevante Daten, die das GUI-Element repräsentiert, in eines der Lookups
• Die Actions beobachten das Lookup: Ist es leer, sind sie deaktiviert, enthält es Elemente, sind sie aktiviert. In actionPerformed() benutzen Actions die Elemente des Lookups.

Das NetBeans-Lookup benachrichtigt Beobachter nur, falls Daten eine bestimmten Typs im Lookup sind: Eine Action, die Personen in eine Datenbank speichert, will in der Regel nicht wissen, ob und wieviele Bücher im Lookup sind.

Beispiels-Implementierung

Ich habe ein Beispiels-Projekt implementiert und in ein ZIP-Archiv gepackt. Nach dem Entpacken kann es mit NetBeans geöffnet werden. Das Kontextemenü des Projects-Window bietet Run oder Debug an (auf die Klasse Main mit der rechten Maustaste klicken).

(Nur) Der Übersichtlichkeit wegen verzichtete ich bei den Beispielen auf Parameterüberprüfung, in “Produktions-Code” sollten die Parameter überprüft werden, beispielsweise eine NullPointerException geworfen, falls null überreicht wird anstelle einer erwarteten Objektreferenz.

LookupAction

Die LookupAction habe ich kopiert aus dem Projekt JPhotoTagger. LookupActions beobachten einen Lookup. Bei Aufruf von actionPerformed() ruft die LookupAction bei den spezialisierten Actions die abstrakte Methode actionPerformed(Collection<? extends T> lookupContent) auf, mit isEnabled(Collection<? extends T> lookupContent) können sie entscheiden, ob sie aktiviert sein sollen, in der Regel werden sie true liefern, falls der Lookup-Content Elemente enthält.

public abstract class LookupAction<T> extends AbstractAction implements LookupListener {

    private final Class<? extends T> lookupResultClass;
    private final Lookup lookup;
    private Lookup.Result<? extends T> lookupResult;

    protected LookupAction(Class<? extends T> lookupResultClass, Lookup lookup) {
        this.lookupResultClass = lookupResultClass;
        this.lookup = lookup;
        setLookupResult();
    }

    protected abstract boolean isEnabled(Collection<? extends T> lookupContent);

    protected abstract void actionPerformed(Collection<? extends T> lookupContent);

    private void setLookupResult() {
        if (lookupResult == null) {
            lookupResult = lookup.lookupResult(lookupResultClass);
            lookupResult.addLookupListener(this);
            resultChanged(null);
        }
    }

    @Override
    public void resultChanged(LookupEvent evt) {
        setEnabledInDispatchThread();
    }

    private void setEnabledInDispatchThread() {
        final boolean isEnabled = isEnabled(lookupResult.allInstances());

        if (EventQueue.isDispatchThread()) {
            setEnabled(isEnabled);
        } else {
            EventQueue.invokeLater(new Runnable() {

                @Override
                public void run() {
                    setEnabled(isEnabled);
                }
            });
        }
    }

    protected Collection<? extends T> getLookupContent() {
        return (lookupResult == null)
                ? Collections.<T>emptyList()
                : lookupResult.allInstances();
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        setLookupResult();
        actionPerformed(lookupResult.allInstances());
    }
}

Eigenes Lookup

Die Klasse ModifiableLookup liefert ein Lookup und bietet Methoden an, dessen Inhalt zu modifizieren.

public final class ModifiableLookup implements Lookup.Provider {

    private final InstanceContent content = new InstanceContent();
    private final Lookup lookup = new AbstractLookup(content);

    @Override
    public Lookup getLookup() {
        return lookup;
    }

    public void add(Object content) {
        this.content.add(content);
    }

    public void remove(Object content) {
        this.content.remove(content);
    }

    public void set(Collection<?> content) {
        this.content.set(content, null);
    }
}

Beispiel: Ausgewählte Listenelemente in das Lookup einfügen

Will ich ausgewählte Items einer JList in das Lookup einfügen, kann ich folgende Klasse benutzen:

public final class LookupListSelectionListener implements ListSelectionListener {

    private final ModifiableLookup lookup;

    public LookupListSelectionListener(ModifiableLookup lookup) {
        this.lookup = lookup;
    }

    @Override
    public void valueChanged(ListSelectionEvent e) {
        if (!e.getValueIsAdjusting()) {
            JList list = (JList) e.getSource();
            List<Object> selectedValues = Arrays.asList(list.getSelectedValues());
            lookup.set(selectedValues);
        }
    }
}

Beispielsklassen, die in das Lookup sollen

public final class Human {

    private final String name;

    public Human(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return name;
    }
}

public class Dog {

    private final String name;

    public Dog(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name + " (Wuff)";
    }
}

public final class CreatureListModel extends DefaultListModel {

    private static final long serialVersionUID = 1L;

    public CreatureListModel() {
        addElement(new Human("Anton"));
        addElement(new Human("Berta"));
        addElement(new Human("Cäsar"));
        addElement(new Human("Dora"));
        addElement(new Human("Emil"));
        addElement(new Dog("Fiffi"));
        addElement(new Dog("Waldi"));
    }
}

Kommunikation über ein zentrales Lookup

Ein Anwendungsmodul kann Lookups beispielsweise so bereitstellen:

public final class Lookups {

    public static final Lookups INSTANCE = new Lookups();
    private final ModifiableLookup humansLookup = new ModifiableLookup();

    public ModifiableLookup getHumansLookup() {
        return humansLookup;
    }

    private Lookups() {
    }
}

Erweiterte LookupAction

Die erweiterte LookupAction interessiert sich (nur) für Instanzen von Human

public final class ShowHumansInLookupAction extends LookupAction<Human> {

    private static final long serialVersionUID = 1L;

    public ShowHumansInLookupAction() {
        super(Human.class, Lookups.INSTANCE.getHumansLookup().getLookup());
        putValue(Action.NAME, "Zeige ausgewählte Menschen");
    }

    @Override
    protected boolean isEnabled(Collection<? extends Human> humans) {
        return !humans.isEmpty();
    }

    @Override
    protected void actionPerformed(final Collection<? extends Human> humans) {
        JOptionPane.showMessageDialog(null, humans);
    }
}

In einem GUI benutzen

Die entscheidenden Zeilen in einem GUI, die Action ist einem Button zugeordnet, Model und ListSelectionListener der Liste:

    list.setModel(new CreatureListModel());
    list.addListSelectionListener(new LookupListSelectionListener(Lookups.INSTANCE.getHumansLookup()));
    button.setAction(new ShowHumansInLookupAction());

Worauf achten beim Ausführen der Beispielsanwendung

• Ist nicht ausgewählt, setzt sich die Action automatisch auf deaktiviert, der Button mit der Action ist deaktiviert (“ausgegraut”)
• Werden ein oder mehrere Menschen ausgewählt, ist die Action aktiviert, der Button reagiert auf Klicks (Betätigung)
• Sind nur Hunde ausgewählt, ist der Button deaktiviert
• Die Action erhält nur Menschen: Sind Hunde und Menschen ausgewählt, zeigt bei Klick auf den Button die Action den Lookup-Content an – es sind nur die erwarteten Objekte darin

Vorteile

• Die Action ist nicht an ein GUI gebunden (sie benötigt nur ein Lookup). Sie ist nicht anzupassen, falls später beispielsweise ein JTree die Geschöpfe anzeigt (getrennt nach Mensch und Tier). Es könnte auch ein Dialog zum Ändern der Daten eines Menschen benutzt werden: Der “Mensch im Dialog” gelangt in das Lookup, das die Action benutzt.
• Die Action fragt nicht nach den benötigten Daten, sie erhält sie
• Die Action aktiviert und deaktiviert sich automatisch
• Das Lookup könnte über Modulgrenzen hinweg benutzt werden, beispielsweise über das Java-Service Provider Interface (SPI) oder ein globales Lookup, wie es die NetBeans-Platform anbietet. Die Actions anderer Module sind nur mit dem passenden Lookup zu verknüpfen, sie müssen nicht wissen, woher die Daten kommen (wie sie an diese gelangen).
• Actions sind nur ein Beispiel, es können beliebige Klassen LookupListener sein
]]> http://www.elmar-baumann.de/blog/2011/09/26/das-netbeans-lookup-fur-nicht-rcp-projekte-benutzen/feed/ 0 http://www.elmar-baumann.de/blog/2011/09/21/java-laufzeitausnahmen-anzeigen-variante/ http://www.elmar-baumann.de/blog/2011/09/21/java-laufzeitausnahmen-anzeigen-variante/#comments Wed, 21 Sep 2011 19:47:04 +0000 Elmar http://www.elmar-baumann.de/blog/?p=1098 Im Artikel “Java: Laufzeitausnahmen anzeigen” steht, wie ich im AWT-EventDispatchThread nicht gefangene Ausnahmen mit einem Dialog anzeige. Inzwischen verfolge ich eine weniger “aufdringliche” Variante, die nicht von der Arbeit ablenkt oder das Schließen des Programmfensters verhindert, falls im EventDispatchThread laufend neue Ausnahmen geworfen und nicht gefangen werden:

• Die Ersatz-EventQueue benutzt das Logging-System und loggt die Ausnahme mit dem Level SEVERE
• Ein Handler – ein erweiterter java.util.logging.Handler – reagiert auf bestimmte Loglevel, zeigt beispielsweise einen “Fehlerindikator” an, bei Klick darauf erhält der Benutzer nähere Informationen über den Fehler

Modifizierte EventQueue

public final class AppEventQueue extends java.awt.EventQueue {

    @Override
    protected void dispatchEvent(AWTEvent event) {
        try {
            super.dispatchEvent(event);
        } catch (Throwable t) {
            Logger.getLogger(AppEventQueue.class.getName()).log(Level.SEVERE, null, t);
        }
    }
}

Handler

public final class ErrorLogHandler extends Handler {

    private static final int MIN_LOG_LEVEL_VALUE = Level.WARNING.intValue();

    public ErrorLogHandler() {
        Logger.getLogger("").addHandler(this);
    }

    @Override
    public void publish(LogRecord record) {
        int recordLevelValue = record.getLevel().intValue();
        boolean isError = recordLevelValue >= MIN_LOG_LEVEL_VALUE;

        if (isError) {
            // Hier den Fehler visualisieren
        }
    }

    @Override
    public void flush() {
        // ignorieren
    }

    @Override
    public void close() throws SecurityException {
        // ignorieren
    }
}

Der Handler fügt sich dem root Logger hinzu, der root Logger ruft die Handler-Methode publish() auf. Jeden Loglevel ab WARNING betrachtet der Handler als Fehler (isError). Bei Fehlern kann er beispielsweise über die setIcon()-Methode eines Labels ein Fehler-Icon setzen und bei Klick auf das Label die Fehlerinformationen anzeigen, beispielsweise anhand Fehler-LogRecords, die er temporär speichert.

EventQueue ersetzen

Die EventQueue ersetze ich “rechtzeitig” durch folgende Codezeile (im Projekt JPhotoTagger unmittelbar nach Erzeugen des Programmfenster-Frames):

Toolkit.getDefaultToolkit().getSystemEventQueue().push(new AppEventQueue());

Die folgenden Abbildungen zeigen die Auswirkungen: In NetBeans setzte ich einen Haltepunkt in die Zeile 127 der Klasse AppInit, Methode setJptEventQueue(), das ist die Zeile mit dem push()-Afuruf. Gelb unterlegt ist der Thread AWT-EventQueue-0. Nach Aufruf ist zu sehen, dass nun Thread AWT-EventQueue-1 läuft, die Namen lassen sich nicht ändern, es wird nur die Nummer hochgezählt.


JPhotoTagger: AWT-EventQueue ersetzen, Debugger-Ansicht vor Ersetzen


JPhotoTagger: AWT-EventQueue ersetzen, Debugger-Ansicht nach Ersetzen.


Fehleranzeige durch einen Log-Handler in JPhotoTagger am unteren Programmfensterrand.

Außerhalb der AWT-EventQueue

In anderen Threads kann ich nicht gefangene Ausnahmen loggen mit java.lang.Thread#setDefaultUncaughtExceptionHandler() – der Handler wird nicht aufgerufen im AWT-Event Dispatch Thread. Beispiel:

public final class UncaughtExceptionLogger implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
         Logger.getLogger(UncaughtExceptionLogger.class.getName()).log(Level.SEVERE, null, e);
    }
}

Benutzung:

Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionLogger());

Zusammenfassung (mit Erweiterung um FileHandler)

• Nicht gefangene Ausnahmen sollen dem Benutzer unaufdringlich angezeigt werden und in einer Logdatei stehen
• Ein erweiterter java.util.logging.Handler zeigt dem Benutzer Probleme an ab dem Loglevel WARNING, ein java.util.logging.FileHandler schreibt die LogRecords in eine Logdatei. Diese Handler füge ich dem root Logger hinzu.
• Je ein Logger loggt ungefangene Ausnahmen mit dem Level SEVERE
  • im AWT-EventDispatchThread in einer eigenen EventQueue, die die “Standard”-EventQueue ersetzt
  • in (allen) anderen Threads in einem java.lang.Thread.UncaughtExceptionHandler, den ich setze mit Thread#setDefaultUncaughtExceptionHandler()
]]> http://www.elmar-baumann.de/blog/2011/09/21/java-laufzeitausnahmen-anzeigen-variante/feed/ 0 http://www.elmar-baumann.de/blog/2011/09/20/quellcode-auf-webseiten/ http://www.elmar-baumann.de/blog/2011/09/20/quellcode-auf-webseiten/#comments Tue, 20 Sep 2011 19:46:10 +0000 Elmar http://www.elmar-baumann.de/blog/?p=1075 Die Breite für Texte auf einer Webseite sollte beschränkt sein auf etwa 60 bis 70 Zeichen. Längere Zeilen sind schwieriger zu lesen: Der Beginn von Folgezeilen ist schwieriger zu finden. Quellcode von Computerprogrammen hat oft mehr Zeichen pro Zeile. In der Regel wird er eingebettet in <pre>-Blöcke, so bleibt seine Formatierung erhalten. Sollen Fließtext und Quellcode auf Webseiten gemischt werden und die Darstellungsfläche des Quellcodes soll nicht breiter werden als jene des Texts, geschieht das nach meinen Erfahrungen meistens auf folgende ungünstige Weisen:

• Der Code ist in einer Art “Unterfenster”, verschiebe ich eine horizontale Scrollbar (Scroll-Leiste), sehe ich das Ende längerer Zeilen
• Der Code wird rechts abgeschnitten

Die horizontale Scrollbar hat mindestens folgende “gravierende” Nachteile:

• Ich kann nicht den gesamten Code auf einmal sehen, schiebe ich die Scrollbar nach rechts, ist der Code links abgeschnitten
• Ich kann nicht wie gewohnt navigieren, bin gezwungen mit der Maus extra eine Scrollbar anzusteuern, will ich anschließend den Text lesen, muss ich wieder anders vorgehen. Ich bin es gewohnt, nach dem Laden einer Webseite diese “bequem” mit der Leertaste so lange nach unten zu blättern, wie sie mich interessiert, das geht so nicht, ich muss ständig zur Maus greifen und diese hin- und herfahren.

Manchmal ist außer der horizontalen Scrollbar zusätzlich eine vertikale vorhanden, ich kann dann den Quellcode auch nach unten nicht vollständig überblicken.

Der Code wird rechts abgeschnitten, falls dem Ersteller des Cascading Stylesheets (CSS) Ästhetik wichtiger ist als der Inhalt (overflow: hidden;). Das ist noch weniger akzeptabel wie die Scrollbars.

Ich will nicht gezwungen sein, Text zu markieren, in die Zwischenablage zu kopieren, einen Texteditor zu öffnen und den Code aus der Zwischenablage in den Texteditor einzufügen: So kann ich durch overflow: hidden versteckten Text hervorholen oder den Inhalt von “Unterfenstern” in eine größere Darstellungsfläche kopieren.

Folgende für mich praktikable Lösungen verhindern das:

• Der Code steht nicht in <pre>-Blöcken, Zeilenumbrüche werden mit <br /> erzielt, Einrückungen mit   (im normalen Textfluss würden andernfalls mehrere aufeinanderfolgende Leerzeichen auf eines reduziert)
• Das Seitenlayout hat nur zwei Spalten: Eine für die “Navigation” und eine für den Text. Die Textspalte ist rechts und versteckt nicht überlaufenden Text. Der Code steht in <pre>-Blöcken.

Letzere Lösung – 2 Spalten, überlaufender Text wird nicht versteckt, Code in <pre>-Blöcken – halte ich für die bessere: Bei der ersten Lösung werden Zeilen dort umgebrochen, wo der Programmierer Quelltext nicht umbräche, da er unübersichtlich würde. Die “Navigationsspalte” muss dazu links sein, andernfalls könnte der Quelltext in “Navigationstext” ragen, dann wären beide Texte schwierig zu entziffern.

Aus diesem Grund habe ich die “Navigationsspalte” nach links verschoben (es war nur eine float-Anweisung im CSS zu ändern von left auf right).

]]> http://www.elmar-baumann.de/blog/2011/09/20/quellcode-auf-webseiten/feed/ 0 http://www.elmar-baumann.de/blog/2011/07/25/modulare-java-programmierung-via-services/ http://www.elmar-baumann.de/blog/2011/07/25/modulare-java-programmierung-via-services/#comments Mon, 25 Jul 2011 17:15:54 +0000 Elmar http://www.elmar-baumann.de/blog/?p=1031 Eine umfangreichere Anwendung ist unübersichtlich, schwierig zu “pflegen” und erweitern, falls ich sie in einem einzigen JAR unterbringe. Teile ich sie auf in mehrere Projekte und jedes Projekt ergibt ein JAR, ist dies besser. Die Abhängigkeiten der Projekte untereinander sollten minimal sein (eine Klasse des Projekts X sollte nicht nach einer Klasse des Projekts Y verlangen).

Bevor ich eine größere Anwendung programmiere, sollte ich mich einarbeiten in ein Framework, das zu diesem Zweck entwickelt wurde, beispielsweise der NetBeans Platform und dieses benutzen. Die Einarbeitung kostet Zeit, die Benutzung spart diese jedoch auf lange Sicht und schont die Nerven.

Falls ich mich nicht einarbeiten will, ist der ServiceLoader nach meinen aktuellen Kenntnissen am geeignetsten, dieser lässt sich auch in einem Framework benutzen.

Dazu definiere ich in einem oder mehreren Projekten Interfaces (Services). Diese implementiere ich in anderen Projekten.

Beispielsweise könnte ich entscheiden, das Programmfenster hat drei Bereiche, in die andere Module (Projekte) “Fenster” einfügen können. Die Interface-Definition sähe z.B. so aus:

public interface WindowSystem {
    void dockIntoSelectView(Component component);
    void dockIntoEditView(Component component);
    void dockIntoPropertiesView(Component component);
}

In irgend einem Projekt implementiere ich dies und publiziere diese Implementierung gemäß der JavaDoc des ServiceLoader im META-INF/services-Verzeichnis:

public final class ApplicationFrame implements WindowSystem {

    @Override
    public void dockIntoSelectView(Component component) {
        tabbedSelectViewPane.add(component);
    }

    @Override
    public void dockIntoEditView(Component component) {
        tabbedPaneEditView.add(component);
    }

    @Override
    public void dockIntoPropertiesView(Component component) {
        tabbedPanePropertiesView.add(component);
    }
}

Will ich in einem anderen Projekt der Select-View des Anwendungsfensters etwas hinzufügen, benutze ich den ServiceLoader. Ich vereinfache mir die Arbeit mit der Klasse ServiceLookup eines Projekts, das alle anderen Projekte nutzen dürfen und das keine Abhängigkeit zu einem anderen Projekt hat, siehe Implementierung weiter unten:

public final class ImageFileBrowser implements Module {

    private JTree fileSystemTree;

    @Override
    public void initModule() {
        java.awt.EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                createFileSystemTree();
                addFileSystemTree();
            }
        );
    }

    private void createFileSystemTree() {
        FileFilter directoryFilter = FileSystemUtil.getDirectoriesOnlyFileFilter();
        TreeModel fileSystemTreeModel = FileSystemUtil.createFileSystemTreeModel(directoryFilter);

        fileSystemTree = new JTree(fileSystemTreeModel);
        fileSystemTree.setCellRenderer(new FileSystemTreeCellRenderer());
        fileSystemTree.addTreeSelectionListener(new ImageDisplayTreeSelectionListener());
    }

    private void addFileSystemTree() {
        WindowSystem windowSystem = ServiceLookup.lookup(WindowSystem.class);

        windowSystem.dockIntoSelectView(fileSystemTree);
    }
}

Klasse ServiceLookup eines “Utility”-Projekts, das keine Abhängigkeiten zu anderen Projekten hat und das alle anderen Projekte benutzen dürfen:

public final class ServiceLookup {

    public static <T> T lookup(Class<T> serviceClass) {
        if (serviceClass == null) {
            throw new NullPointerException("serviceClass == null");
        }

        ServiceLoader<T> serviceLoader = ServiceLoader.load(serviceClass);
        Iterator<T> serviceImplementations = serviceLoader.iterator();

        return serviceImplementations.hasNext()
                ? serviceImplementations.next()
                : null;
    }

    public static <T> Collection<? extends T> lookupAll(Class<T> serviceClass) {
        if (serviceClass == null) {
            throw new NullPointerException("serviceClass == null");
        }

        Collection<T> serviceImplementations = new ArrayList<T>();
        ServiceLoader<T> serviceLoader = ServiceLoader.load(serviceClass);

        for (T service : serviceLoader) {
            serviceImplementations.add(service);
        }

        return serviceImplementations;
    }

    private ServiceLookup() {}
}

Prinzip einer modularen Anwendung mit Hilfe des ServiceLoader:

• Die Anwendung besteht aus unterschiedlichen Projekten, jedes hat eine bestimmte Aufgabe (“Zuständigkeit”)
• Einige Projekte deklarieren verschiedene Services als Interface
• Andere Projekte implementieren diese Services und veröffentlichen die Implementierungen im META-INF/services-Verzeichnis
• Projekte benutzen die Services und fügen so der Anwendung weitere Fähigkeiten hinzu
• Ein “Sammelprojekt” enthält die JARs aller Teilprojekte und den “Startcode”, der eine von allen Teilprojekten zu implementierende “init”-Methode aufruft (im Beispiel oben die Methode initModule() des Services Module, “Abholen” der Implementierungen mit ServiceLookup.lookupAll())

Will ich die Anwendung erweitern, eröffne ich ein neues Projekt, benutze die Services und füge das Projekt-JAR dem Sammelprojekt hinzu. Ich brauche nicht die bisherigen Projekte anzupassen.

Das Beispiel oben könnte ich erweitern: Ein neues Projekt implementiert analog zu ImageFileBrowser über die Module-Schnittstelle beispielsweise eine Klasse Mp3FileBrowser, ein weiteres VideoFileBrowser. Diese Projekte müssen nichts voneinander wissen ebensowenig wie das Fenstersystem wissen muss, welche Fenster mit welcher Funktion ihm hinzugefügt werden.

]]> http://www.elmar-baumann.de/blog/2011/07/25/modulare-java-programmierung-via-services/feed/ 0 http://www.elmar-baumann.de/blog/2011/04/29/argernisse-mit-windows-installationsprogrammen/ http://www.elmar-baumann.de/blog/2011/04/29/argernisse-mit-windows-installationsprogrammen/#comments Fri, 29 Apr 2011 21:23:43 +0000 Elmar http://www.elmar-baumann.de/blog/?p=995 Start einer Liste. Im Idealfall ärgert ein Installationsprogramm nicht, in schlimmen Fällen treffen mehre Punkte zu. Unter “obligatorisch” verstehe ich, das Installationsprogramm führt etwas aus, ohne nachzufragen oder zu informieren.

• Installation zusätzlicher Programme, beispielsweise einer weiteren Anwendung oder einer Web-Browser-Toolbar, obwohl dies verneint wurde oder obligatorisch (obligatorisch: Oft ist das der Fall bei einer “Standardinstallation”)
• Obligatorisches Hinzufügen von Verknüpfungen in den System Tray
• Obligatorisches Hinzufügen von Verknüpfungen in die Schnellstartleiste
• Obligatorisches Hinzufügen von Verknüpfungen auf den Desktop
• Bei älteren System als Vista: Keine Nachfrage, wo im Programme-Ordner des Startmenüs die Verknüpfungen platziert werden sollen, statt dessen obligatorisches Einfügen eines Programme-Ordners oder einer Verknüpfung in den Wurzelordner, sodass der Programme-Ordner des Startmenüs ohne “eigene Pflege” bald so viele Einträge enthält, dass das Finden eines Programms etliche Zeit beansprucht, da dort keine Suche existiert
• Obligatorisches Hinzufügen zu einer der etwa 50 Autostart-Varianten
• Obligatorisches Hinzufügen eines Dienstes, der automatisch gestartet wird und der dauerhaft Arbeitsspeicher und Rechenleistung verbraucht
• Obligatorisches “in Besitz nehmen” von Dateitypen und im Programm kann dies nicht deaktiviert werden
• Unsinnige Benennung der in Besitz genommenen Dateitypen, beispielsweise heißen alle Bildtypen “Xyz-Programm-Datei”; im Explorer kann dann nicht mehr so nach Dateityp sortiert werden, dass JPEG-Dateien getrennt sind von TIFF-Dateien
• Bei jeder Installation wird ein neuer Autoplay-Handler eingerichtet und bisherige Autoplay-Handler, die nicht mehr funktionieren, werden nicht gelöscht; wird ein Speichermedium eingelegt, ist der Autoplay-Dialog gefüllt mit fehlerhaften Vorschlägen
• Obligatorisches extensives Auffüllen des Explorer-”Neu”-Kontextmenüs, werden diese Einträge mühevoll via Regedit entfernt, sind sie nach Start des Programms wieder da und im Programm kann dieses Verhalten nicht abgestellt werden
• Eine automatische Aktualisierung wird als Dienst installiert, der nicht über die erforderlichen Rechte verfügt und fortan bei jedem Windows-Login Fehlermeldungen anzeigt (“Sie verfügen nicht über die benötigten Rechte …”, keine Schaltfläche, die funktioniert wie “runas /user:Administrator”)
• Nicht funktionierendes Deinstallationsprogramm
• Deinstallation hinterlässt viel “Müll” wie nicht funktionierende Autoplay-Handler oder Dienste-Starts
• Deinstallation löscht nicht die (große) MSI-Datei mit den Installationsdateien
]]> http://www.elmar-baumann.de/blog/2011/04/29/argernisse-mit-windows-installationsprogrammen/feed/ 0