Dieser Beitrag stellt dar, welche Auswirkungen Quantencomputer auf kryptographische Verfahren haben könnten. Dazu werden die Grundlagen und der aktuelle Stand symmetrischer und asymmetrischer Verschlüsselungsmethoden grundlegend erläutert. Ziel ist es, wichtige Begriffe möglichst verständlich zu erläutern und die unterschiedlichen kryptographischen Verfahren in ihrem Zweck einzuordnen. Abschließend werden die besonderen Herausforderungen durch Quantencomputer aufgezeigt sowie Lösungsansätze durch Post-Quanten-Kryptographie vorgestellt.

Der Text soll, der Hoffnung des Autors nach, auch ohne umfassende Vorkenntnisse gut verständlich sein. Der Autor empfiehlt ferner, sich den Text möglichst entspannt an einem sonnigen Sonntagnachmittag auf Terrasse, Balkon oder im Lieblingssessel mit einem Glas Tee durchzulesen.

Einleitung

Allzu oft werden Artikel zu den Auswirkungen von Quantencomputern auf die Informationssicherheit übertrieben apokalyptisch dargestellt. Beispiele hierfür sind ein Beitrag auf Telepolis mit der Äußerung „Dazu wird wohl auch die Fähigkeit zählen, die aktuell verwendete Kryptografie und Verschlüsselung schneller zu knacken, als man sich das derzeit vorstellen kann“ oder der ZDNET-Beitrag, der mit Sätzen wie „Damit wäre alles von Staatsgeheimnissen bis hin zu Bankkontodaten in Gefahr“ ein vergleichbar dystopisches Zukunftsbild zeichnet.

Es ist Zeit, der Sache mal auf den Grund zu gehen – auf Basis der aktuellen Erkenntnisse. Natürlich kann niemand sagen, welche Entdeckungen morgen oder übermorgen noch das Licht der Welt erblicken. Einige Aussagen sind deshalb noch unter Vorbehalt, andere können heute schon sehr verlässlich getroffen werden. Los geht's.

Die Grundwerte der Informationssicherheit sind Vertraulichkeit, Integrität und Verfügbarkeit, die häufig durch weitere Anforderungen wie Authentizität und Verbindlichkeit ergänzt werden. Auf technischer Ebene werden diese Forderungen in weiten Teilen durch kryptografische Primitive erfüllt. Insbesondere die Vertraulichkeit kann über sogenannte symmetrische Chiffren erreicht werden. Das sind Verfahren, bei denen der selbe Schlüssel zur Ver- und Entschlüsselung verwendet wird.

Symmetrische Chiffren

Nahezu jeder kennt dabei klassische Chiffren wie die Cäsar-Chiffre oder Vigenère-Chiffre. Aber natürlich ist auch die Enigma-Verschlüsselung eine symmetrische Chiffre, so wie der Data Encryption Standard (DES) und der heutige Platzhirsch: der Advanced Encryption Standard (AES).

Wer sich das aktuelle TLS 1.3 genauer anschaut, wird herausfinden, dass ausschließlich AES und ChaCha20 als symmetrische Chiffren zur Auswahl stehen. Tools wie VeraCrypt bieten neben AES hingegen noch vier weitere Verfahren an, die voraussichtlich aber nur Lesern mit Vorwissen bekannt sein dürften: Twofish, Serpent, Kuznyechik und Camellia.

Wenn wir die fünf zuletzt genannten betrachten, haben diese alle gemeinsam, dass sie eine (maximale) Schlüssellänge von 256 Bit aufweisen. Wenn wir also etwas verschlüsseln wollen, brauchen wir als Schlüssel eine Folge von 256 Einsen und Nullen, welche das Schlüsselmaterial bildet. Zur Entschlüsselung müssen diese 256 Bits exakt identisch zum Verschlüsselungsvorgang sein. Ist nur ein Bit verkehrt, wird der ursprüngliche Klartext nicht wiedererkennbar sein. Nur mit der richtigen Kombination bekommen wir den ursprünglichen Inhalt wieder entschlüsselt. Es ist nun einmal wie ein Schlüssel: Ein bisschen richtig genügt eben nicht.

Die letzten 50 Jahre Informatikgeschichte lassen stets den Eindruck entstehen, dass alle Probleme einfach nur eine Frage der Zeit sind. Ein bisschen auf die nächste Prozessorgeneration warten, hier noch schauen, was Nvidia auf den Markt bringt. Früher oder später haben wir doch sicher genug Leistung, um alle 256 Bit, also 32 Bytes, durchzuprobieren.

Wer jedoch denkt, dass das vollständige Durchrechnen eines Verfahrens mit 256-Bit-Schlüssellänge in naher Zukunft Realität sein wird, unterschätzt dieses Problem gewaltig. Der Mensch ist sehr schlecht darin, exponentielles Wachstum zu verstehen. Zwar haben die drei Pandemiejahre dabei geholfen, den Begriff bekannter zu machen, dennoch unterschätzen bisweilen auch viele Informatiker weiterhin die Bedeutung.

Angenommen, uns würde das Kunststück gelingen, ein Entschlüsselungsergebnis auf nur einem einzelnen Atom zu speichern. Dann wäre es so, dass auf unserer Erde nicht genug Atome zur Verfügung stehen, um das Ergebnis jedes möglichen AES-Schlüssels zu speichern. Auch nicht in unserem Sonnensystem. Nicht einmal die ca. 200–400 Mrd. Sterne unserer Milchstraße stellen genug Atome zur Verfügung.

Dazu kommt, dass 256 Bit einfach eine willkürliche Grenze darstellen. Den Aufwand, eine gute Verschlüsselung zu konstruieren, sollte man nicht unterschätzen. Aber es hält uns wirklich nichts davon ab, eine 512-Bit-Verschlüsselung zu konstruieren. Hier könnte nun der Einwand sein, dass sich das Verfahren dadurch verlangsamen würde. Dies ist aber deutlich weniger merklich, als man meinen könnte.

Zur Frage, wie leicht sich die symmetrischen Verfahren skalieren lassen, ein kurzer Exkurs: Der AES ist in Runden aufgebaut und unterstützt 128 Bit, 192 Bit und 256 Bit Schlüssellängen. Die kleinste Variante mit 128 Bit wird in 10 Runden durchgeführt, die 192 Bit in 12 Runden und 256 Bit in 14 Runden. Damit ist die 256-Bit-Variante nur ca. 30–40 % langsamer als die 128-Bit-Variante. Ein normaler Rechner schafft recht problemlos 8–10 Gigabyte pro Sekunde AES-Verschlüsselung (256 Bit). Selbst wenn der Rechner in einer theoretischen 512-Bit-Variante nur 4–5 Gigabyte pro Sekunde verschlüsseln könnte, wäre dies verkraftbar.

Ganz ohne Neuentwicklung könnten wir auch die Schlüssellänge des AES durch Mehrfachanwendung steigern. Ein gutes Beispiel hierfür hat es in der Geschichte der Kryptologie schon gegeben: der 3-DES. Aufgrund der Tatsache, dass der Data Encryption Standard nur 56 Bit (effektive) Schlüssellänge hatte, wurde dieser durch eine dreifache Anwendung zum 3-DES weiterentwickelt. Durch die dreifache Anwendung verdoppelte sich die Schlüssellänge auf ca. 112 Bit. Auch wenn der 3-DES heute nicht mehr empfohlen wird, könnte eine solche Vorgehensweise dennoch als Vorbild dienen, sofern keine generellen Schwachstellen im AES bekannt werden.

Es ist also leicht einzusehen, dass uns eine Skalierung hier keine Probleme bereitet. Dennoch wird davon ausgegangen, dass 256 Bit auch in der Welt der Quantencomputer noch ausreichend sicher sind. Das liegt auch in der groben Schätzung begründet, dass die Anzahl der 256-Bit-AES-Schlüssel die Anzahl der Photonen in der Milchstraße übersteigt. Auf die Gefahr durch Quantencomputer möchte ich jedoch erst am Ende näher eingehen, vorweg kann allerdings bereits festgehalten werden, dass moderne symmetrische Chiffren als nicht gefährdet gelten.

Nach diesem Ausritt in die symmetrischen Chiffren können wir uns erst mal ein zweites Glas Tee gönnen und im Anschluss die Welt der asymmetrischen Kryptologie betreten. Fertig? Dann geht es jetzt weiter.

Asymmetrische Verfahren

Ein wesentliches Merkmal asymmetrischer Verfahren ist, dass zwei Schlüssel existieren: ein öffentlicher und ein privater. Der öffentliche darf, dem Namen nach, jedem bekannt sein. Der private Schlüssel muss geheim bleiben. Wer die Welt der asymmetrischen Verfahren betritt, kann diese grob in drei Bereiche unterteilen: Ver- und Entschlüsselung, Signaturerstellung und Schlüsselaustausch. Wir schauen uns zunächst mal den Bereich Ver- und Entschlüsselung an.

Wer in der Schule, Berufsschule oder im Studium asymmetrische Chiffren kennenlernt, wird häufig zunächst mit dem RSA-Algorithmus konfrontiert. Das RSA-Verfahren besteht zunächst aus der Idee, sich zwei Primzahlen auszudenken, die, miteinander multipliziert, nur noch mit hohem Aufwand getrennt, also faktorisiert werden können. Mit einer Zahl aus zwei großen Primfaktoren lässt sich aber noch nichts verschlüsseln. Wir brauchen ein Zahlenpaar, welches in einem speziellen Verhältnis zueinandersteht. Das ist ganz vereinfacht so ähnlich wie mit der 5 und der 0,2. Wenn ich eine Zahl mit 5 multipliziere, z. B. die 3, erhalte ich die 15: Wir haben damit den Klartext 3 erfolgreich verschlüsselt und die 15 als Chiffretext erhalten. Wenn ich anschließend die 15 mit 0,2 multipliziere, erhalte ich die Klartextnachricht 3 zurück. Wenn wir nun die 5 als öffentlichen Schlüssel und die 0,2 als privaten Schlüssel betrachten, haben wir eine vereinfachte Vorstellung davon, wie zwei verschiedene Zahlen für den Ver- und Entschlüsselungsvorgang genutzt werden können. Das ist bei RSA ähnlich, nur dass nicht multipliziert, sondern exponenziert wird. Also wird zur Verschlüsselung eine Zahl mit dem öffentlichen Schlüsselexponenten exponenziert und mit dem privaten Schlüsselexponenten für die Entschlüsselung exponenziert. So existiert ein öffentlicher Exponent zur Verschlüsselung und ein privater Exponent zur Entschlüsselung.

Wenn die zwei Primfaktoren bekannt sind, können wir ein solches Zahlenpaar bestimmen, welches in Bezug auf das oben erwähnte Primzahlprodukt in diesem inversen Verhältnis zueinandersteht. Kann ein böser Mensch die Faktorisierung mit geringem Aufwand durchführen, ist dieser natürlich ebenfalls in der Lage, zum öffentlichen Schlüssel den zugehörigen privaten Schlüssel zu ermitteln. Aus diesem Grund spricht man häufig davon, dass RSA auf dem Faktorisierungsproblem beruht. Das ist akademisch betrachtet jedoch nur halb korrekt. Die Ermittlung des privaten Schlüssels in Unkenntnis der Primfaktoren beruht auf dem Problem der Faktorisierung, soweit richtig. Allerdings ist die Verschlüsselung eine (modulare) Exponentiation, weshalb die Entschlüsselung auch auf dem Problem der sogenannten diskreten Wurzel beruht. Wird für eines dieser Probleme eine einfache Lösung gefunden, ist das Verfahren gebrochen.

Diese Idee entstand Ende der 70er-Jahre, und seitdem hat sich natürlich viel verändert, weshalb die Ver- und Entschlüsselung mit RSA heute nur noch geringe Relevanz besitzt. In TLS 1.3 wird RSA zur Datenverschlüsselung gar nicht mehr unterstützt und war bereits in TLS 1.2 seit langem nicht mehr empfohlen. Dies hängt mit der sogenannten vorwärtsgerichteten Sicherheit (Forward Secrecy) zusammen: Wird nämlich der private Schlüssel zu einem späteren Zeitpunkt bekannt, könnten auch ältere verschlüsselte Daten entschlüsselt werden. Spätestens seit den Snowden-Enthüllungen 2013 versucht man genau dies möglichst zu verhindern.

Es gibt andere Verfahren zur asymmetrischen Ver- und Entschlüsselung wie ElGamal und Rabin. Diese sind jedoch ähnlich alt und haben praktisch noch weniger Relevanz als RSA. Der Grund dafür ist, dass wir das nicht wirklich brauchen. Denn egal, welches asymmetrische Verfahren wir wählen: Es wird entsetzlich viel langsamer sein als eine symmetrische Chiffre. Daher ist vielen bereits bekannt, dass die Absicherung der Kommunikation häufig hybrid funktioniert. Das bedeutet, dass wir ein asymmetrisches Verfahren nehmen, um die 128–256 Bit auszutauschen, die wir im Anschluss als AES-Schlüssel verwenden können. Wir wollen, dass auf den zwei Seiten der Kommunikation der gleiche Schlüssel vorliegt. Was wir also eigentlich brauchen, ist ein Schlüsselaustausch.

Schlüsselaustausch

Wer bereits Vorkenntnisse hat, wird bei Schlüsselaustausch unmittelbar an Diffie-Hellman denken. Allerdings ist vielen nicht bekannt, dass das klassische Diffie-Hellman-Verfahren noch (etwas) älter als RSA ist. Auch hier können wir leicht wieder eine Vereinfachung vornehmen. Angenommen, wir haben zwei Kommunikationsparteien A und B, und jede denkt sich eine Zahl aus. Sagen wir, A denkt sich die 5 aus und B die 7. Dann brauchen wir noch eine gemeinsame öffentliche Zahl, die nicht geheim ist, nehmen wir die 3. Wenn A nun 5*3 und B 7*3 rechnet, kommen hier jeweils die 15 und die 21 heraus. Nun werden die Ergebnisse ausgetauscht: A übermittelt die 15 an B und B die 21 an A. Jede Seite multipliziert nun das übermittelte Ergebnis mit ihrer eigenen geheimen Zahl. So nimmt A die 21 von B und multipliziert sie mit 5: 5*21=105. B multipliziert die 15 von A mit 7: 15*7=105. Auf beiden Seiten liegt nun die 105 vor. Ausgetauscht wurde die Zahl 3 und die Ergebnisse 15 und 21. Die 105 selbst wurde nicht übertragen, liegt aber nun auf beiden Seiten vor.

Ein Schlüsselaustauschverfahren ermöglicht, dass auf nahezu magische Weise bei den Kommunikationspartnern ein Schlüssel entsteht, ohne dass dieser explizit übermittelt wird. Wir können nun die Zahl 105 als AES-Schlüssel verwenden, um die auszutauschenden Inhalte symmetrisch zu verschlüsseln.

Grundsätzlich funktioniert Diffie-Hellman ähnlich. Aber während in diesem einfachen Beispiel multipliziert wurde, wird im klassischen Diffie-Hellman exponenziert. Ein Angreifer könnte mit einer Division das Verfahren brechen: dies gelingt es bei Diffie-Hellman nur mit dem sogenannten diskreten Logarithmus. Lässt sich der diskrete Logarithmus effizient berechnen, kann der geheime Exponent aus den übermittelten Nachrichten bestimmt werden.

Heute wird Diffie-Hellman regelmäßig kaum noch mit Primzahlen durchgeführt. Das liegt daran, dass die Zahlen, um die Sicherheit zu gewährleisten, immer größer gewählt werden müssen. Heute würde ein solches privates Geheimnis wie die 5 und die 7 im Bereich einer 4000-Bit-Zahl liegen. Das ist zwar für den Rechner noch zu bewältigen, benötigt jedoch insbesondere auf mobilen Geräten viel Zeit.

Elliptische-Kurven-Kryptographie

Die oben genannten Verfahren kommen mit den uns bekannten Operationen aus der Schule wie Addition, Multiplikation und Exponentiation aus. Es hat sich jedoch gezeigt, dass sich mit diesen Operationen die asymmetrischen Verfahren nur noch schwer „steigern“ lassen. „Steigern“ bedeutet in diesem Kontext, den Abstand zwischen dem Aufwand zur (legitimen) Berechnung und dem Aufwand für einen erfolgreichen Angriff zu vergrößern. In der Vergangenheit mussten wir die Größe der Zahlen stark steigern, damit der praktische Angriff weiterhin ausgeschlossen bleibt.

Um dieses Problem zu adressieren, hat man sich überlegt, wie man ggf. neue Operationen entwickeln lassen könnte, die diesen Abstand vergrößern. Den Abstand, dass die legitime Berechnung leicht ist, die erforderlichen Aufwände für einen erfolgreichen Angriff jedoch weiterhin groß bleiben. Die Antwort darauf sind elliptische Kurven. Eine elliptische Kurve ähnelt den Polynomen aus dem Mathematikunterricht, erfüllt jedoch zusätzliche Bedingungen, die ihr besondere Eigenschaften verleihen. Es ist möglich, Operationen auf Punkte der Kurve durchzuführen, welche als Ergebnis wiederum ebenfalls auf der Kurve liegen.

Wenn wir uns noch mal das Diffie-Hellman-Beispiel anschauen, dann hatten wir eine öffentliche Zahl 3 sowie die geheimen Zahlen 5 und 7. Bei Diffie-Hellman auf elliptischen Kurven ersetzen wir die 3 durch einen Punkt in einem Koordinatensystem. Statt der öffentlichen 3 haben wir zum Beispiel den Punkt (3 | 2), wobei 3 die X- und 2 die Y-Komponente darstellt. Beide Seiten multiplizieren jetzt diesen öffentlichen Punkt mit ihrer geheimen Zahl. Bei der Addition von Punkten, die wir aus dem Matheunterricht kennen, würden wir nun die 3 und die 2 jeweils mit 5 und mit 7 multiplizieren und die 5*(3 | 2) = (15 | 10) und 7*(3 | 2) = (21 | 14) erhalten. Wenn nun jede Seite der anderen Seite dieses Ergebnis übermittelt, also A erhält (21 | 14) und B erhält (15 | 10), muss jeder seinen privaten Schlüssel anwenden, um die Ergebnisse 5*(21 | 14) = (105 | 70) und 7*(15 | 10) = (105 | 70) zu erhalten. Auf beiden Seiten wurde der gleiche Punkt bestimmt.

Diffie-Hellman auf elliptischen Kurven funktioniert exakt auf die gleiche Weise, nur dass die Multiplikation einer Zahl mit einem Punkt anders definiert ist. Wird ein entsprechend ausgewählter Punkt auf einer elliptischen Kurve mit einer Zahl multipliziert, erhalten wir einen anderen Punkt, der ebenfalls auf der Kurve liegt. Übermittelt nun jede Seite dieses Ergebnis der Gegenseite, entsteht nach erneuter Anwendung des privaten Schlüssels auf beiden Kommunikationsseiten der gleiche Punkt. Wir nehmen anschließend wahlweise die X- oder Y-Komponente als gemeinsames Geheimnis.

Findige Leser werden einwenden, dass es mit der bekannten (3 | 2) und dem Ergebnis (15 | 10) nicht sonderlich schwierig ist, die 5 als Geheimnis zu ermitteln. Über eine Division der Komponenten der Punkte lässt sich das private Geheimnis ermitteln. Bei elliptischen Kurven ist die Operation so definiert, dass diese Rückrechnung durch den diskreten Logarithmus möglich wäre. Ist dieses Problem mit geringem Aufwand lösbar, ist das Verfahren nachhaltig gebrochen. Hier unterscheiden sich die zwei Diffie-Hellman-Varianten nicht: in beiden Fällen basiert die Sicherheit auf der Schwierigkeit des diskreten Logarithmus. Allerdings kann bei elliptischen Kurven eine äquivalente Sicherheit durch deutlich kleinere private Geheimnisse realisiert werden (ca. 256 Bit anstelle 4096 Bit).

Nahezu bei jeder TLS-Verbindung im Netz wird ein solcher Schlüsselaustausch über elliptische Kurven durchgeführt. Jedoch, egal welche Schlüsselaustauschvariante wir wählen, bleibt dennoch das Problem, dass wir uns nicht sicher sein können, ob wir uns mit dem „richtigen“ Kommunikationspartner austauschen. Nur weil wir Zahlen hin und her schicken, können wir uns nicht sicher sein, ob diese Zahlen auch von der Person kommen, die wir annehmen. Wir lösen mit einem Schlüsselaustausch das Vertraulichkeitsproblem, lassen hierbei jedoch die Authentizität auf der Strecke. Daher kommen wir nun zum dritten und letzten großen Feld: die Signaturen.

Digitale Signaturen

Zur Erstellung von Signaturen findet RSA, so wie oben erläutert, weiterhin breite Anwendung. Dies hat sich auch mit TLS 1.3 nicht geändert. Neben der Signaturerstellung mit RSA kommt auch der sogenannte Digital Signature Algorithm (DSA) zum Einsatz. Dieser kann ebenfalls auf elliptischen Kurven basieren. Ein prominentes Beispiel für den Einsatz von DSA auf elliptischen Kurven sind die Signaturen auf der Bitcoin-Blockchain.

Ziel einer digitalen Signatur ist es, Integrität und Authentizität zu sichern. Integrität bedeutet, dass der Inhalt unverändert ist bzw. unrechtmäßige Änderungen entdeckt werden können. Authentizität ist die Sicherstellung und Überprüfung der Identität. Also, dass der Kommunikationspartner tatsächlich die Person ist, für die er oder sie sich ausgibt.

So wie zur Ver- und Entschlüsselung mit RSA ist es auch bei Signaturverfahren so, dass ein öffentlicher und ein privater Schlüssel existiert. Mit dem privaten Schlüssel können Unterschriften erzeugt werden, die mittels öffentlichem Schlüssel verifiziert werden können. Wenn wir jedoch über den gleichen unsicheren Kanal den öffentlichen Schlüssel übermitteln, könnte man sich nicht sicher sein, ob dieser nicht von einem Angreifer ausgetauscht wurde.

Diese Vertrauenslücke wird durch ein Zertifikat überbrückt. Ein Zertifikat ist eine Zuordnung einer Identität, z. B. durch einen Namen, mit einem öffentlichen Schlüssel und wird von einer vertrauenswürdigen Instanz bescheinigt. Zu den im Zertifikat beurkundeten öffentlichen Schlüsseln gehört somit der private Schlüssel. Beweist jemand, dass er oder sie über den privaten Schlüssel verfügt, indem beispielsweise eine Signatur erzeugt wird, beweist diese Person, über den zum öffentlichen Schlüssel im Zertifikat zugehörigen geheimen Schlüssel zu verfügen. Auf diese Weise wird die Identität nachgewiesen, die im Zertifikat bescheinigt wurde.

Und nun mal alles zusammen. Bauen wir im Browser eine TLS-Verbindung auf, wird uns ein Zertifikat übermittelt, welches wir anhand bereits bekannter Zertifikate überprüfen können. Ferner beweist die Gegenseite durch eine Signatur, in Kenntnis des privaten Schlüssels zu sein. Auf diese Weise können wir überprüfen, auch nur mit der Gegenseite zu sprechen, die im Zertifikat genannt ist. Außerdem wird mittels Diffie-Hellman ein Schlüsselaustausch durchgeführt, um auf beiden Seiten einen symmetrischen Schlüssel zu erzeugen. Anschließend kann dieser Schlüssel zur Verschlüsselung der Inhalte verwendet werden. Somit haben wir Vertraulichkeit, Integrität und Authentizität auf Basis einer TLS-Verbindung sichergestellt.

Gefahr durch Quantencomputer

Quantencomputer nutzen die Prinzipien der Superposition und Verschränkung, um innerhalb eines einzigen Rechenablaufs eine extrem große Anzahl möglicher Zustände zu erzeugen. Vielen Informatikern kommt hierbei möglicherweise eine nichtdeterministische Turingmaschine in den Kopf. Diese Vorstellung entspricht jedoch nicht ganz der Realität. Anders als bei klassischer Parallelverarbeitung ist es nicht einfach ein gleichzeitiges Ausführen aller Rechenwege. Vielmehr ermöglicht die Quantenmechanik, dass durch gezielte Quantengatter bestimmte Resultate verstärkt und andere ausgelöscht werden.

Vielleicht hilft an dieser Stelle ein Gedankenbild, um die Besonderheit der Arbeit mit Quantencomputern zu verdeutlichen: Wenn man einen Stein in einen stillen See wirft, entsteht eine einzelne Welle, die sich gleichmäßig ausbreitet. An einem beliebigen Punkt im Wasser kann man das Auf und Ab dieser Welle gut vorhersagen – es verhält sich, wie man es erwarten würde. Mit Quantencomputern zu arbeiten ist hingegen, als würde man viele Steine gleichzeitig an verschiedenen Stellen ins Wasser werfen. Die Wellen überlagern sich, verstärken oder löschen sich gegenseitig aus. Beobachtet man nun einen zufälligen Punkt auf dem See, erscheint das Verhalten chaotisch und kaum vorhersehbar. Doch wenn man das Muster der Störungen versteht und die Steine gezielt wirft – also das Problem clever formuliert – kann man sich diese Überlagerung zunutze machen. Gerade in dieser Gleichzeitigkeit liegt das große Potenzial von Quantencomputern.

Das bedeutet, dass nicht für jedes Problem ein effizienter Quantenalgorithmus existiert. Es gibt Probleme, bei denen Quantencomputer keinen oder nur einen geringen Mehrwert liefern. Bei anderen Problemen ist die Überlegenheit hingegen bereits nachgewiesen.

Gegenwärtig sind Quantenprozessoren noch sehr fehleranfällig, weshalb sich ein Großteil der Forschung auf verbesserte Hardwaresysteme und ausgefeilte Fehlerkorrekturverfahren konzentriert. Aber ungeachtet dessen entwickelt man bereits heute Algorithmen und Gatterdesigns, um gewappnet zu sein, sobald ausgereiftere Quantenchips zur Verfügung stehen.

In Bezug auf die Kryptologie sind hier zwei solcher Verfahren bekannt: der Grover- und der Shor-Algorithmus. Der Grover-Algorithmus dient der Suche in einer unsortierten Datenbank. Abstrakt betrachtet ist es der Algorithmus, der zur Berechnung symmetrischer Verfahren verwendet werden könnte. Die schlechte Nachricht dabei ist, dass der Grover-Algorithmus den Aufwand einer vollständigen Schlüsselsuche, also das Durchprobieren aller möglichen 256-Bit-AES-Schlüssel, auf die Wurzel dieses Schlüsselraums reduziert. Das bedeutet, dass wir mit einem 256-Bit-AES nur noch den Aufwand einer 128-Bit-Verschlüsselung hätten – dies aber unter der Berücksichtigung, dass wir einen funktionierenden, fehlerfreien Quantencomputer mit mehreren tausend Qubits hätten. Vereinfacht halbiert sich der Aufwand um die Hälfte der Bitlänge.

Die gute Nachricht ist: 128 Bit ist immer noch eine unglaublich große Anzahl an Schlüsseln. Auch mit diesem Werkzeug wären wir weit davon entfernt, vom Quantencomputer bedroht zu sein. Ebenfalls eine gute Nachricht: Die Wurzel stellt eine asymptotisch untere Schranke dar. Das bedeutet, dass der Grover-Algorithmus auch physikalisch nicht besser sein kann.

Das bedeutet nicht, dass ein Quantencomputer nicht für ein spezielles symmetrisches Verfahren gefährlich werden könnte, weil ein besserer Quantenalgorithmus entdeckt wird. Es bedeutet nur, dass nicht generell jedes symmetrische Verfahren in der Gefahr steht, gebrochen zu werden. Insbesondere aufgrund der Tatsache, dass die Stärke der Verschlüsselung leicht hochskaliert werden kann.

Zusammengefasst sind unsere Passworttresore und unsere Festplattenverschlüsselung nicht in unmittelbarer Gefahr. Sicherlich ist es sinnvoll, hier wachsam zu bleiben, allerdings können wir erstmal entspannt bleiben.

Etwas weniger entspannt sieht es bei den asymmetrischen Verfahren aus. Wer den Text genau gelesen hat, konnte zwei Probleme identifizieren, auf denen die asymmetrischen Verfahren beruhen: die Faktorisierung bei RSA und das Problem des diskreten Logarithmus bei Diffie-Hellman und bei den Verfahren auf Basis elliptischer Kurven. Der Quantencomputer ist aufgrund des Shor-Algorithmus eine Gefahr für die Sicherheit dieser Verfahren. Dieser macht sich einen mathematischen Trick zunutze. Wenn man eine beliebige Zahl nimmt und nacheinander mit den Zahlen 1, 2, 3 etc. exponenziert und modulo dem Primfaktorprodukt in RSA rechnet, wiederholt sich diese Sequenz nach einer gewissen (vorher unbekannten) Anzahl. Diese Wiederholung ist ein Muster, welches durch eine sogenannte Quanten-Fouriertransformation erkannt werden kann. Aus dieser Wiederholungsfrequenz lässt sich im Anschluss mindestens einer der Primfaktoren ermitteln.

Auf unseren normalen Rechnern wäre diese Suche ein Algorithmus mit exponentieller Laufzeit und deshalb praktisch nicht durchführbar. Auf einem Quantencomputer wird aus dem Problem ein polynomialzeitiger Algorithmus und wäre somit nicht länger sicher. Auch für das Problem des diskreten Logarithmus bietet der Shor-Algorithmus eine zu effiziente Lösung, sodass Verschlüsselungsverfahren nicht länger auf diesem Problem basieren dürften.

Damit haben die Berichte in gewisser Weise einen validen Punkt, dass wir ohne asymmetrische Verfahren keinen sicheren Schlüsselaustausch mehr hätten und auch die Korrektheit einer digitalen Signatur in Frage gestellt werden müsste. Aber es gibt Hoffnung.

Post-Quanten-Kryptographie

Schon 1978 wurde das McEliece-Kryptosystem veröffentlicht, von dem auch heute noch ausgegangen wird, dass es Sicherheit gegenüber Quantencomputern bietet. Allerdings werden hier Schlüsselgrößen im höheren Kilobyte- bis sogar Megabyte-Bereich erzeugt. Insbesondere in den 70er-, 80er- und 90er-Jahren wäre dies nicht realistisch gewesen. Seit Ende der 90er ist auch mit NTRU ein asymmetrisches Verfahren bekannt, bei dem von einer Resistenz gegenüber Quantencomputern ausgegangen wird.

Im Jahr 2017 startete das NIST eine offizielle Suche nach einem neuen QC-resistenten asymmetrischen Verfahren und, wie wir heute wissen, sollte es 7 Jahre dauern, bis diese Suche abgeschlossen ist.

Die Suche endete im August 2024 mit einem Verfahren für einen Schlüsselaustausch und drei Verfahren zur Erzeugung digitaler Signaturen. So wurde u. a. ML-KEM (vormals Kyber genannt) für den Schlüsselaustausch und ML-DSA (vormals Dilithium genannt) zur Erstellung von Signaturen standardisiert. Beide Verfahren basieren auf dem sogenannten Modul-Learning-with-Errors-Problem, daher stammt auch das ML im Namen. [Kleiner Funfact: Kyber sind die Kristalle in den Lichtschwertern der Jedi und aus Dilithium-Kristallen erhalten Raumschiffe wie die Enterprise ihre Energie.]

Bei ML-KEM steht das KEM für Key-Encapsulation Mechanism, was bedeutet, dass auf Basis des öffentlichen Schlüssels ein Geheimnis „verpackt“ wird, das auf der Empfängerseite mit Kenntnis des privaten Schlüssels entpackt werden kann. Bei ML-KEM kann lediglich eine 256-Bit große Nachricht chiffriert werden. Eben genau so viel, dass es für einen AES-Schlüssel genügt. Findige Leser werden einwenden, dass dies eigentlich dem Forward Secrecy Gedanken widerspricht. Aber die Parameter können für jeden Verbindungsvorgang neu gewählt/gewürfelt werden, weshalb sich die Sache hier anders verhält, als ein Schlüsselaustausch mit RSA.

Das Problem, auf dem das ML-KEM Verfahren basiert, ist eines aus der linearen Algebra und chiffriert eine Nachricht auf Basis von Matrizenmultiplikation, bei der ein zusätzlicher Fehlervektor integriert wird – was man als „Rauschen“ bezeichnen könnte. Es verrauscht die Nachricht in dem Umfang, dass es ein großes Hindernis für den Angreifer darstellt. Das Rauschen lässt sich auch mit Kenntnis des privaten Schlüssels nicht vollständig entfernen, allerdings ist die Auswirkung des Rauschens für den Entschlüsselungsvorgang so gering, dass es die Dechiffrierung und Wiederherstellung der Nachricht nicht verhindert.

ML-KEM steht in drei Varianten zur Verfügung: ML-KEM-512, ML-KEM-768 und ML-KEM-1024. Im Wesentlichen ändert sich lediglich die Größe der Matrizen und Vektoren. Die 1024-Variante wird auch als „paranoid“ bezeichnet, und so dachten sich die Entwickler des Signal-Messengers (vermutlich): Das ist der Weg. Daher ist hier bereits ML-KEM-1024 integriert. Dieser wird mit einem „klassischen“ Schlüsselaustausch auf elliptischen Kurven kombiniert, sodass beide Verfahren gebrochen werden müssten, um an den gemeinsamen Schlüssel zu gelangen.

Zurück zum Thema. Es gibt berechtigte Zweifel bezüglich der PQ-Verfahren. Das liegt daran, dass viele Kandidaten, die vormals von Experten als sicher eingestuft wurden, von anderen Experten regelrecht zerstört wurden. Daher gibt es eine gewisse Unruhe darüber, ob diese selektierten Verfahren nicht ebenfalls Schwächen enthalten, die einfach nur noch unentdeckt sind. Möglich ist das natürlich. Daher ist es immer gut, ein Verfahren in Reserve zu haben. Im März 2025 erweiterte das NIST die vier Verfahren um ein weiteres mit dem Namen HQC, welches als Backup für das Schlüsselaustauschproblem dienen soll. Strukturell ist HQC näher an McEliece als an Kyber, beruht somit auf einer anderen Klasse von Problemen weshalb davon ausgegangen wird, dass nicht zeitgleich beide Verfahren gefährdet sind.

Fazit

Quantencomputer könnten sich tatsächlich als großer Wurf auf der einen Seite und realistisches Problem für die derzeitigen klassischen asymmetrischen Verfahren auf der anderen Seite erweisen. Wie in den referenzierten Artikeln in der Einleitung basieren Einschätzungen zur „Kryptoapokalypse“ durch Quantencomputer häufig noch auf dem Wissen von vor 10 Jahren. Heute stehen wir dieser Zukunft nicht mehr ganz ungerüstet gegenüber.

Achso: Falls jemand die kryptografisch sicheren Hashverfahren vermisst haben sollte, dem sei gesagt, dass ich diese nicht vergessen habe. Auch für Hashfunktionen gelten ähnliche Bedingungen und Herausforderungen wie für symmetrischen Verschlüsselungsverfahren. Hier ist jedoch zu berücksichtigen, dass im SHA-2 und SHA-3 bereits jeweils eine 512-Bit-Variante existiert. Hier haben wir also keine Probleme. Aus diesem Grund können Quantencomputer in Bezug auf Hashfunktionen weitgehend ignoriert werden.

Ich bedanke mich bei allen Lesern, die es bis hierher durchgehalten haben, und verabschiede mich mit einem hierzu passenden Zitat von Goethe: „Durch Stolpern kommt man bisweilen weiter, man muss nur nicht fallen und liegen bleiben.“

Hinweis: Artikelbild ML generiert, der Text aber nicht  

Neue (alte) Hardware
Während and dem Barebone Gehäuse für den PI gebastelt wurde ist ein gebrauchter Supermicro Server eingezogen. Darauf liefen - oder auch nicht - zunächst einige Hypervisor (ESXi, HyperV, Proxmox). Die ursprüngliche Ausstattung war dann auch bald zu wenig und es gab einige Upgrades:

• 2x L5640 (6 Kern "Low-Power")
• 6x 16GB DDR3-1066 ECC REG

Anfang des Jahres hat sich dann das alte "Datengrab" - eine externe 4TB Platte - verabschiedet. Dies rückte das NAS Projekt mal wieder in den Fokus. Für einen niedrigen 4-stelligen Betrag wurden dann einige Festplatten besorgt.
Geplant war dann eigentlich den RAID-Controller an eine VM im Proxmox durchzureichen und dort Truenas zu installieren. Truenas beziehungsweise ZFS allgemein benötigt direkten Zugriff auf die Datenträger ohne einen RAID-Controller. HBA sind hier das Mittel zum Zweck, einige RAID-Controller kann in den IT-Mode umflashen. Leider mag der Controller weder den IT-Mode noch war das Passthrough wirklich erfolgreich.
Allerdings bietet Truenas Scale auch eine auf KVM basierte Virtualisierung und k8s basierte Container-Apps. Also weg mit Proxmox und Truenas direkt installiert, Glücklicherweise bot das Supermicro-Board genug SATA Ports um auf den Controller verzichten zu können. Beachten muss man hierbei, daß der Datenträger auf dem Truenas installiert wird nicht weiter zur Verfügung steht. Eine Installation auf einem USB-Stick ist nicht empfehlenswert, man benötigt also am besten eine kleine SSD zur Installation.

Nach der Installation und Ersteinrichtung des ZPools wird man von einem fröhlichen Dashboard begrüßt.

Für den Heimgebrauch kann man durchaus auf L2-ARC und slog-Device verzichten. Die Anforderungen für einen brauchbaren slog übersteigen die Fähigkeiten normaler SSDs ohnehin. Wenn man also nicht grad ein paar Enterprise-SSDs rumliegen hat, lässt man das besser. Der L2-ARC hilft nur wenn der ARC voll läuft oder zu klein für das Working-Set ist. Einen L2-ARC kann man einfach nachrüsten falls er wieder erwarten doch notwendig wird. Wobei selbst dann mehr RAM für einen größeren ARC sinnvoller ist.

Was nun?
Einerseits hat das NAS nun mehr Leistung als mit dem NanoPi möglich gewesen wäre, dafür steht kein Proxmox Server mehr zur Verfügung. Wie schon gesagt bietet Truenas Scale eine rudimentäre Schnittstelle zu KVM Virtualisierung und App-Container über k8s, in Freenas und Truenas Core wird/wurde das über die FreeBSD eigenen Jails gelöst.
Der Truenas eigene App-Pool wächst immer weiter und bietet neben üblichen wie NextCloud und PLEX auch beispielsweise miniIO. Man kann aber auch eigene Container importieren oder den sehr umfangreichen Truecharts Katalog nutzen.

Für das Heimnetz stellt Truenas nun einige Dienste bereit

Über einen externen Proxy und VPN werden einige der Dienste auch nach außen freigegeben, so kann man beispielsweise den codeserver von jedem beliebigen Browser nutzen.

Neue (neue) Hardware
Leider war diese Hardwarekonfiguration tatsächlich sehr weit von stromsparend entfernt. Ohne Last verbrauchte das System zwischen 150 und 170 Watt. Spitzenverbrauch lag bei 230 Watt. Da das System dauerhaft laufen soll war das schlicht zu viel. Tatsächlich hat das System meinen Stromverbrauch in etwas über 6 Monaten mehr als verdoppelt.
Neue Hardware ist deutlich energieeffizienter, also mal schauen was es so gibt. Leider ist die alte Hardware so alt, daß nichts davon in einem neuen System nutzbar wäre. Die Alder-Lake Plattform war zum Zeitpunkt des Wechsels sehr verlockend. 
Die Wahl fiel letztlich auf:

• 64 GB DDR4 RAM in 2 Modulen
• Core i5-12500T
• B660 Mikro-ATX Board 

Nach einiger Wartezeit und etwas RAM aus einem alten Desktop sieht das dann so aus.

Der Stromverbrauch des neuen Systems liegt nun bei 75-80 Watt und 120 Watt unter last. Nicht perfekt aber besser. Beim aktuellen Stromverbrauch muss man auch bedenken, daß Truenas die Festplatten nicht schlafen legt und diese damit mindestens 20 Watt bei Zugriffen eher 40 Watt verbrauchen.
 

Die meisten erinnern sich sicher nicht mehr an mich, ich habe hier vor vier Jahren mal eine Vorstellung verfasst. Seitdem ist viel passiert bei mir, und ich würde gerne meinen Werdegang mit euch teilen. Kurze Zusammenfassung der ersten Vorstellung: Ich bin Lukas, mittlerweile 25, ausgebildeter Fachinformatiker für Systemintegration und arbeite als Softwareentwickler.

Der Titel klingt sehr reißerisch, ist aber akurat. Meine Intention mit diesem Artikel ist, die letzten Jahre etwas zu reflektieren. Zum anderen möchte ich Menschen Mut machen, die sich vielleicht in einer ähnlichen Situation befinden wie ich mich befunden hbae.

Ich werde euch jetzt nicht mit unnötigem Geschwafel langweilen und gleichzeitig auch  nicht zu viel über mich persönlich verraten, deswegen wird das Resumé der letzten Jahre recht kurz: Ich habe nach dem Bestehen meiner Ausbildung aus gesundheitlichen Gründen in drei verschiedenen Firmen für jeweils nicht länger als fünf Monate gearbeitet. Das hat große Lücken in meinen Lebenslauf gerissen, von viel Praxiserfahrung keine Spur. Jedes neue Bewerbungssgespräch mit mehr Erklärungsbedarf.

Zitat

"Systemadministration ist nichts für mich."

 

Nachdem ich den letzten Job verloren hatte, habe ich mir gesagt, dass es so nicht weitergehen kann. Ich habe mir die Zeit genommen die ich brauche um fit zu werden und außerdem einen Entschluss gefasst. Systemadministration ist nichts für mich. Der größte Spaß für mich war schon immer das Erstellen von Skripten mit Powershell, weswegen ich mir dachte: hey, warum nicht programmieren lernen. Gesagt, getan. Ich habe eine 16-monatige Weiterbildung zum C++ Programmierer bei einer Fernakademie absolviert. Das Ganze schien aber definitiv auf Vollzeit-Berufstätige ausgelegt gewesen zu sein, ich hatte den Kurs bereits nach zwei Monaten abgeschlossen.

Und was jetzt? Ich habe eine Einführung in die Sprache und objektorientierte Programmierung bekommen, kleinere Dinge programmiert und Konzepte gelernt. Stellt mich jetzt jemand ein? Für mich war klar, so vermutlich noch nicht. Nachdem ich also einige Erfahrungsberichte gelesen habe, habe ich beschlossen mein neugewonnenes Wissen in die Tat umzusetzen und ein Projekt zu starten. Dazu möchte ich noch sagen, dass ich in dieser Zeit natürlich arbeitslos gemeldet war. Das Arbeitsamt habe ich stets über meine Pläne und Vorhaben informiert, weswegen mir sämtliche Freiheiten gelassen wurden. Ich musste keine Bewerbungen schreiben und konnte mich vollends auf meine "Umschulung" fokussieren.

Für mein Projekt habe ich einige Rahmenbedingungen aufgestellt:

1. Es soll eine Konsolenanwendung ohne Fremdbibliothken sein, um mein Wissen um C++ und die STL (Standard Template Library) zu vertiefen und vorzuzeigen.
2. Es muss komplex genug sein, damit ich heraussteche, aber so simpel, dass es in einem angemessenen Zeitrahmen fertigzustellen ist.

Ich habe mich für eins meiner Lieblingskartenspiele entschieden, Phase 10. Für Spiele habe ich mich eh immer begeistert und ich dachte mir, dass es sicher eine Herausforderung darstellt, die Algorithmen für die Phasenüberprüfung zu entwerfen. Ungefähr drei Monate später habe ich dieses Projekt erfolgreich abschließen können. Der Code war natürlich alles andere als professionell, und wenn ich da jetzt mit meiner bald einjährigen Erfahrung draufschaue, belächle ich das ein wenig. Aber das ist okay, zu dem Zeitpunkt war es viel wichtiger etwas Fertiges, Präsentierfähiges zu haben. Zu zeigen, dass ich ein Projekt anfangen und fertigstellen kann, und dass es funktioniert.

Zitat

"offen und ehrlich"

 

Mit dem Selbstbewusstsein, das ich durch das Projekt gewonnen habe, habe ich direkt angefangen deutschlandweit Bewerbungen zu schreiben, ich wollte unbedingt anfangen professionell zu entwickeln. Die ganz große Frage war natürlich, reicht ein GitHub-Link zu meinem Projekt um den extrem lückenbehafteten Lebenslauf zu kaschieren? Ich dachte mir, ich habe sowieso nichts zu verlieren, also werde ich offen und ehrlich sein. Ich habe im Anschreiben direkt den "Elefanten im Raum" angesprochen, meine krankheitsbedingten Ausfälle.

Nach fünf Bewerbungen auf Junior-C++-Entwicklerstellen hatte ich vier Bewerbungsgespräche und einen neuen Job. In jedem dieser Gespräche habe ich sämtliche Fragen zu meinen Lücken ehrlich beantwortet, was jedes Mal sehr positiv aufgenommen wurde.

Inzwischen arbeite ich seit fast einem Jahr als C++-Entwickler in einem StartUp. Meine Arbeitskollegen sind ausschließlich Akademiker, was für mich als Mathe- und Informatiknoob eine noch viel größere Herausforderung war. Zu meinem Glück wurde im Bewerbungsgespräch mein Wille zu Lernen erkannt. Das möchte ich auch noch einmal betonen. Ich hatte sehr viel Glück. Klar, ich habe eine Weiterbildung absolviert und ein Projekt entwickelt, aber manchmal hilft es definitiv zur richtigen Zeit am richtigen Ort zu sein.

Seit Mitte letzten Jahres bin ich also wieder in Vollzeit angestellt, war keinen Tag krank und gehe jeden Tag mit extrem viel Motivation zur Arbeit. Es macht einfach Spaß. Um mein Wissen noch weiter zu vertiefen werde ich außerdem ab kommendem Semester an der Fernuniversität Hagen Informatik studieren.

Abschließend möchte ich auf die Zukunft in diesem Blog eingehen. In unregelmäßigen Abständen werde ich fachliche Artikel zur Softwareentwicklung mit C++ erstellen. Ich freue mich sehr darauf, mein neues Wissen weiterzugeben und den angehenden (C++)-Entwicklern im Forum weiterzuhelfen. Außerdem wird es möglicherweise Erfahrungsberichte aus dem Fernstudium geben, seid gespannt!

LG

Lukas aka BLAAAAAAAAAAAAAAAAAARGH

Der Plan mal wieder ein NAS zu bauen schwirrt schon seit längerem durch meinen Kopf. Alles auf dem PC zu lagern um das Dokument dann doch vom Laptop aus zu bearbeiten oder den Film dann über die PS4 zu sehen ergibt halt auch nur begrenzt Sinn. Also dann dochmal den alten Shuttle-Barebone aus der Schrott-Ecke auf Arbeit mit nach hause genommen, ne alte Grafikkarte und etwas RAM aus der Wühlkiste genommen und zusammengebaut. Positiv: Das Gerät schaltet ein und läuft offenbar auch. Negativ: Es produziert kein Bild, zumindest nicht an meinem Monitor. Was an allem Möglichen liegen könnte. Die Grafikkarte könnte selbst kaputt sein, der DVI auf DP Adapter funktioniert nicht in der benötigten Richtung. Einen anderen Monitor oder eine weitere Grafikkarte zum testen ist aber nicht vorhanden. Ende der Geschichte, bauen wir also kein NAS.

Planänderung

Doch. Sonst wäre das hier ja albern. Ne Grafikkarte kaufen um festzustellen das es was anderes ist, wäre auch quatsch. Aber vor einigen Wochen durch Zufall gesehen das jemand ein NAS aus nem RaspberryPi 4 gebaut hat. Die Idee an sich ist ja nix spektakulär Neues. Neu für mich war der 4xSATA-Hat. 

Es gibt sogar ein Bündel aus SATA-Hat und einem Gehäuse, in dem neben Raspi und Hat auch noch 4 2,5 Zoll SATA-Platten Platz finden. Da ich aber nur einige 3,5 Zoll HDDs übrig habe, war das Gehäuse keine Option. Im weiteren Verlauf der Suche bin ich dann auf den NanoPi M4 gestoßen, bzw. zuerst auf den SATA-Hat für diesen.

Der NanoPi wird von einem RK3399 angetrieben, daher kann das Board sogar PCIe. Während der Raspi-Hat 2 USB Kanäle nutzt, nutzt der NanoPi-Hat also PCIe. Außerdem ist der RK3399 doch schneller als der RaspberryPi 4. Dafür ist der NanoPi M4v2 auch etwas teurer. Mit Kühlkörper, SATA-Hat und eMMC Karte kostet der Spaß etwa 120 € inkl. Versand. Da kommt dann wohl auch noch etwa 25 € Einfuhrumsatzsteuer drauf. Für nur 20 € mehr hätte man das auch gleich bei Antratek bestellen können. Aber den Shop hab ich erst später gefunden. Das gesamte Konstrukt könnte dann so aussehen.

Der SATA-Hat versorgt auch gleich den NanoPi mit Strom. Mit dem Molex-Anschluss auf dem Hat kann man auch die Festplatten mit Strom versorgen. Um 4 Festplatten zu betreiben sollte man den Hat aber mit ATX-Netzteil betreiben, dazu kann man den 4-poligen Anschluss auf dem Board nutzen.

Ein passendes Gehäuse

Nach einigen verworfenen Ideen - selbst defekte QNAPs gehen auf ebay für jenseits der 150 € Marke weg - werde ich das alte Barbone von Shuttle ein wenig umbauen. Dazu habe ich zunächst einen Festplattenkäfig für 5 3,5 Zoll Platten bestellt. Da ich das Original-Netzteil aus dem Barbone weiter nutzen werde, kann ich nur 4 Platten einbauen, aber mehr wollte ich sowieso nicht. Außerdem möchte ich versuchen den CPU-Kühler des Gehäuses zu nutzen. Damit ist allerdings die oben gezeigte Konfiguration unmöglich, da die CPU des NanoPi auf der Unterseite verbaut ist. Ich muss also den NanoPi umdrehen und den SATA-Hat dann also irgendwie neben dem NanoPi einbauen. Dafür benötigt man aber nur ein paar Kabel und anderen Kleinkram. 

Und zu guter Letzt möchte man das Gerät auch einschalten können. Da ich ein ATX-Netzteil benutze, könnte man einfach am Mainboard-Stecker - der ja nicht genutzt wird - Pin 16 und 18 Überbrücken. Da das Netzteil dann daerhaft läuft, ist das nicht die beste Lösung. Es gibt sogar schon fertige Schalter für diesen Einsatzzweck. Die schönste Variante die ich gefunden habe. 

Wartezeit verkürzen

Da einige Teile eine Lieferzeit von 2-4 Wochen haben. Kann ich mich in der Zwischenzeit ein wenig um die Software und den Umbau des Barebone-Gehäuses kümmern. Zum Umbau wird es in einem nächsten Teil ein paar Bilder geben, aber viel zu sagen gibt es da nicht. Die Software könnte aber noch spannend werden. Es gibt zwar diverse fertige Images für den NanoPi, aber die mag ich nicht. Es gibt allerdings auch ein paar Images aus dem Arch Linux ARM-Projekt für den RK3399. Der erste Schritt wäre nun diese erstmal unter QEMU zu testen und Software nachzuinstallieren bzw runter zu werfen. Der NanoPi hat zwar auch einen SD-Slot von dem er booten kann, das Ziel ist aber die eMMC Karte für das Betriebssystem zu nutzen. Dazu bietet FriendlyArm zwar ein Tool an das ein Linux-Image von der SD-Karte auf die eMMC schreibt. Allerdings muss man dafür sein eigenes Linux in ein Image mit diesem Tool verpacken. Die Anleitung für interessierte gibt es hier: http://wiki.friendlyarm.com/wiki/index.php/EFlasher#Make_Your_Own_eFlasher

In den letzten Monaten wurden die meisten unserer Linuxserver auf Arch-Linux umgestellt. Ein paar Ausnahmen wird es weiterhin geben. vCenter läuft beispielsweise auf der VMWare eigenen Linux-Distribution, andere Software bringt in Form einer virtuellen Appliance auch eigene Linux-Distributionen oder verlangt nach einer spezifischen Distribution mit speziellen Paketen.

Jedenfalls sind 11 Server auf Arch-Linux Basis im Einsatz. Eine Update-Runde dauert bei unserer Internetanbindung dann eine Weile. Das Ziel war nun die Angelegenheit zu Beschleunigen. Dafür gibt es prinzipiell mehrere Möglichkeiten.

1. Einen eigenen Arch Mirror aufbauen
2. ein zentraler Cache für Pakete
3. ein verteilter Cache für Pakete

Beim eigenen Mirror hat man dann einen Server auf dem alle Arch-Pakete liegen. Für den zentralen Cache lädt ein Server zunächst das Paket um es dann zunächst über das Netzwerk im Cache abzulegen und von dort aus zu installieren. Dafür werden Pakete die alle Server benötigen im verteilten Cache auf jedem Server abgelegt.

Pacman Cache

Für den zentralen Cache müssten alle Server über NFS o.ä. auf den Server mit dem Cache zugreifen. Vom Aufwand abgesehen, bastelt man sich so natürlich einen Single-Point-of-Failure. Für den verteilten Cache benötigt man nur einen simplen Webserver und ein paar Zeilen Shell-Befehle.

Für diesen Zweck genügt darkhttpd vollkommen. Hat man den installiert "konfiguriert" man ihn einfach indem die Systemd Unit angepasst wird. Dann benötigt man noch ein paar Links im Paket-Cache und ist im Grunde fertig.

pacman -S darkhttpd
systemctl enable darkhttpd
nano /etc/systemd/system/multi-user.target.wants/darkhttpd.service
systemctl daemon-reload
ln -s /var/lib/pacman/sync/*.db /var/cache/pacman/pkg
systemctl restart darkhttpd

Die Unit sieht dann in etwa so aus.

[Unit]
Description=Darkhttpd Webserver
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/darkhttpd /var/cache/pacman/pkg --port 9090 --uid http --gid http --mimetypes /etc/conf.d/mimetypes
ProtectSystem=full
ProtectHome=on
PrivateDevices=on
NoNewPrivileges=on

[Install]
WantedBy=multi-user.target

Der Pacman-Cache in /var/cache/pacman/pkg wird hier zum WWW-Root. Als Port wurde 9090 gewählt, da auf keinem der Server etwas auf dem Port läuft. Welchen Port man letztlich wählt ist egal. Die Standardoptionen "chroot" und "no-listing" werden entfernt. Mit chroot funktionieren Symlinks nicht und Verzeichnislisting ist fürs Debuggen ganz sinnvoll.

Updates

Damit die Server nun ihre Pakete von dem vorbereiteten Server erhalten, muss der auf jedem weiteren Server in die Mirrorliste eingetragen werden. Da die Mirrorliste zeilenweise verarbeitet wird, müssen die neuen Einträge an den Anfang der Datei.

Server = http://enton.<domäne>.intern:9090

Der Port :9090 ist natürlich durch den vorher gewählten Port vorgegeben.

Danach funktionieren Updates wie gewohnt mit pacman -Syu. 

Mehr

Da die Server verschiedene Aufgaben haben, sind auch unterschiedliche Pakete installiert, einige haben docker, andere php oder mariadb oder eine bunte Mischung. Nachdem der Cache eines Servers nun für alle verfügbar ist, bekommen wir aber zumindest Standardpakete (Kernel, ..) für alle weiteren Server nun aber aus dem lokalen Netz. Der Vorgang lässt sich nun für weitere Server wiederholen. Die Mirrorliste wird einfach nur länger.

Wenn alle Server ihren Cache freigeben und in jeder Mirrorliste alle Server eingetragen sind, ist dann auch egal, welcher Server mit Updates beginnt. Die nächsten Server sollten mit ihren Updates allerdings auf vorherige Server warten, da sonst die Pakete noch nicht auf den lokalen Servern verfügbar sind und wieder aus dem Netz geladen werden.

Als Fallback für neue Pakete oder Pakete die kein anderer Server hat, sollten in der Mirrorliste nicht nur die eigenen Server eingetragen sein. Ein praktisches Tool um die Liste aktuell zu halten ist reflector. Ich habe auf einem der Webserver eine Liste aller lokalen Paketcaches. Aus der Liste und reflector kann man sich vor den Updates dann eine frische Mirrorliste basteln.

curl --silent http://kangama.<domäne>.local:9090/liste |grep -v `hostname` && reflector -f 5 -l 5 -c de > /etc/pacman.d/mirrorlist

Kleinkram

Zunächst werden ein paar nützliche Helfer installiert.

• dhcpd - ist einfacher als immer nach der korrekten Konfiguration zu fragen
• zsh - coole Shell ist cool, dazu ein anders Mal mehr
• ntpd - um an der Uhr drehen zu lassen
• acpid - Laptop zuklappen -> Laptop schläft ein. Prima (ab und an gibt es Probleme beim aufwachen)
• htop - welcher Prozess braucht hier eigentlich soviel CPU/RAM?

Da man ja nicht als root arbeiten soll - an einigen Stellen wird das auch aktiv verhindert - wird noch ein neuer Benutzer angelegt. Der kommt in die Gruppen audio, video und wheel. Damit er hören und sehen kann. Der wheel Gruppe wird noch sudo erlaubt. Das ist am Laptop zwar egal da es eh nur den einen Nutzer geben wird und man es auch nur dem spezifischen Benutzer erlauben könnte, aber naja .. alte Gewohnheiten.

Ein Wellensittich

Hab ich das Arch-Wiki schon gelobt? Nicht nur das man zu allem eine Anleitung zur Installation und Konfiguration bekommt, es gibt sogar sinnvolle Übersichten zu verfügbaren Packeten nach Themengebieten. Wenn man also nicht weiß welche Desktopumgebung mit welchem Windowmanager man möchte kann man sich hier einen aussuchen.
Nun mag es etwas faul oder einfallslos wirken, aber der erste Eintrag in der Liste gefällt mir. Budgie .. es gibt eigentlich nicht viel zu sagen, man findet Dinge da wo man sie erwartet, oder im ersten Moment halt nicht, weil gnome-control-center und budgie-extras noch nicht installiert sind. Das Ding wirkt jedenfalls schön aufgeräumt. Doch damit man das selbst beurteilen kann müssen ein paar kleinere Pakete wie xorg, mesa, Grafiktreiber, ein Display Manager und Audiokram wie alsa und pulseaudio installiert werden.
Das funktioniert alles überaschend problemlos.

Die üblichen Verdächtigen

Mittlerweile ist es spät und so ein leerer Desktop ist nun auch recht langweilig. Also schnell noch Chromium, VLC und Nautilus installiert. Youtube läuft, Musik und Videos vom Windows-PC im Netzwerk kann man auch ansehen. Prima. Netflix .. ne geht nicht ...
War ja auch zu einfach. Netflix braucht eine Erweiterung für Chromium - chromium-widevine. Dies gibt es allerdings nur im AUR. 

YAY - AUR

Im Arch User Repository findet man letztlich alles das es nicht ins offizielle Repo geschafft hat. Das ganze funktioniert so ähnlich wie die FreeBSD Ports. Nur das die Pakete hier in einem GIT liegen. Zur Installation wird das entsprechende Paket vom Server geklont und mit makepkg "installiert". Auch für diese Aufgabe gibt es Helferlein. YAY zum Beispiel. Da auch das ein AUR-Paket ist, muss es natürlich zunächst auf dem beschriebenem Weg installiert werden. Danach kann man weitere Pakete aus dem AUR einfach mit

yay paketname

installieren. Makepkg ist dann übrigens so ein Programm das nicht als root ausgeführt werden möchte. Ich erwähne das, weil ich es regelmäßig vergesse und yay immer erstmal als root klone.

Ein Terminal für den Desktop

Derweil nervt es ungemein den Desktop jedesmal für ein paar Shell-Befehle zu verlassen. Dafür gab es doch auch ein paar Lösungen ..
Früher hab ich dafür eTerm benutzt - E16 fand ich ziemlich gut, die neue Version müsste ich irgendwann mal anschauen.
Aber gut, ohne enlightenment kein eTerm, was gabs noch? xterm! .. Ja nun .. ähm

pacman -R xterm

(u)rxvt ereilte das gleiche Schicksal. Warum? Die Schrift ist auf dem Display einfach irrsinnig winzig.
Gewonnen hat vorerst alacritty.

Temperaturprobleme

Nach einer Weile youtube schauen wundert man sich eventuell warum der Laptop ein Loch in den Tisch brennt. Er wird unfassbar heiß. Nach der Installation von sensors und xsensors hat man zumindest die Gewissheit, sich das Problem nicht einzubilden. htop ergänzt das Bild mit 60-90% CPU-Auslastung und einem load um 5 herum. Tendenz steigend.
Das war in dem Moment aber vermutlich eine Auswirkung des Powermanagments. Nach etwas Recherche und powertop ist einigermaßen klar was hier das Problem ist. Linux reduziert den CPU-Takt deutlich später als Windows, muss es aber irgendwann auf jeden Fall tun. Ab dem Moment steigt der load, da die CPU ja nun langsam ist. Durch hohen load wird die CPU wieder beschleunigt sowie es etwas Reserven gibt. Das Gerät pegelt sich dann langsam um die 80°C ein. Der Fairness halber muss hier aber erwähnt werden, das es unter Windows dann gern mal Probleme gab Videos flüssig darzustellen.

Bluetooth für Anfänger

Eigentlich wollte ich nur meine Kopfhörer mit dem Laptop koppeln. Das Bluetooth-Icon wird ja angezeigt und scheint auch eingeschaltet zu sein. Kopfhörer werden mal gefunden und können nicht koppeln, bleiben gleich unauffindbar oder können zwar koppeln aber dann nicht verbinden. Im Arch-Wiki findet man dann den Hinweis pulseaudio-bluetooth zu installieren falls das noch nicht passiert ist. Ne, das war es nicht ..
Nach einer Ewigkeit gefummel mit bluetoothctl auch keine neuen Erkenntnisse außer Fehlermeldungen der obskureren Art.

error updating services: Host is down (112)

Die führen dann aber tatsächlich ins Arch-Forum und zu dem Hinweis doch mal 

dmesg |grep bluetooth

nach sinnvollen Fehlermeldungen abzusuchen. Und tatsächlich konnte die Firmware nicht geladen werden.
Wie ich dann aus diesem Post lernte, gibt es von Lenovo zwar keine passende Firmware allerdings funktioniert die von Acer auch ganz prima.

 .. Firmware

Dies wird keine Anleitung für Linuxanfänger. Es wird keine Patentrezepte zum Lösen von Problemen geben. In so gut wie jedem beschriebenem Fall wird es alternative Lösungen geben. An einigen Stellen wird etwas Vorwissen vorausgesetzt.

Motivation

Als begeisterter Windowsnutzer seit ca 15 Jahren mit etwas Langeweile, habe ich beschlossen mal etwas verrücktes zu versuchen. Die winzige 256 GB SSD meines Yoga 3 Pro war mal wieder übervoll, also wurde endlich mal eine neue gekauft auf die das Windows umziehen sollte. Was lag also näher als der kleinen SSD auf ihre alten Tage noch etwas Spaß zu gönnen. Nebenbei könnte ich auf die Art die Linuxkentnisse etwas vertiefen und sehen wie viel Spaß Linux auf dem Desktop beziehungsweise Laptop macht. Zum Einen ist dies nicht der erste Ausflug in die Linuxwelt. Erste Versuche wurden zu Zeiten von Debian 2/3 unternommen. Anfangs noch mit SuSE und Red Hat um dann recht schnell bei Debian zu landen und einige Jahre dabei zu bleiben. Zum Anderen habe ich auch beruflich ein paar Linuxserver, mit unterschiedlichen Distributionen, zu verwalten.

Fragen vor dem Anfang

Die wichtigste oder unwichtigste Frage am Anfang ist welche Distribution es werden soll. Schaut man bei Distrowatch vorbei versinkt man schnell in einer Unmenge an Varianten. Unter Hauptdistributionen findet man eine Liste der populärsten Distributionen mit einer groben Unterteilung nach Komplexität. Da schon etwas Erfahrung mit Linux vorhanden ist und ich auch nichts komplett vorgekautes benutzen wollte, hab ich mich für Arch Linux entschieden. Einige Server auf Arbeit laufen auch schon damit. Es ist also kein vollkommenes Neuland.

Die Installation

Zur Installation gibt es nicht viel zu sagen. Es gibt im Arch-Wiki eine ausführliche Anleitung, der man problemlos folgen kann sofern man lesen und tippen kann. Ein kleiner Stolperstein liegt in der Partitionierung. Früher hab ich beispielsweise /usr auf eine eigene Partition ausgelagert. Unter Arch funktioniert das nicht, da /bin und /sbin nur Symlinks auf /usr/bin und /lib sowie /lib64 Links auf /usr/lib sind. Danach fangen dann die Probleme an.

Das erste mal booten

Was zuerst auffällt ist die winzige Schrift in der Konsole, immerhin hat das Yoga 3 Pro ein QHD+ Display bei gerade mal 13 Zoll Diagonale. Zum Glück hatten schon viele ähnliche Probleme und es gibt auch dazu einen Artikel im Arch Wiki.

Danach möchte man eventuell noch etwas mehr Software installieren. Das wird aber erstmal nichts. Aus Gründen wird der "falsche" Treiber für das WLan-Modul geladen. Der falsche Treiber landet also auf der Blacklist. Ohne WLan wird es allerdings schwierig den richtigen Treiber zu bekommen. Eine Lösung dafür ist einfach nochmal das Installationsmedium zu booten und in das installierte System zu "chrooten". Im Installationssystem ist auch der richtige Treiber verfügbar und kann in das Zielsystem installiert werden. Ist das alles geschafft, darf man dann noch etwas lernen. Es gibt noch "rfkill", mit dem man Bluetooth und WLan ein- beziehungsweise ausschalten kann/darf/muss. Nun kann man das WLan mit "wifi-menu" oder "wpa_supplicant" konfigurieren und weitere Software installieren.

da es unser erstes Thema in der Umschulung war, befassen wir uns heute, mit den Zahlensystemen, die in der IT Welt ihr Zuhause haben. 

Als kleine Themenzusammenstellung gehen wir heute auf das

• Duale Zahlensystem (Binär) 
• Hexa Dezimalsystem
• Oktadezimal System

Sowie auf die Umrechnung von

• Dezimal zu Binär und zurück 
• Dezimal zu Hex und zurück 
• Dezimal zu Okta und zurück 
• So wie Hex zu Okta und Binär und das auch wieder zurück ein

Du wirst danach, mit jedem Zahlensystem, mit einer Leichtigkeit rum hantieren können. Ich verrate dir, wie man mit einfachen Tricks, von einem zum anderen System umrechnen und welche Zahlen du dir in der IT Welt merken solltest, weil du ständig damit konfrontiert wirst.

Das Dezimal System ist das was uns von klein auf beigebracht wurde, von Null bis 9, da man die Zahlen beliebig aneinander stellen kann, sind der unendlichen Zahl keine Grenzen gesetzt. Es ist das 10er Zahlen System. Für den Menschen ist dieses System naheliegend (10 Finger, 10 Zehen). 

1. Es gibt 10 Ziffern von 0 bis 9
2. Der größte Wert der dargestellt wird ist die 9
3. Stellenwerte

• Der Wert der 1. Stelle beträgt 10⁰ = 1, es ist die "Einer" - Stelle
• Der Wert der 2. Stelle beträgt 10¹ = 10, es ist die "Zehner" - Stelle
• Der Wert der 3. Stelle beträgt 10² = 100, es ist die "Hunderter" - Stelle
• Der Wert der 4. Stelle beträgt 10³ = 1000, es ist die "Tausender" - Stelle
• usw. 

Dadurch ergibt sich die Interpretation der Zahl 123 in einem Beispiel so. 

123 = 3*10⁰ + 2*10¹ + 1*10²

Macht unterm Strich 

123 = 3 + 20 + 100

Kommen wir zum ersten uns fremden System, dem Dualen Zahlensystem. Dual weil es nur zwei Möglichkeiten der Darstellung gibt. Es ist das Zweier System. Die 1 und die 0. Deshalb wird es in der IT und Mathematik Binär (bi = zwei) genannt. Das Binäre System ist das wohl wichtigste Zahlen System in der Welt der Computer, da es die einzige Sprache ist die dein Prozessor versteht. Das ist die so genannte Maschinensprache.

Aber genug drum rum geredet, kommen wir zum ersten umrechnen. 

Für Zahlen des Binär Systems gilt 

1. Es gibt 2 Ziffern, die 0 und die 1
2. Der größte Wert den man darstellen kann ist die 1
3. Stellenwerte

• Der Wert der 1. Stelle beträgt 2⁰ = 1
• Der Wert der 2. Stelle beträgt 2¹ = 2
• Der Wert der 3. Stelle beträgt 2² = 4
• Der Wert der 4. Stelle beträgt 2³ = 8
• usw.

Üblich für die Kennzeichnung einer Zahl eines Systems, hinter der Zahl, eine kleine Zahl oder einen Buchstaben dran zu hängen 

• 2 oder b für das Binär System, zum Beispiel 101₂ oder 100_b
• 8 oder o für das Oktal System, zum Beispiel 45₈ oder 45_o
• 16 oder h für das Hexadezimal System, zum Beispiel 26₁₆ oder 26_h
• 10 oder d für das Dezimal System, zum Beispiel 99₁₀ oder 99_d

Interpretations Beispiel einer Binär Zahl 

1101₂ = 1*1 + 0*2 + 1*4 + 1*8

Macht unterm Strich 

1101₂ = 1 + 4 + 8

Das ergibt dann 13 in Dezimal oder 13₁₀

Das 16er System ist das Hexadezimal System. Da uns bis jetzt nur Ziffern zur Verfügung standen werden wir das nach dem Binären System das meist häufigste Zahlen System der IT Welt besprechen. Dazu kommen zu den normalen 10 Ziffern 0 bis 9 noch die Buchstaben a bis f hinzu. Früher wurden die Buchstaben groß geschrieben, was aber jetzt falsch ist. Deshalb zeige ich dir sofort die richtige Schreibweise also mit kleinen Buchstaben. 

Für das Hexadezimal System gilt folgendes

1. Es gibt 16 Ziffern, 0 bis 9 und a bis f (a=10, b=11, c=12, d=13, e=14, f=15)
2. Der größte Wert den man darstellen kann ist der Wert 15
3. Stellenwerte

• Der Wert der 1. Stelle beträgt 16⁰ = 1
• Der Wert der 2. Stelle beträgt 16¹ = 16
• Der Wert der 3. Stelle beträgt 16² = 256
• Der Wert der 4. Stelle beträgt 16³ = 4096
• usw.

Als kleines Beispiel rechnen wir

c2_h = 2*1 + 2*16

Macht unterm Strich 

2 + 192

Das ergibt einen Dezimal Wert von 194

Jetzt fragt sich bestimmt so ziemlich jeder, "wozu erfindet man sowas blödsinniges wie das Hexadezimal System?". Die Antwort ist ganz einfach. Der Einfachheit halber um die Zahlen kürzer darstellen zu können. Als Beispiel, was ist in der Darstellung kürzer? 

43727 Dezimal,

1010 1010 1100 1111 Binär oder

aa cf Hexadezimal? 

Natürlich das Hexa. Und da es größere Zahlen gibt wie 43727 denken wir mal an 10¹² als Beispiel (ergibt 1 000 000 000 000) und da jede Stelle an Ziffern quasi Ressourcen bedeutet. Man aber  Ressourcen und Zeit niemals genug hat, wurde ein System entwickelt, welches noch einfach zu rechnen und trotzdem kompakter darzustellen ist. 

Wer sich jetzt fragt warum dann das Binär? Nun es muss halt auch ein System geben welches von Maschinen gesprochen werden kann. Da man durch Strom einer Maschine sagen kann Strom an ist 1 und Strom aus ist 0, ist das die einfachste Lösung um mit wenig Aufwand komplexe Zahlen Rechnungen und Aufgaben einer Maschine bei zu bringen. 

Nun das letzte Zahlensystem, das Oktale Zahlensystem. Es ist das 8er Zahlensystem (Oktopus 8 Arme). Die Zahlen 0 bis 7 werden hierbei nur benutzt. Es ist in der IT Welt nicht so oft vertreten, kommt aber hin und wieder mal vor das man es kennen sollte.

Für das Oktalsystem gilt folgendes

1. Es gibt 8 Ziffern, 0 bis 7
2. Der größte Wert den man darstellen kann ist der Wert 7
3. Stellenwerte

• Der Wert der 1. Stelle beträgt 8⁰ = 1
• Der Wert der 2. Stelle beträgt 8¹ = 8
• Der Wert der 3. Stelle beträgt 8² = 64
• Der Wert der 4. Stelle beträgt 8³ = 512
• usw.

Als Beispiel berechnen wir

23_o = 3*1 + 2*8

macht unterm Strich

23 = 3 + 16

Ergibt 23_o = 19_d  

Jetzt haben wir ein Beispiel, an dem der Oktal Wert größer erscheint als der Dezimal Wert, aber das ist auch normal. Das Dezimal System rechnet mit 10 Ziffern, das Oktale nur mit 8. Da man nur im Dezimalsystem "dreiundzwanzig" ausspricht und im Oktalen "zwei drei" ist es extrem wichtig, die anderen Zahlensysteme niemals dezimal aussprechen. Sondern immer Ziffer für Ziffer benennen.

So nun können wir beginnen, die verschiedenen Zahlensysteme umzurechnen. Wir fangen mit vier Tabellen an, damit wir leichter umrechnen können, solltest du dir diese Werte unbedingt merken, das erleichtert ungemein die Umrechnung der Zahlensysteme.

Du musst dir nicht alles davon merken, aber so bis 4096 in jedem System, solltest du schon im Kopf haben. Diese Zahlen kommen immer wieder in der IT-Welt vor und wer es am Anfang schon kennt, hat später weniger Probleme sich die Zahlen zu merken. Als Beispiel 2¹⁰ ergibt 1024, 1 MiB (Mebibyte) hat 1024 KiB (Kibibyte). Du siehst also das sind ganz normale IT zahlen, die dir in deiner Laufbahn ständig über den Weg laufen werden.

Dann fangen wir mal an mit dem umrechnen.

Dezimal zu Binär

105_d wollen wir in Binär umwandeln, zunächst guckst du in die liste bei Binär wie oft die 105 in die 256 passt, 0 mal. Da die ersten nullen nicht aufgeschrieben werden, weil die Tabelle noch kilometerweit weiter nach Links geht, guckst du das du die nächstmögliche Zahl raussuchst, in dem Fall 105 wäre es die 64 (da es in 128 ja auch eine 0 ergeben würde). Du schreibst also die erste 1 und rechnest den Rest aus. 105 - 64 = 41, du schreibst am besten in eine Tabelle 1 Rest 41, dann rechnest du mit der 41 weiter, wie oft passt die 41 in die 32? genau auch ein mal, also schreibst du wieder eine und hast als Zwischenwert jetzt 11 und den Rest, das wäre bei 41 - 32 = 9. Wir merken uns 11 Rest 9. Da die 9 unsere Zahl ist mit der wir weiter rechnen guckst du wie oft die 9 in die 16 passt, 0 mal. Also schreibst du 110 Rest auf. Rest ist wieder 9 und du gehst zu der 8 hin, wie oft passt die 9 in die 8? genau 1 mal, 9 - 8 = 1. Jetzt schreiben wir wieder in der Tabelle weiter 1101 Rest 1. Das Spielchen geht jetzt so weiter, wie oft passt die 1 in die 4? 0 mal, also 11010 Rest 1, wie oft in die 2? 0 mal, also 110100 Rest 1, wie oft in die 1? ein mal also schreibst du 1101001 auf. Da die Tabelle zum ende angekommen ist, hast du deinen ersten Binären Wert schon mit einer Leichtigkeit herausbekommen, 105 in Binär ist 1101001.

War das jetzt schwer? Ich glaube kaum. Wenn du noch etwas üben möchtest dann such dir einfach mehr Zahlen aus und wenn ich sie überprüfen soll, schreib sie in die Kommentare. Als Alternative kannst du dir auch auf dem Smartphone einen IT Taschenrechner runterladen. Unter Android kann ich dir die App Six Teen Free empfehlen. Nein das ist keine Werbung, denn ich bekomme kein Geld von den Machern der App, leider … Auf jeden Fall hast du da die Möglichkeit Dezimal, Hex, Bin und Oktal werte einzugeben und er zeigt dir sofort die restlichen Werte an, am Anfang hab ich es mir schwer getan, weil ich nicht wusste, dass man auf den blauen Balken in jeder Zeile anklicken kann, in der man die Werte eingeben möchte. Nachdem man das weiß ist dieser Rechner einfach nur Super. Einfach, klein und ohne viel Schnickschnack.

Es wäre gut wenn du dann erst ein Paar Zahlen in Binär umrechnest, damit du dich mit der Tabelle vertraut machst und damit du das System beherrschst.

Binär zu Dezimal

Die Umrechnung ist genauso Simple. Wir rechnen mal die Zahl 1001 0011 in Dezimal um. Hier nimmst du am besten auch sofort die Tabelle zur Hand

machst dir unten noch zwei Zeilen hinzu damit du das hier hast

In die vierte Zeile kannst du dann deine Zwischenrechnung reinschreiben. Dann legen wir los...

Jetzt guckst du einfach wo überall die 1 ist, diese zahlen musst du einfach nur zusammen zählen, dann hast du die Dezimal Zahl raus. In unserem Fall ist das die

128+16+2+1=147

Somit ergibt der Binäre Wert 1001 0011 den Dezimalen Wert 147.
Wie immer kannst du dir dann Paar zahlen ausdenken und diese dann umrechnen um eine Routine zu bekommen.

Dezimal zu Hexadezimal

Als erstes erstellst du dir ne Zusatz Tabelle. In dieser Tabelle steht nur ganz einfach von 0 - 15 und von 0 - 9 und die a - f, wie hier im Beispiel gezeigt

Das dient am Anfang der Leichtigkeit und dem gewöhnen an ein 16er Zahlensystem. Du wirst merken das du am Anfang noch mit dem a-f paar mal durcheinander kommst. Das legt sich aber schnell mit der Zeit. Die Rechnung ist aber fast genauso einfach wie Dezimal zu Binär, nur das du hier mehr Kopfrechnerei hast. Aber wie sagt man so schön? damit aktivierst du natürlich deine grauen Zellen.
Wir nehmen mal die Zahl 3048. Die wird wie immer geprüft, wie oft sie in die 256 passt... 11 mal und Rest ist 232 (11*256=2816 dann 3048 - 2816 = 232). 11 hat den Wert b, den notierst du dann inklusive Rest. Mit dem Rest von 232 rechnest du dann weiter, wie oft passt sie in die 16? 14 mal mit dem Rest von 8, 14 hat den Wert von e, den notierst du dann inklusive Rest. Mit dem Rest von 8 rechnest du dann weiter und guckst wie oft sie in die 1 passt, 8 mal und Rest 0, also schreiben wir auf 8. Zusammen ergibt es den Wert von be8

Somit hast du grad errechnet das der Dezimalwert von 3048, den Hex Wert von be8 ergibt.

Hexadezimal zu Dezimal

Das ist genau das selbe Prinzip wie bei den anderen varianten, aber wir wollen jetzt nicht faul werden und machen eine Zahl wieder ausführlich zusammen. Wir nehmen den Hex Wert fe und wandeln ihn in Dezimal um. Wie herum du jetzt anfängst ist eigentlich egal, ich fange immer links an, weil ich dann die großen Zahlen schonmal weg hab. Wir schnappen uns das f und rechnen f*16. F ist der Stellenwert von 15 und 15*16 ergibt 240. Die Zahl notieren wir uns und nehmen uns das e vor was den Stellenwert 14 hat. 14*1 ergibt 14 und jetzt brauchen wir nur noch die beiden Werte addieren 240+14 ergibt laut Adam Riese 254. Du siehst das umrechnen ist eigentlich recht simple, sobald einer einem zeigt wie es geht.

Dezimal zu Oktal

Nachdem wir schon die schweren Sachen errechnet haben ist Oktal ein Kinderspiel (ich halte mich mit Absicht kurz, da das ganze quasi ne Wiederholung ist). Wir müssen alles nur in dem 8er System berechnen, aber die Logik wie das funktioniert ändert sich hier auch nicht.
Ich zeige dir einmal kurz eine Zahl und du versuchst es dann mit anderen Zahlen nachzumachen. Ich kopiere nochmal die Tabelle um das umrechnen leichter zu machen und du nicht ständig hin und her scrollen musst.

Wir nehmen uns die Zahl 212 und wandeln diese um. Wie oft passt die 212 in die 64? 3 mal, wir merken uns die 3 und den Rest (64*3 = 192)(212-192=20) 20. Mit der 20 rechnen wir weiter, wie oft passt sie in die 8? 2 mal und Rest 4 (2*8=16) die 4 passt 4 mal in die eins, somit ergibt sich der Wert 324_o .
War doch nicht so schwer oder?

Jetzt gehen wir mal einen Schritt weiter.

Hexadezimal zu Binär und zurück

Das ist im Gegensatz zu den anderen Umrechnungen ganz einfach. Nimm dir die Binärtabelle und erweitere sie um eine Zeile, wir nutzen aber nur die rechten 4 Spalten, da wir ein 16er System umwandeln, und der höchste wert 15 beträgt, brauchen wir 2⁴ nicht mehr

Wir rechnen einen kleinen Wert aus, 6b_h wird erst aufgeteilt, erst rechnen wir das b um, das ist der Dezimalwert von 11, den tragen wir wie gewohnt in die Tabelle ein, 11 passt einmal in die 8, einmal in die 2 und einmal in die 1 rein, somit ergibt sich der Wert 1011. Jetzt die 6, da passt die 4 und die 2 einmal rein. Das ergibt den wert von 110. Jetzt fügen wir die beiden Zahlen zusammen und erhalten einen Binärwert von 110 1011.

Zurück geht das genauso leicht. wenn du eine Binäre zahl von 110110110110 hast, trennst du sie am besten erst in 4er Blöcke auf damit du 1101  1011  0110 hast, dann schnappst du dir den ersten Block also die 1101 und wandelst den in Hex um (1*8+1*4+1*1) das ergibt dann 13, Hex ist das dann ein d, den merken wir uns und nehmen den zweiten Block um, 1011 (1*8+1*2+1*1) der Wert von 11 ergibt ein Hex b, den wieder merken und den letzten Block vornehmen 0110 ergibt (1*4+1*2) 6, damit haben wir einen Hex Wert von db6. 

Oktal zu Binär und zurück

Da man Hex zu Oktal nicht direkt umrechnet, sondern erst eine zwischen Rechnung über Binär macht, um zum Ziel zu kommen, ist das der letzte Punkt des Blogs.
Oktal ist ein 8er System, da brauchen wir von der Tabelle die wir zuletzt genutzt haben nur noch die letzten 3 Spalten

Die Umrechnung Basiert auf der selben Logik wie die von Hex zu Binär, da die Rechnung nur mit 4, 2 und 1 gerechnet wird, werde ich mir die Rechenschritte sparen. Wir haben eine Binäre zahl von 110101100010111101, diese spalten wir wieder in Blöcke, aber diesmal in 3er Blöcke dadurch entsteht dieses Muster 110  101  100  010  111  101. Fangen wir mit den Blöcken an, 110 ergibt 6, 101 ergibt 5, 100 ergibt 4, 010 ergibt 2, 111 ergibt 7 und 101 ergibt wieder 5, jetzt packen wir alles zu einer zahl und heraus kommt 6 5 4 2 7 5 was das Ergebnis auch liefert nämlich 654275_o 

Zurück ist es genauso leicht aber damit wir das dann auch besprochen haben hier ein Beispiel 364_o in Binär. Wieder splitten wir die Zahlen und nehmen und rechnen sie in Binär 3 ergibt 011, 6 ergibt 110 und 4 ergibt 100. Somit haben wir drei Binär Blöcke 011  110  100, da wir die erste null streichen können ist der Binäre Wert 11110100 der Oktalen Zahl 364.

Also schwer ist was anderes oder?
 

Ich hoffe ich war nicht all zu anstrengend und konnte dir mit dem umrechnen der Zahlensysteme helfen, falls du ein Feedback geben möchtest, nutz bitte die Kommentar Funktion, ich freue mich über jedes Feedback und beantworte es auch schnellstmöglich.

Bis zum nächsten mal

euer Lewan

Geht das überhaupt? 

Nun, das werde ich für dich testen. Es gab schon unzählige Testkarnickel, aber geblogt, hat es hier bis jetzt noch keiner.

Und genau da fängt mein Blog an. Ich werde dir in regelmäßigen Abständen, offenlegen

• Was ich gelernt habe 
• Wie mir das Thema gefiel bzw. 
• Wie verständlich das Thema in der kurzen Zeit vermittelt wurde
• Welche Hilfsmittel, wie Internet Seiten oder Bücher ich benutzt habe
• Welche Tips mir mein Dozent mit auf den Weg gegeben hat und
• Welche besonderen Unterschiede in meinem Betrieb zu anderen Betrieben bzw. zu der rein Schulischen Ausbildung vorliegen

Wobei ich bei dem letzten Punkt, auf deine Hilfe angewiesen bin. Nutze die Kommentar Funktion, um mir zu zeigen, dass ich genug Vorwissen gesammelt habe um

1. Die IHK-Prüfung zu bestehen
2. Im Praktikum nicht zum Kaffe Kocher verdammt werde und
3. Der wichtigste Punkt. Mit meinem Vorwissen, eine solide Grundlage habe um bei meinem zukünftigen Arbeitgeber, eine attraktive Hilfe zu sein und nicht nur ein Klotz am Bein. 

Das ganze ist natürlich für beide Seiten attraktiv zu sehen. Nicht nur ich profitiere von deinen Kommentaren, sondern auch du kannst von meinem Blog profitieren.

Viele Themen werden mal kurz mal lang durchgerattert und ob es nach zwei Jahren im Kopf geblieben ist, wenn man sich nicht mehr damit beschäftigt, beantwortet sich natürlich von selbst. Je öfter wir unsere grauen Zellen an das Thema leiten, um so mehr Synapsen werden angesprochen und um so weniger gerät ein Thema in Vergessenheit. 

Du bist schon länger Fachinformatiker und willst uns angehenden Fachinformatikern, mit Rat und Tat bei Seite stehen? 

Auch du bist eine riesen Bereicherung für meinen Blog. Es gibt genug Themen, die man falsch aufgenommen hat. Dieses falsche Wissen kann in einer mündlichen Prüfung dann das Todesurteil sein. Sollte dir ein falsch formulierter Blog Eintrag auffallen, schreibe es bitte in die Kommentare. Dadurch wird das falsche Wissen nicht im Internet weiter kursieren und die Blog Leser haben dann die Möglichkeit sich durch diesen Blog mit richtigen Ansätzen dem Thema neu zu widmen. 

Natürlich ist das kein Lehrblog den ich führe, aber eine Zusammenfassung dessen, was mir in meiner Umschulung auf den Weg gegeben wurde. 

Schließlich ist das Thema ja "in zwei Jahren zum Fachinformatiker, geht das überhaupt?" Und nicht "ich bringe dir in zwei Jahren den Beruf bei" ?

Somit verabschiede ich mich mit meinem ersten Blog bei dir und gebe dir noch die Fragen auf den Weg

• Hat dich der Blog angesprochen? 
• War er gut zu lesen oder so anstrengend, dass du froh warst, endlich Licht am Ende des Tunnels gesehen zu haben? 

Ich freue mich über deine Geduld, deine Zeit und dein Interesse das du in den Beitrag investiert hast. Dein Kommentar wäre das gelbe vom Ei. Ich hoffe auf ein Wiedersehen und das Folgen meines Blogs. 

Euer Lewan 

Damit man nicht mit jedem Container alles neu machen muss, kann man sich über Dockerfiles eigene Images erzeugen. Die hier gezeigte Version ist mehr oder weniger die finale Version. Davor gab es natürlich diverse Fehlversuche sei es wegen eigener Fehler oder weil man manche Dinge auch einfach nicht vermutet hätte. Unter Windows Nanoserver gibt es beispielsweise gar kein msiexec und das msiexec vom Server Core schreibt die Registryeinträge gar nicht oder irgendwohin wo sie später nicht gefunden werden. Mit setx kann man zwar globale Umgebungsvariablen setzen, startet man den Apache aber als Dienst, wird die Pfadeinstellung dennoch nicht genutzt.

# Wir benutzen unser schon gepulltes Windows Servercore Image
FROM servercore:ltsc2019
COPY install /install
# Installiert die ODBC Treiber im Image
# Wer hier eine Ausgabe zum Debuggen will kann noch "/l! out13.log" anhängen
RUN ["msiexec", "/a C:\\install\\msodbcsql_13.msi", "/qn"]
RUN ["msiexec", "/a C:\\install\\msodbcsql_17.msi", "/qn"]
# Installation von VC Redist - 15 wird bei Server 2019 nicht benötigt
RUN ["C:\\install\\vc_17.exe", "/quiet", "/install"]
RUN ["C:\\install\\vc_13.exe", "/quiet", "/install"]
# Die Registry-Datei für die ODBC Treiber importieren
RUN "reg import C:\\install\\odbc.reg"
# install brauchen wir nicht mehr
RUN "RMDIR /S /Q C:\\install"
# /instantclient entspricht dann C:\instantclient im Image
COPY instantclient /instantclient
# einfach großartig - wenn jemand eine Idee hat wie ich Apache als Service erklären kann wo der instantclient liegt ...
ENV PATH="C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Windows\System32\OpenSSH\;C:\Users\ContainerAdministrator\AppData\Local\Microsoft\WindowsApps;C:\instantclient"
# Apache usw. kopieren - *1
COPY webapp /webapp
WORKDIR /webapp
# wir möchten mit dem Container reden
EXPOSE 80
# kopieren von php und der php.conf ins Apache config Verzeichnis - *2
COPY php/php /webapp/php
COPY php/php.conf /webapp/Apache24/conf/extra
# zum Testen/Debuggen
#ENTRYPOINT ["cmd.exe"]
# und los geht’s
ENTRYPOINT ["C:\\webapp\\Apache24\\bin\\httpd.exe"]

Das Dockerfile kommt dann mit in das Build-Verzeichnis und das neue Image kann mit folgendem Befehl erzeugt werden.

PS E:\build\>docker build -t test .

Mit

PS E:\build\>docker run -it -p 80:80 --name test_container test

starten wir den Container und prüfen das alles wie gewünscht funktioniert. Ist das der Fall teilen wir das Dockerfile in 3 Dateien. Das Dockerfile wird dann bei *1 und *2 aufgeteilt. Der erste Teil bleibt wie er ist und wir nennen das Dockerfile core2019. Und bauen ein Image daraus.

PS E:\build\>docker image build -t core2019 -f .\core2019 .

Das zweite Dockerfile sieht dann so aus

FROM core2019:latest
COPY webapp /webapp
EXPOSE 80

und das dritte so

FROM apache_core2019:latest
COPY php/php /webapp/php
COPY php/php.conf /webapp/Apache24/conf/extra
WORKDIR /logodata
ENTRYPOINT ["C:\\webapp\\Apache24\\bin\\httpd.exe"]

Ich habe die Dockerfiles nach dem Image benannt das sie erzeugen. Die weiteren Images baue ich also mit

PS E:\build\>docker image build -t apache_core2019 -f .\apache_core2019 .
PS E:\build\>docker image build -t php_apache_core2019 -f .\php_apache_core2019 .

Damit hat man zwar etwas Overhead bei jedem Build, da jedesmal das komplette Verzeichnis zum Buildprozess übergeben wird. Allerdings können wir so sehr einfach andere PHP und/oder Apache Versionen in ein anderes Image packen ohne den Standard zu verlieren oder die grundlegende Installation wiederholen zu müssen.

Lauf Docker, Lauf!

Die entstandenen Images kann man nun wieder mit kürzeren Namen taggen und schließlich starten

PS> docker run --restart unless-stopped -d --name flamara -p 17000:80 -v E:\share\develop:C:\webapp\docroot -v E:\share\config:C:\webapp\docroot\config\ --dns=10.0.0.20 php2019:latest

Mit -p mappen wir einen Port des Hosts zu dem freigegebenen Port des Containers. Dann mappen wir mit -v zum einen die Webapplikation selbst ins docroot des Containers und auch die Konfiguration der Software.

So können wir beliebige Versionen der Software mit der gleichen Konfiguration (Benutzer, Rechte, Datenbankanbindung) in der gleichen Umgebung testen.

Die nächsten Schritte wären nun, das Ganze mit einem Linux Base-Image zur erstellen und danach automatisierte Builds.

Als nächstes bereiten wir die Build-Umgebung vor. Wir laden Apache, PHP, passende vc_redist (17 und 13), Microsoft ODBC Treiber 13 und 17, SQLSRV5.3, und einen Oracle Instantclient herunter.

Ich überspringe an dieser Stelle einige Schritte und zeige nur die endgültige Version. Ihr verpasst aber nichts Dramatisches, der Buildprozess wurde nur einige Male verändert und die Verzeichnisstruktur entsprechend angepasst. Der Sinn oder Unsinn wird dann vermutlich klar, wenn wir uns die Dockerfiles ansehen.

Also legen wir erstmal folgende Struktur an:

Build
├───install
├───instantclient
├───webapp
│   ├───Apache24
│   └───docroot
└───php
    └───php

In install legen wir die VC Redist Installer und die ODBC Treiber MSI-Pakete ab. Ich habe die umbenannt um sie leichter unterscheiden zu können.

Den Instantclient kann man einfach entpacken und den Inhalt des instantclient_18_3-Verzeichnisses in instantclient ablegen.

In php/php wird das heruntergeladene PHP entpackt und in webapp/Apache24 der Webserver. Die httpd.conf nach Belieben anpassen, darauf achten das das DocumentRoot webapp/docroot sein soll und noch eine webapp/Apache/conf/extra/php.conf includieren. Die gibt es zwar nicht, das erledigt dann der Buildprozess.

Die php.conf kommt nach /php und sieht etwa so aus:

LoadModule php7_module "C:\webapp\php\php7apache2_4.dll"
AddType application/x-httpd-php .php
PHPIniDir "C:\webapp\php"
DirectoryIndex index.php

Nun noch PHP konfigurieren und dann sind die Vorbereitungen abgeschlossen.

Eigentlich ... also quasi schon ...

Aus irgendeinem Grund werden die Registry-Einträge für die ODBC-Treiber nicht geschrieben. Weder beim Build noch im laufenden Container. Also erstellen wir noch eine odbc.reg und legen die mit nach /install. Die Datei kann man erzeugen, indem man den Schlüssel exportiert. Dazu kann man kurzzeitig die ODBC Treiber auf dem Host installieren.

Die grundlegende Frage gleich vornweg: Warum sollte man Docker auf einem Windows Server betreiben?

Nunja, weil man es kann. Außerdem besteht die Infrastruktur bei den meisten unserer Kunden aus MS SQL-Server und Windows Servern auf denen unsere Software installiert wird. Hier könnte man nun argumentieren, dass unsere Software "nur" PHP und Apache benötigt und das zusammen mit PostGreSQL oder ORACLE durchaus auf Linux laufen könnte. Ja, ist richtig, wir möchten aber nicht auch noch irgendwelche Linux Installationen bei unseren Kunden pflegen.

Sucht man, naiv wie man ist, einfach mal nach "docker windows", landet man früher oder später bei "Docker CE for Window". Hat man das installiert und den ersten Container gestartet, wird einem auffallen das die Container nicht beim Booten starten. Da ist auch nichts falsch konfiguriert, das soll so sein. Dafür gibt es sicherlich Gründe. Diese Version ist für Entwickler gedacht, die Docker auf ihrem Windows 10 PC betreiben wollen. Wollen wir aber gar nicht …

Installation

Also installieren wir mal das richtige

PS> Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201 -Force
PS> Install-Module -Name DockerMsftProvider -Force
PS> Install-Package -Name docker -ProviderName DockerMsftProvider -Force

Danach möchte der Server einmal neu starten und wir können mit docker version schauen ob das funktioniert hat.

PS C:\> docker version
Client:
 Version:           18.09.0
 API version:       1.39
 Go version:        go1.10.3
 Git commit:        33a45cd0a2
 Built:             unknown-buildtime
 OS/Arch:           windows/amd64
 Experimental:      false

Server:
 Engine:
  Version:          18.09.0
  API version:      1.39 (minimum version 1.24)
  Go version:       go1.10.3
  Git commit:       33a45cd0a2
  Built:            11/07/2018 00:24:12
  OS/Arch:          windows/amd64
  Experimental:     true

An der Stelle konfigurieren wir den Dienst erstmal ein wenig. Das kann man prinzipiell auch über eine json-Datei erledigen. Anleitungen dazu findet man genug. Man kann die Parameter aber auch direkt dem Dienst übergeben.

PS E:\> Stop-Service Docker
PS E:\> Remove-Service Docker
PS E:\> New-Service -Name Docker -DisplayName "Docker Engine" -StartupType Boot -BinaryPathName "C:\Program Files\Docker\dockerd.exe --run-service -H npipe:// -H 0.0.0.0:2375 --data-root=E:\docker --experimental"
PS E:\> Start-Service Docker

Für Remove-Service benötigt man allerdings PowerShell Version 6. Die gibt es zwar seit August 2018, ist dennoch nicht im Server 2019 enthalten. Nach dem Neustart des Dienstes legt Docker nun seine benötigte Verzeichnisstruktur unter E:\docker an. Und durch –experimental können wir später –plattform=linux nutzen.

Nun ist es endlich soweit, wir holen unser erstes Image. Normalerweise würde man das einfach mit

PS> docker pull microsoft/nanoserver

erledigen. Das funktioniert zwar, aber ...

Das was man dann bekommt ist ein Server 2016 SAC Image. Was per se zwar nicht verkehrt ist, aber im ersten Moment auf einem Server 2019 nicht funktioniert. Hier müsste man dem docker run noch ein --isolation=hyperv mitgeben oder man holt ein neues Image. Für Images die zum Server 2019 passen benötigt man spezifische Tags und kann sich nicht auf den Standard :latest verlassen. Images vom Nanoserver und Windows Server Core holen wir mit.

PS> docker pull mcr.microsoft.com/windows/nanoserver:1809
PS> docker pull mcr.microsoft.com/windows/servercore:ltsc2019

Anschließend verpassen wir den Images noch neue Tags

PS> docker image tag mcr.microsoft.com/windows/nanoserver:1809 nanoserver:1809

An dieser Stelle können wir auch schon mal einen Container mit einem der Images starten.

PS> docker run -it --name testdings microsoft/nanoserver powershell

Damit bekommen wir eine PowerShell Instanz in dem laufenden Container und können Dinge tun. Updates installieren, wäre eines dieser Dinge. Das erledigt man normalerweise mit sconfig auf der geöffneten PowerShell.

In den nächsten Teilen bereiten wir die Build-Umgebung vor, basteln uns ein Dockerfile und bewundern das Ergebnis

und willkommen zurück zum Azubi-Wissen - wie immer versucht in relativ einfachen Worten zu erklären

jetzt geht alles um Hardware-RAIDs (Redundant Array of Independent Disks). Ein RAID ist ein Zusammenschluss von 2 oder mehr Festplatten mit dem Ziel bei einem Ausfall einer Platte (gerade in Server-Umgebungen) nicht gleich einen Totalausfall zu haben.

Was wird dazu benötigt?

Ein Hardware-RAID lässt sich nicht einfach so in jedem System erstellen. Selbst wenn ich mir 2 Festplatten an den privaten PC hänge habe ich normalerweise keine Möglichkeit daraus einen Hardware-RAID zu machen - ein Software-RAID dagegen wird mittlerweile von vielen Chipsätzen unterstützt, dabei wird allerdings die Prozessorleistung beansprucht und auch die internen Bussysteme deutlich mehr belastet. Für unseren Hardware-RAID braucht es einen sogenannten RAID-Controller.

Statt also die Festplatten direkt mit dem Mainboard zu verbinden, werden sie direkt (oder indirekt mit Zwischenschritt) mit einem Controller verbunden. Der Controller bringt meist eine BIOS-ähnliche Möglichkeit beim Starten des PCs in ein Menü zu gelangen in dem der RAID dann konfiguriert werden kann.

Aber jetzt an das EIngemachte. Welche RAIDs gibt es?

Ich sage dem PC nicht "Ich will einen RAID" und klicke "weiter", "weiter", "weiter", "Fertig". Naja fast nicht. Als IT-ler müssen wir uns überlegen welche Art von RAID wir haben wollen, davon gibt es nämlich ein paar - und die haben Nummern, sie werden auch tatsächlich im Sprachgebrauch so benannt.

RAID 0

Striping. RAID 0 ist tatsächlich ein Sonderfall und viele behaupten, dass sich diese Nummer nicht als RAID schimpfen kann - es hat nämlich nichts mit Redundanz (= Ausfallsicherheit) zu tun. Es ist sogar das Gegenteil der Fall, aber schauen wir uns mal an was es überhaupt macht.

Nehmen wir mal an wir haben 2 Menschen (das sind unsere Platten^^), der ein schreibt "Hallo Welt" auf einen Zettel und braucht dafür 2 Sekunden. Verbinden wir unsere Menschen (Platten) jetzt, sagen wir dem einen er soll "Hallo" schreiben, während der andere gleichzeitig einfach nur "Welt" schreibt. Es dauert 1 Sekunden bis "Hallo Welt" auf dem Papier steht, wir waren also schneller.

Bei diesem RAID werden Daten also gleichzeitig auf die verschiedenen Platten verteilt (Blockweise), wir bekommen also einen Performance-Boost und haben mehr Speicherplatz zum beschreiben. Der Nachteil natürlich: Wenn eine Platte ausfällt sind unsere Daten weg, PC ist nicht mehr bootbar (ähnlich wie wenn man bei der Programmierung einfach mal die Hälfte aller Buchstaben löscht, dann bleibt nur noch etwas stehen das das System nicht versteht). Dadurch, dass wir auch nicht eine Festplatte haben sondern 2 ist die Ausfallrate höher. Oder in einer anderen Dimension gesprochen: Wenn wir darauf warten, dass 1 Festplatte ausfällt können Jahre vergehen, aber wenn man 1000 Festplatten hat ist die Chance groß, dass hier und da mal welche ausfallen. Also je mehr Platten, desto höher die Ausfallrate.

RAID 1

Mirroring. Jetzt kommen wir zum ersten 'echten' RAID - und der ist sogar noch recht einfach erklärt. Die Platten sind gespiegelt, heißt was auf die eine geschrieben wird, wird gleichzeitig auch auf die andere geschrieben - keine unterschiedlichen Daten wie beim RAID 0, sondern dieselben Daten. Würde wir unseren Menschen also hier auftragen "Hallo Welt" zu schreiben würden beide "Hallo Welt" auf ihren zettel schreiben.

Vielleicht kann man das auch ohne einen RAID machen, indem man einfach eine Festplatte klont, aber hier kommt der Controller zum EInsatz: Lässt sich eine Platte nicht mehr lesen oder fällt aus (oder jemand ist so mutig und zieht eine Platte mitten im Betrieb raus - einmal gemacht, aber ich würde es natürlich nicht empfehlen), wird automatisch die andere angesprochen, es entsteht kein Ausfall. Steckt man dann eine neue Festplatte an wird der RAID 'im Hintergrund' neu aufgebaut. Nachteil ist, dass uns weniger Speicherplatz zur Verfügung steht. Wir können nur den Speicherplatz einer Platte benutzen - die andere ist schließlich nur als "Klon" da, wir können keine extra Daten auf sie schreiben.

Achja, logisch ergibt sich, dass beide Festplatten hier dieselbe größe haben sollten, sonst gibt es entweder Fehler oder wir verschenken Speicherplatz.

RAID 5

Block-Level Striping mit verteilter Paritätsinformation. Wer hat sich solche Wörter nur ausgedacht? Respekt an diejenigen die den Wikipedia-Eintrag verstehen. Tatsächlich ist RAID 5 komplizierter als die anderen beiden. Wir sind auch nicht mehr bei 'mindestens 2 Festplatten', sondern hier brauchen wir mindestens 3 - oft sind es aber 5 Festplatten die man hier verwendet.

Ich erkläre es erst einfach, um es verständlich zu machen, dann mit etwas mehr Fachbegriffen.

Also: nehmen wir an wir haben diesmal unsere 3 Menschen (Platten), aber zum Verständnis lassen wir sie diesmal Zahlen schreiben. Einer schreibt eine "1" auf seinen zettel, der nächste eine "2" und der dritte - wer hätte es gedacht - eine "3". Vorneweg: Wir haben unsere Daten wieder blockweise verteilt, haben also den Vorteil von RAID 0, dass wir mehr Geschwindigkeit sowohl beim Schreiben als auch beim Lesen haben. Allerdings werden unsere Daten nicht auf alle Festplatten aufgeteilt, sondern es wird eine frei gelassen. Wir wollten nie eine "3" schreiben, aber unser RAID macht das automatisch - das muss es auch. Ich wollte das ähnlich einer Rechenaufgabe aufbauen: 1 + 2 = 3. Fällt eine Festplatte nun aus hätten wir zum Beispiel 1 + x = 3 (x ist unsere ausgefallene Platte) - unser RAID kann die fehlenden Daten während der Laufzeit errechnen, es braucht die Platte nicht. Allerdings sollten wir sie trotzdem ersetzen, denn jetzt büßen wir massiv an Performance ein, unser PC rechnet sich zu tode - aber er funktioniert. Wir erleiden trotzdem einen kleinen Verlust an Kapazität.

Gehen wir nochmal genauer darauf ein: Die Daten die wir auf unsere Platten schreiben wollen werden auf alle Platten bis auf eine verteilt. Erst wenn diese geschrieben wurden ließt unser Controller die Daten aus und auf die übrige Platte wird dann die sogenannte Parität geschrieben - eine XOR-Veknüpfung der Daten die berechnet wird. Wichtig zu wissen: Diese Parität wird nicht immer auf dieselbe Platte geschrieben sondern es 'rotiert', wird also mit jedem neuen Block auf eine andere Platte geschrieben

RAID 6

Ist eher unbekannt, wird aber minimum in Baden Württemberg als Prüfungswissen vorrausgesetzt. Raid 6 wird eher seltener eingesetzt, meist von Systemen die super-mega-ultra-wichtig sind und unter keinen Umständen ausfallen dürfen. Der größte Vorteil ist, das nicht nur 1 sondern gleich 2 Festplatten gleichzeitig ausfallen dürfen ohne das System lahm zu legen. Minimum brauchen wir hier 4 Festplatten - 2 für unsere Daten und 2 die wir bei RAID 5 eine Parität schreiben. Wir haben also ein RAID 5, der einzige unterschied ist wir haben noch eine Parität. Und dadurch das wir hier wieder einen Bereich weg nehmen haben wir natürlich noch weniger frei verfügbaren Speicher als bei einem RAID 5. Wird ein RAID 6 aufgrund der Ausfallsicherheit eingesetzt wird oft dazu geraten Festplatten unterschiedlicher Hersteller oder Produktions-Daten zu nehmen um das Risiko von 2 gleichzeitig ausfallenden Festplatten weiter zu verrigern.

RAID 10

( Von Wheart, based on image File:RAID 0.svg by Cburnett - Eigenes Werk, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=6411865 )

Es wird wieder einfach. RAID 10 hat seinen Namen nicht einfach irgendwo her, es ist eine Kombination aus RAID 1 und RAID 0. Heißt wir nutzen jeweils immer 2 Platten im RAID 1 UND diese entstandenen RAIDs werden nochmal mit einem RAID 0 überbügelt. Dadurch haben wir sowohl eine Ausfallsicherheit, als auch eine höhere Geschwindigkeit. Aber: Es ist teuer. 4 Festplatten wovon ich nur die Hälfte an Speicher habe... lohnt sich eher selten.

Wichtig ist hier: Man braucht immer eine gerade anzahl Festplatten (mindestens 4, vorrausgesetzt keiner geht davon aus, dass 2 Festplatten zur exakt gleichen Zeit ausfallen), weil man auf der unteren Ebene ja immer erst 2 Platten spiegelt.

RAID 01

( Von Wheart, based on image File:RAID 0.svg by Cburnett - Eigenes Werk, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=6411849 )

Man kann es vielleicht schon vermuten... hier werden die Platen erst in mehrere RAID 0's aufgeteilt und dann wird ein RAID 1 drüber gebügelt. Manch einer stellt sich nun die Frage: Was ist der Unterschied zu RAID 10? Anhand des Bildes lässt sich kaum ein unterschied feststellen und egal wie man es dreht, man hat RAID 0 und 1 und beide Vorteile davon.

Der Unterschied wird sichtbar wenn wir die Anzahl der Platten verändern. Für ein RAID 10 brauchen wir nämlich mindestens 4 Festplatten (wie gesagt wir spiegeln sie ja auf der unteren Ebene erst), bei einem RAID 01 brauchen wir minimum... 3! Und anders als bei einem Raid 10 kann es hier schon Sinn machen die Raid 0 auf unterster Ebene auch mal mit 3 oder mehr Festplatten zu machen - aus Performancegründen.

( Von RAID_1.svg: en:User:C burnettderivative work: Nmoas (talk) - RAID_1.svg, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=11995780 )

Allerdings sind 3 Festplatten jetzt eine Ausnahme, ähnlich wie beim RAID 5 werden die Platten zusammengefügt und die Blöcke durchnummeriert. Jede ungerade Nummer bekommt Daten, jede gerade Block-Nummer nur eine Kopie des Blocks davor - alles wieder rotierend auf die Platten verteilt.

Sonstige Es gibt noch mehr RAIDs die aber eher unbekannt sind und selten vorkommen. Da diese im Praxisgebrauch Ausnahmen bilden gehe ich hier nicht weiter auf sie ein.

Die Berechnung des verfügbaren Speichers

Nehmen wir an wir haben 3 Festplatten mit jeweils 1TB:

RAID 0 ist einfach. Beim RAID 0 können wir alle 3 Platten benutzen, wir schreiben und lesen auf allen 3 gleichzeitig, haben nichts doppelt, können also die vollen 3 TB ausnutzen. Wir zählen also einfach alle 3 Platten zusammen.

RAID 1 ist ebenfalls einfach, allerdings macht es hier keinen Sinn 3 Platten als Beispiel zu haben (das würde jemand tun der davon ausgeht das 2 Platten zur exakt gleichen Zeit ausfallen). Nehmen wir also an wir haben 2. Wir spiegeln die Platten, haben also nur die Hälfte des Gesamtspeichers zur Verfügung - also nur die Kapazität einer Platte.

RAID 5 ist auch nicht sooo schwer. Mit ein wenig Hintergrundwissen und logischem Denken kriegen wir das hin. Was wir hier wissen müssen: Die Datenblöcke und die Parität haben immer dieselbe Größe. Ob ich nun (bei 5 Platten) meine Daten auf 4 verteile und die Parität auf die 5te Platte setze, oder ob ich (bei 3 Platten) meine Daten auf 2 verteile und die 3. Platte die Parität bekommt. Also trotz das die Parität immer auf einem anderen Laufwerk liegt können wir damit rechnen, dass wir immer 1 Platte als Speicherplatz für die Paritäten bei der Berechnung der Speicher-Kapaität abziehen müssen. Bei unseren 3 Festplatten macht das 2 TB, bei 5 Platten wären es 4TB. Besonders ist hier das wir prozentual mehr Speicher zur Verfügung haben, je mehr festplatten wir benutzen. Bei 3 Platten haben wir 66% Speicher frei zur Verfügung (2 von 3). Bei 4 sind es 75% (3 von 4) und bei 5 Festplatten 80% (4 von 5),...

RAID 6 ist nachdem wir uns mit RAID 5 herumgeschlagen haben wieder ähnlich. Statt immer 1 Festplatte mit Parität haben wir hier immer 2 Festplattend ie Paritäten beinhalten und uns dementsprechend nicht zur Speicherung der eigentlichen Daten zur Verfügung stehen. Also immer (Anzahl Festplatten - 2). Auch hier wieder: Je mehr Festplatten desto lohnenswerter ist der zur Verfügung stehende Speicherplatz.

RAID 10/01 sind ebenfalls einfach. Egal wieviele Platten wir haben, wir haben immer die Hälfte vom Gesamtspeicher - wir kopieren unsere Daten ja wieder.

Schlussendlich gibt es nur noch eine Anmerkung: Viele Server bieten ein sogenanntes Hot-Spare-Laufwerk. Zusätzlich zu den Platten die ihr für euer RAID braucht (für welches auch immer ihr euch entscheidet) wird hier noch eine Platte angeschlossen. Die macht erstmal gar nichts, sie hängt da halt, ganz ohne Daten.

Richtig konfiguriert sollte der Controller sobald eine Festplatte ausfällt sämtliche Daten der defekten Platte auf die spare(="ungenutzt")-Platte schreiben (deswegen haben wir ja einen RAID, die Daten lassen sich rekonstruieren, selbst wenn die ausgefallene Platte absolut kein lebenszeichen mehr von sich gibt). Fällt in dieser Zeit der 'rekonstruktion' eine der anderen Platten aus sind die Daten weg! (Ausnahme RAID 6) Hat man keine Spare-Platte muss man schnell handeln. Wird man darauf aufmerksam gemacht das eine Festplatte ausgefallen ist kann man diese entfernen (das geht meist auch im laufenden Betrieb) und eine neue Platte in den Server schieben, der Vorgang zur Rekonstruktion sollte automatisch erfolgen.

Fragen, Anregungen oder Ergänzungen? Immer her damit.

Nach einer längeren Zeit der Beitragsflaute mal wieder ein neuer Post. Dafür gibt es dieses mal auch etwas mehr und wieder einen Veranstaltungsbericht. Dieses mal jedoch nicht von einer Konferenz, sondern von einem Seminar mit anschließender Prüfung zur Zertifizierung.

Vom 05.07.2016 bis zum 07.07.2016 bin ich mit einem Kollegen in Köln auf einer prüfungsvorbereitenden Schulung zum Thema "Usability Engineering and User Experience" gewesen und habe dort einiges an Wissen erworben, das ich gerne auszugsweise(da sonst jeglichen Rahmen sprengend) mit euch teilen möchte.

Innovative Software braucht doch keine Kreativität "UX aus der Dose"

Im April 2016 habe ich mit zwei Kollegen die "OBJEKTspektrum information days" in Frankfurt am Main besucht und dort einen extrem interessanten Vortrag von einem mir recht sympathischen Sprecher gesehen.

In dem Vortrag mit dem provokanten Titel "Innovative Software braucht doch keine Kreativität – Ein Usability-Engineering How-to-Guide" beschrieb der Sprecher Herr Thomas Geis, wie man mithilfe der EN ISO 9241 und anderer Erkenntnisse aus dem Bereich "Entwicklung gebrauchstauglicher Produkte" mit rein methodischem Vorgehen sogenannte "Erfordernisse" an ein Produkt identifizieren kann, die unabhängig von bisherigen Lösungen oder Anforderungen oft exakt das beschreiben, was eigentlich vom Benutzer gewünscht wird.

Beispiel gefällig? Heizungsventile kennt ja so ziemlich jeder. Üblicherweise sind die irgendwie zum Drehen und haben von 0-5 eine Skala drauf, wobei man eigentlich nie weiß, welche Zahl welche Temperatur bedeutet.

< Ein beliebiges Standard-Thermostat

Ein Erfordernis an ein Heizungsventil oder eine "Heizeinrichtung" allgemein lautet jedoch eher so:

"Der Benutzer muss wissen, welchen Wert er eingeben muss um eine gewünschte Raumtemperatur zu erreichen."
Daraus ergibt sich, wenn man genau ist, nicht die Anforderung
"Der Benutzer muss am System an einem Drehregler einen Wert von 0-5 einstellen können", sondern eher etwas wie "Der Benutzer muss am System die gewünschte Zieltemperatur eingeben können."

Was passiert, wenn man so eine Anforderung konsequent zu einem sogenannten "interaktiven System" weiterentwickelt, sieht man beispielhaft hier. Das System ist bezüglich der Temperaturmessung im Raum zwar noch nicht zu 100% ausgereift, aber ein gefühlter Quantensprung an "Mehrkontrolle" gegenüber einem regulären Heizungsventil. Denn sind wir mal ehrlich, wer kennt die Situationen nicht, in denen man wie ein Verrückter zwischen "2.5" und "4.5" am Heizungsventil hin- und herdreht.

Noch spannender wird es, wenn man den Nutzungskontext einer "Heizung" genauer analysiert. Dann stellt man schnell fest, dass es nicht darum geht, eine "Zieltemperatur einzustellen", sondern dass es "angenehm temperiert ist". Analysiert man diesen Gedanken weiter, könnte es z.B. mit einem "Wearable Computer" verbinden um anhand der Körpertemperatur und der Entfernung zum Haus die Heizung so anzuschalten, dass die Wunschtemperatur immer automatisch gehalten wird. Fahre ich also weg, fährt die Heizung so weit herunter, dass sie, wenn ich jetzt umdrehen würde, bei der Ankunft zu Hause wieder auf der "Wohlfühltemperatur" steht. Boom! Innovation. Etwas, das als neu oder mit "Wow"-Effekt wahrgenommen wird, weil es bestehende Prozesse drastisch vereinfacht, verbessert oder einfach völlig anders löst als bisher bekannt.

Das Seminar - "Usability in a nutshell"

Angefixt von dem Talk auf der Konferenz haben mein Kollege und ich uns also ein gutes halbes Jahr später im Mietwagen nach Richtung Köln auf den Weg gemacht. Dadurch, dass der Talk auf der Konferenz so gut war, haben wir uns auch direkt dazu entschieden, das Training ebenfalls bei Herrn Geis von der Firma ProContext durchzuführen. Bevor jemand fragt, ich kassiere hier keine Provision, ich bin einfach wirklich begeistert von den Inhalten und der Art der Vermittlung.

"Human centered design process"

Nach dem Check-In im B&B-Hotel Köln/Messe und einem sehr geschmeidigen Abendessen in einem mexikanischen Restaurant ging es am nächsten Morgen ausgeschlafen und frisch gestärkt mit dem Zug Richtung Innenstadt zum Konferenzhotel direkt am Kölner Dom.

Tag 1 -  Usability-Basics

Bevor in tatsächliche Übungen eingestiegen werden konnte, gab es erstmal eine ordentliche Portion Theorie. Denn bei der Herstellung gebrauchstauglicher Produkte gibt es eine Menge Dinge, die einem begegnen können, die sehr präzise eingeordnet werden müssen, um sie richtig zu deuten. Die ISO-9241 und die Seminarinhalte vermitteln uns genau diese Sprache, diese Begriffe mit denen es möglich ist, solche Themen und diffusen Konzepte konkret zu benennen und damit zu arbeiten.

Programmübersicht Tag 1

Themen waren unter anderem "Erfordernisse", "Anforderungen" und was deren Unterschied ist. Ein Erfordernis z.B. ist oft unbewusst, ein sogenanntes "implied need" und muss systematisch im Nutzungskontext erhoben werden. Eine Anforderung wiederum befriedigt bei Erfüllung ein Erfordernis und basiert auf diesem. An 2 Beispielen möchte ich das kurz exemplarisch für andere erläuterte Begriffe darlegen. Alles ausführen kann und möchte ich hier nicht, das würde a) den Rahmen sprengen und müsste ich euch das vermutlich beim Lesen in Rechnung stellen.

Erfordernis

Syntax: Die <Benutzergruppe>, muss XXX wissen / verfügbar haben, um YYY entscheiden / tun zu können.

Es gibt also immer eine Voraussetzung und einen Zweck, die im Erfordernis festgehalten sind, welches wiederum im Nutzungskontext verankert sein muss.

Ein Beispiel für eine Vorrichtung zum Garen von Eiern:

Der Benutzer muss den Garzustand des Eis kennen, um entscheiden zu können, ob er es im Garvorgang belässt oder nicht.

Anforderung

Syntax: Der Benutzer muss am System ZZZ

• erkennen/überblicken können
• auswählen können
• eingeben können

Daraus ergäbe sich für unsere Garvorrichtung folgende beispielhafte Anforderung:

Der Benutzer muss am System den Garzustand der darin befindlichen Eier erkennen können.

Wie diese Anforderung jetzt technisch umgesetzt wird, ist an dieser Stelle bewusst offen gehalten. Ob eine grafische Anzeige, eine Push-Mitteilung auf das Smartphone (IoT ist ja in aller Munde momentan), eine Melodie oder was auch immer das "Beste" ist, wird im Anschluss im Test überprüft.

Des weiteren wurden die 7 Dialogprinzipien und ihren Auswirkungen auf die Gestaltung von Nutzungsschnittstellen thematisiert.

Am Ende des ersten Workshop-Tages wurden gemeinsam in Übungen aus Nutzungskontextbeschreibungen Erfordernisse und aufbauend darauf Anforderungen her- bzw. abgeleitet. Interviews und Nutzerbeobachtungen spielen dabei im Vorfeld eine entscheidende Rolle.

Der Tag war also schon gefüllt mit ordentlich Inhalt, sowohl qualitativ als auch quantitativ. Und es zeichnete sich nicht ab, dass das weniger werden sollte. Im Gegenteil.

Um die Inhalte gebührend zu verarbeiten und Platz für Neues zu machen, gönnten wir uns mit einem Teil der Truppe nach einem Besuch des Weihnachtsmarktes am Kölner Dom gemeinsam im "Früh am Dom" noch das ein oder andere Kölsch.

Tag 2 - Entwickeln und Testen von UI/UX-Lösungen

“If the user can’t use it, it doesn’t work” –Susan Dray

Noch leicht schwammig im Kopf vom Kölsch ging es mit der Bahn zurück zum Hauptbahnhof und von da aus ins Schulungshotel.

Wenn Tag 1 den Fokus darauf legte, die Basis zu legen und Erfordernisse und Anforderungen zu sammeln, war der Hauptinhalt von Tag 2, zu erkunden, wie man dieses Wissen jetzt in ein Produkt, oder besser, einen Prototypen bzw. eine evaluierbare Geschäftsidee überführt.

Der oben schon verlinkte "Menschzentrierte Prozess zur Gestaltung gebrauchstauglicher interaktiver Systeme" war die Basis, auf der der zweite Tag basierte. 

Nachdem man Erfordernisse identifiziert und Anforderungen hergeleitet hat, ist der nächste Schritt im Prozess, eine Designlösung zur Evaluierung zu erarbeiten. Auf gut deutsch: "Einen Prototypen zum Testen bauen."

Dafür gibt es natürlich verschiedene Dinge, die man beachten muss. Ein paar Begriffe, Konzepte und Informationen, die dazu gehören, will ich hier exemplarisch auflisten.

Kippschalter - Benutzung offensichtlich

Affordance -Aufforderungscharakter Der Grad der Affordance beschreibt, wie sehr ein Element in einer Nutzungsschnittstelle zu seinem korrekten Gebrauch auffordert. Einem Schalter ist z.B. recht deutlich anzusehen, dass man ihn umlegen kann. Ich habe allerdings auch schon Dimmschalter gesehen, die man zum Anschalten nach unten "streicheln" musste und zum Abschalten bzw. dimmen nach oben. Aus Usability-Sicht ein ziemlicher Griff ins Klo.

Intuitiv

Im Usability-Sprech spricht man von Intuitivität, wenn die Benutzung eines interaktiven Systems unabhängig von der Erfahrung, vom Wissen, von den Sprachkenntnissen und dem momentanten Konzentrationsgrad des Benutzers unmittelbar verständlich ist.

Das heißt in der Praxis, dass ein Geldautomat dann intuitiv ist, wenn man ihn am Ballermann als 16-Jähriger, der zum zweiten mal in seinem Leben Geld abhebt, grade bierbedingt 2,5 Promille intus hat trotzdem bedienen kann. Obwohl der Automat grade in "Spanisch" eingestellt ist. Leichter gesagt als getan also.

Mentales Modell

Unter einem "Mentalen Modell" versteht man die Vorstellung, die ein Mensch von der Umgebung, den Menschen und Dingen hat, mit denen er interagiert. 

Wasserhahn mit klassischer "blau - kalt, rot - warm"-Färbung

Das Mentale Modell von einem Wasserhahn ist bei den meisten Menschen so konzipiert, dass es einen Griff zum Starten des Wasserflusses und einen Schieberegler zum Einstellen der Temperatur gibt. Das wäre das "Systemmodell". Ein Mensch, der zum ersten mal einen Wasserhahn mit Berührungssensor benutzen möchte, wird vermutlich Probleme damit haben, wenn er bis dahin noch keinen Kontakt zu dieser Technik hatte.

Ein paar Jahre vorher gab es z.B. noch nicht mal den stufenloser Schieberegler am Mischer. So musste man noch manuell heißes bzw. kaltes Wasser aufdrehen, bis man die gewünschte Zieltemperatur erreicht hat. Moderne Systeme bieten hier (zumindest in der Dusche) oft schon eine  auf den Regelmechanismus geätzte Temperaturskala an, die die Benutzung erleichtert. 

Wichtig ist für das mentale Modell jedoch diese Aussage.

Passen mentales Modell und Systemmodell nicht zusammen, sind Nutzungsprobleme vorprogrammiert.

Joel Spolsky, Gründer von Trello und Mitgründer von Stack Exchange, hat dazu vor 17 Jahren(!) einen Blogpost geschrieben, der immer noch Relevanz hat. 

Neben diesen Konzepten wurde den "7 Dialogprinzipien" an diesem Tag erneut verstärkt Zeit gewidmet. Dazu habe ich in meinem letzten Blogbeitrag aber schon ausführlich etwas geschrieben.

Ein weiteres Thema waren verschiedene Gestaltungsrichtlinien, sogenannte "Styleguides" oder "Design Patterns". Hierbei handelt es sich um Vorgaben, wie z.B. ein Button, eine Tabelle oder der gesamte Checkout Vorgang in einer Webseite (das wäre ein Design Pattern) aussehen sollte. Die meisten großen Hersteller von Software bieten so etwas übrigens an. Auf der Homepage unseres Trainingsanbieters findet ihr dazu einer super Übersicht.

Nach einer kurzen Exkursion zur Gestaltung verschiedener Prototypen (z.B. Papierskizze, Storyboard, Wireframe, etc.) ging es zum Ende hin dann zum großen Thema "Evaluierung der Designlösungen", also dem Test der Prototypen. Diesem Kapitel, das unter anderem Fokusgruppen, Benutzerbefragungen und Usability Tests beinhaltet, werde ich mich aber aufgrund des Umfangs in einem gesonderten Blogbeitrag widmen.

Wir schlossen den Tag mit einer Übersicht über die verschiedenen Rollen im Usability Engineering Prozess, ein paar Übungsaufgaben und einem prall gefüllten Kopf für den morgigen Prüfungstag.

Tag 3 - Prüfung zur Zertifizierung zum "UXQB® Certified Professional for Usability and User Experience – Foundation Level (CPUX-F)"

Den Vormittag und den ersten Teil des Nachmittags wendeten wir am Mittwoch zur Aufarbeitung der Inhalte zum Überprüfen der Gestaltungslösungen (also Usability Testing und co.) auf. 

Am Nachmittag wurde es dann spannend. Die Prüfung stand an. Dazu folgende Rahmenbedingungen.

• 40 Fragen
  • Zum Bestehen müssen 28 von 40 Punkten erreicht werden (70%)
• 75 Minuten
• Keine Hilfsmittel erlaubt
• Jede Frage hat 6 Antwortmöglichkeiten, bei denen eine "signifikant richtiger" ist als die anderen
  • Gibt es nur eine richtige Antwort, gibt es einen Punkt für eine richtige und null Punkte für eine falsche Antwort
• Manche Fragen haben 2 oder 3 "signifikant richtigere" Antworten, wenn dies der Fall ist, geht es aber aus der Aufgabe deutlich hervor
  • Gibt es mehrere richtige Antwortmöglichkeiten, gibt es für jede richtige Antwort 1/AnzahlMöglichkeiten Punkte. Für jede falsche Antwort gibt es 1/AnzahlMöglichkeiten Punkte Abzug. Die Gesamtpunktzahl kann aber nie negativ sein.

Die Fragen wurden, soweit ich das beurteilen kann allesamt durch die Übungen und Beispiele im Training im Vorfeld abgedeckt. So habe ich es dann auch geschafft, stolze 87,50% zu erreichen. Die Schwierigkeit der Fragen war allerdings stark gemischt. So gab es von relativ einfachen Fragen wie "Bei welchen der folgenden Begriffe handelt es sich um Dialogprinzipien?", wo die Lösung einfach aufgrund der Namen recht simpel war bis hin zu sehr schwierigen Fragen, wo mehrere Lösungen tatsächlich richtig waren, aber eine eben ein "Stückchen richtiger" als die anderen eine große Durchmischung. Da ging es z.B. um eine Fehlermeldung in Form eines Fehlercodes nach einer Datumseingabe in einer Webseite und einen Vorschlag zur Verbesserung. Gegeben waren von der ausführlicheren Fehlermeldung hin zum "Tutorial" verschiedene Möglichkeiten. Die richtige war jedoch, die Datumseingabe durch eine Datumsauswahl zu ersetzen, um Tippfehler, die erst validiert werden müssen überflüssig zu machen. So einfach kann's gehen.

Alles in allem machbar, aber knackig.

Fazit

Meiner Meinung nach waren das drei sehr gelungene Tage und wohl investiertes Geld. Geld heißt hier 1.500€ zzgl. MwSt. für das Training und 300€ zzgl. MwSt. für die Prüfung. Eine Rückerstattung bei Nicht Bestehen gibt es hier selbstverständlich nicht.

Obwohl die Möglichkeit besteht, sich extern auf die Prüfung vorzubereiten und die Unterlagen dafür im Internet frei verfügbar sind, halte ich ein vorbereitendes Training für sehr wertvoll, um das Wissen im Kontext richtig einordnen zu können. Darüberhinaus hat man durch den Kontakt mit anderen Teilnehmern die Möglichkeit, sich über Praxiswissen und echte Anwendungsfälle direkt austauschen zu können, was in der Gruppe sehr wichtig war.

Ich gucke heute noch regelmäßig in meine Schulungsmappe und das im Training bzw. für die Prüfung erworbene Seminar hilft mir tatsächlich, im Alltag bessere Entscheidungen zu treffen, wenn es um Produkt- oder Prozessgestaltung geht. Und da ist egal, ob es sich um digitale Produkte handelt oder "welche zum Anfassen".

Wenn ihr Fragen habt, zögert nicht, hier zu kommentieren oder mir zu schreiben.

Gruß, euer "devopsdad" Patrick

Anschließend gebe ich einige Tipps, extrahiert aus eigenen Erfahrungen, wodurch Bewerber um einen Praktikumsplatz, aber auch um einen Ausbildungsplatz negativ aufgefallen sind.

Beachtet bitte auch hier: Dies stellt nur einen Leitfaden aus Erfahrungen dar, der euch keinen Erfolg garantiert, aber es euch hoffentlich ein gutes Stück leichter macht euer Praktikum und damit eure Umschulung erfolgreich zu absolvieren

Die Suche nach passenden Betrieben:

Viele Umschüler unterschätzen die Suche nach einem geeigneten Praktikum gewaltig, geraten unter Zeitdruck und müssen dann jedes Angebot annehmen, ob es ihnen nun zu ihnen passt oder nicht. Wer in solch eine Situation kommt, verliert den Einfluss darauf eine praktische Ausbildung zu erhalten, die zu den zukünftigen Karriereplänen passt. Ihr solltet euch daher bereits 5-8 Monate vor dem Praktikumsstart um einen Praktikumsplatz kümmern

Zuerst solltet Ihr eine Liste von potenziellen Praktikumsbetrieben erstellen. Voraussetzung hierfür ist normalerweise, dass dieser Betrieb in dem Beruf bereits ausbildet und auch in der Lage ist einen Praktikanten zu beschäftigen. Solche Firmen könnt Ihr über Eure IHK, diverse Lehrstellenbörsen oder Praktikumssuchmaschinen finden. Universitäten, Hochschulen und wissenschaftliche Institute bilden inzwischen auch oft aus und nehmen auch immer mal wieder Praktikanten aller Fachrichtungen.

Einer der sichersten und besten Möglichkeiten solche Firmen zu finden ist übrigens ein guter Umgang mit euren Mitumschülern der vorangegangenen Semester. Diese haben entweder bereits ein Praktikum hinter sich gebracht und können euch auch eine gute Einschätzung der dortigen Verhältnisse geben oder starten demnächst in ein Praktikum und haben dort dann bereits eine Zusage. Es lohnt sich hier eine weitere Liste anzulegen und alle diese Firmen separat zu sammeln. Eventuell mit einer kurzen Einschätzung der bisherigen Praktikanten. Frag doch auch einmal bei euren Dozenten nach, in welchen Firmen eure Vorgänger so waren. Gerade der Dozent, der für die Vorbereitung auf die Präsentationen zuständig ist, wird in den Übungen wohl den Namen des jeweiligen Praktikumsbetriebs mehrfach hören und sehen.

Beim Anlegen Eurer Adressenliste solltet ihr darauf achten, wenn möglich, E-Mail-Adressen und Ansprechpartner mit zu erfassen. Wenn ihr so vorgeht, könnt ihr in wenigen Stunden eine beachtliche Liste von 50 – 500 Adressen zusammentragen. Ich rate euch zudem die Adressen an den Anfang zu stellen, von denen ihr wisst, dass sie bereits Praktikanten genommen haben.

Auch solltet ihr hier bedenken, dass die meisten Firmen einfach keine Ressourcen für einen Umschüler haben, selbst wenn sie ausbilden. Hier kann bereits die zuständige IHK eine Grenze gesetzt haben. Die hiesige IHK sagt hierzu es sollte mindestens eine ausgebildete Fachkraft pro Azubi oder Umschüler vorhanden sein und einer der Fachkräfte muss zusätzlich Ausbilder im Betrieb sein. Ausnahmen bestätigen hier, wie immer, die Regel und letztendlich entscheidet eure IHK.

 Es kann daher sehr wohl vorkommen, dass ihr 40 Bewerbungen fertigmacht und 40 Absagen bekommt die nur der einfachen Tatsache geschuldet sind, dass es keine solche Stelle im Unternehmen gibt. Davon erfahrt ihr natürlich nichts und der Frust ist groß, da man sich die Mühe gemacht hat 40 Bewerbungen und Anschreiben anzupassen.  Um euch eine Menge Arbeit und Frust zu ersparen, rate ich euch die Bewerbungen in 2 Schritten anzugehen.

Statt jeder Adresse eine angepasste Bewerbung zukommen zu lassen, könnt ihr im 1. Schritt einen kleinen Text verfassen, indem ihr erklärt für welchen Zeitraum, warum und für welchen Beruf ihr einen Praktikumsplatz sucht. Und bei Interesse werdet ihr ihnen gerne eure kompletten Bewerbungsunterlagen zusenden. In dem Text könntet ihr beispielsweise ebenfalls unterbringen, dass ihr während des Praktikums über den Bildungsträger versichert seid, dieses Praktikum als Ausbildungspraktikum gilt und daher auch nicht unter das Mindestlohngesetz fällt und die Firma aufgrund anderweitiger Förderung auch ansonsten zu keinem finanziellen Ausgleich verpflichtet wäre. Diesen Text sendet ihr dann an alle Empfänger aus eurer Adressliste.

Ihr könnt dies übrigens auch gleich als Übung für eure Skriptkünste nutzen und ein kleines Skript schreiben, mit dem aus eurer Liste die Ansprechpartner und Mailadressen ausgelesen und passend in der Mail eingetragen werden.  Es gibt auch eine einfache Möglichkeit über Thunderbird mithilfe von Addons Mails zu personalisieren.

Alternativ könnt ihr die Liste natürlich auch einfach telefonisch durchgehen. Ihr erhaltet in so einem Fall die Antwort schneller und der Ansprechpartner bekommt einen ersten persönlichen Eindruck von euch. Andererseits kommt es auch sehr oft vor, dass ihr den Anprechpartner telefonisch nicht erreichen werdet. Dies kann ziemlich schnell frustrieren.

Wenn nun eine positive Antwort eintrifft, verfasst ihr im 2. Schritt eine persönliche und auf das Unternehmen zurechtgeschnittene Bewerbungen

Die Bewerbung

Als Ausbilder habe ich eine Menge Bewerbungen von Azubis und später von Umschülern auf der Suche nach einem Praktikum gelesen. Daher hier ein paar Ratschläge daraus:

Achtet darauf eine vernünftige E-Mailadresse zu verwenden. Mailadressen ohne Namensbezug oder Mails von der Domain einer anderen Firma machen oft einen schlechten ersten Eindruck. Legt euch lieber eine kostenlose Adresse an, die ihr nur für Bewerbungen benutzt. Signaturen mit witzigen Sprüchen oder der eigenen Firma haben in solchen Mails nichts zu suchen. Einige kostenlose E-Mailanbietern binden nach dem Versenden ihre eigene Werbesignatur in die Mail ein. Dies könnt ihr meist verhindern, indem ihr einen E-Mail-Client wie z.B. Thunderbird oder Outlook benutzt, anstatt der Weboberfläche. Ihr solltet euch erst einmal selber eine Mail senden, um zu sehen wie die Mail beim Empfänger ankommt.

Bitte legt euch auf einem Dateityp fest. Es hinterlässt einen schlechten Nachgeschmack beim Empfänger, wenn ihr ein Sammelsurium an diversen Dateiformaten versendet, für die er mehrere Programme benötigt oder die er eventuell gar nicht lesen kann ohne ein weiteres Programm zu installieren. Bedenkt dabei, ein Personaler hat eventuell nur ein modernes Microsoft Word installiert und kann im schlimmsten Fall eure Bewerbung als .doc oder .odt überhaupt nicht öffnen. Vorzugsweise schickt ihr eine einzelne Pfd. Dies wird jeder Ansprechpartner öffnen können und es sieht immer gleich aus.

Danach heißt es warten auf eine positive Antwort und auf den Start des Praktikums.

Ich möchte mich hier zuerst mit dem Thema „Praktikum während der Umschulung“ befassen.  Hierbei fließen einmal meine eigenen Erfahrungen ein, da ich beide Seiten des Prozesses kenne. Ich habe dieses Praktikum und seine Phasen zuerst als Umschüler und später mehrfach als Ausbilder durchlaufen.  Zusätzlich habe ich mich für diesen Artikel mit einigen weiteren ehemaligen Umschülern ausgetauscht. Einige davon haben ähnlich positive Erfahrungen gemacht und arbeiten seitdem durchgehend in der IT. Andere wiederum versuchen seit Jahren erfolglos in der IT Fuß zu fassen.

Dabei zeichnete sich bereits ein Muster ab, zwischen der grundsätzlichen Einstellung zur Umschulung, dem Praktikum, dem daraus resultierenden Verhalten und einer anschließenden positiven Karriere.

Ich habe daraus einen kleinen Leitfaden entwickelt, der euch zwar keinen Erfolg garantiert, aber es euch ein gutes Stück leichter machen sollte euer Praktikum und damit eure Umschulung erfolgreich zu absolvieren. Ich habe diesen Leitfaden in verschiedene Teile unterteilt. Das erste Thema betrifft die Praktikumssuche und wurde vom mir in 2 Teile unterteilt.

 1. Teil Praktikumssuche:

Grundsätzliches

Ein Praktikant während einer Umschulung muss zwar nicht von dem Praktikumsunternehmen bezahlt werden, kostet diesen Betrieb jedoch trotzdem Geld und bindet bezahlte Fachkräfte, die sich um den Umschüler kümmern, diesen beaufsichtigen und kontrollieren müssen. Im Normalfall ist es so, dass Praktikanten, nicht oder sehr selten produktiv eingesetzt werden können.  Dazu kommen Kosten für die Bereitstellung eines Arbeitsplatzes, Arbeitsmaterialien, Soft- und Hardware inklusive Lizenzen sowie eventueller Arbeitskleidung.

Ein Unternehmen muss auch beim Einsatz eines Praktikanten das ökonomische und das erwerbswirtschaftliche Prinzip beachten. Dieser Umstand wird gerne von Umschülern und gelegentlich auch von Firmen übersehen.

Einige IT-Firmen haben nicht bewusst vor einen Umschüler als Praktikanten zu nehmen oder wissen über diese Möglichkeit nicht Bescheid.  Es lohnt sich also eventuell seinen Wunschbetreib davon zu überzeugen. Es ist auch nicht unbedingt in jedem Fall nötig, dass der Betrieb bereits ausbildet. Selbst wenn dort noch kein ADA-Schein vorhanden ist, so ist dies noch kein endgültiger  Grund aufzugeben.

In meinem Fall hat der IT-Teamleiter, in Absprache mit der IHK, erst zum Ende meines Praktikums seinen Ada- Schein erworben und das Institut bildet nun schon mehrere Jahre erfolgreich aus. Zusätzlich nimmt das Institut seitdem auch regelmäßig Umschüler als Praktikanten.

Unternehmen, die einen Umschüler als Praktikanten aufnehmen, lassen sich, unserer Erfahrung nach, hinsichtlich Ihrer Motivation meist in 3 grobe Bereiche einteilen:

In der  1. Gruppe sind die Firmen zu finden, die über die Praktikanten zukünftige Mitarbeiter suchen. Diese Firmen nutzen solche Praktika um einen potenziellen zukünftigen Mitarbeiter über eine längere Zeitspanne in der eigenen Produktivumgebung einzuarbeiten. Unternehmen dieser Gruppe übernehmen einen guten Praktikanten nach Ende seiner Umschulung für gewöhnlich. In dieser Gruppe befinden sich erfahrungsgemäß eher mehr mittelständische und große Unternehmen als kleine Firmen.

Die 2. Gruppe von Unternehmen sieht es als ihre Pflicht an, ihren Teil zu Ausbildung und Weiterbildung, inklusive Umschulung, zu leisten. Diese Unternehmen wollen den Umschüler zwar möglich gut ausbilden, haben aber keine Intention diesen später zu übernehmen. Hier finden sich besonders häufig Institutionen wieder, die sowieso bereits im Bereich Lehre sowie der Vermittlung und Schaffung von Wissen tätig sind, wie z.B. Universitäten, Hochschulen und wissenschaftliche Institute.

Die 3. Gruppe setzt sich aus Firmen zusammen, die in dem Praktikanten nur eine billige Arbeitskraft sehen und diesen auch so einsetzen. Diese Unternehmen sind meist kleine, inhabergeführte Firmen, die u.a. dadurch auffallen, dass sie versuchen mehrere Praktikanten auf einmal zu nehmen und die Praktikanten ohne Einarbeitungszeit oder Ansprechpartner produktiv eingesetzt werden. Diese Unternehmen haben weder ein Interesse daran den Umschüler später einzustellen, noch diesen aktiv auszubilden.  Da die Umschüler aber zu diesem Zeitpunkt noch keine ausgebildeten Fachkräfte sind und eigentlich in solch einem Praktikum das praktische Handwerkszeug erlernen sollen, kommt es oft irgendwann innerhalb der Praktikumszeiten zu Vorwürfen, der Praktikant würde nicht die nötigen Fachkenntnisse besitzen und sich nicht genug einbringen. Gelegentlich landen diese Firmen und der Umschüler dann im Streit um Arbeitszeugnisse oder Verleumdung gar vor Gericht. Mir ist übrigens bisher noch kein Fall zu Ohren gekommen, bei dem die Firma in solch einem Fall gewonnen hat.

Soweit zu Teil 1 des Themas Praktikumssuche. Im 2. Teil werde ich mich mit der Suche nach passenden Betrieben beschäftigen und einige kleinere Anmerkungen zu eigentlichen Bewerbung machen.

Jetzt gab es eine ganze Weile lang keine neuen Inhalte hier aber inspiriert durch einen interessanten Thread im Fachinformatiker.de-Forum habe ich mich entschlossen, einen Beitrag zu einem allgemein gültigen Thema zu schreiben, das mir seit einer Weile sehr am Herzen liegt.

Den 7 Dialogprinzipien - Intro

Die 7 Dialogprinzipien, in ISO 9241-110 als "Grundsätze der Dialoggestaltung" beschrieben, beschreiben, wie Nutzer mit interaktiven Systemen interagieren und welche Prinzipien dieser Interaktion allgemein zu Grunde liegen.

Sie können positiv besetzt und erfüllt werden, oder verletzt. Werden sie verletzt, entstehen "Nutzungsfehler".

 Nicht so, Eierlegende Wollmilchsau, CC-BY-SA 2.5, Autor: Georg Mittendecker, Entnommen aus: https://commons.wikimedia.org/wiki/File:Wollmilchsau.jpg

Wichtig ist hier die feine Unterscheidung der Begrifflichkeiten. Ich spreche von "Nutzungsfehlern" nicht von "Nutzerfehlern". Interaktive Systeme, deren Benutzungsschnittstellen(User Interfaces) so gebaut sind, dass sie zum Nutzungskontext der angepeilten Benutzergruppe passen, sind wesentlich weniger fehleranfällig als Systeme, die versuchen, die eierlegende Wollmilchsau für "alle Benutzer jemals" zu sein. Eine nicht vollständige oder fehlerhafte Benutzergruppenanalyse ist einer der Hauptgründe für viele Usability-Probleme und unzufriedene Benutzer.

Aber genug Einführung. Hier kommen sie.

Die 7 Dialogprinzipien - Übersicht

Vorweg: Die Großzahl auftretender Nutzungsfehler entsteht aus Verletzungen der ersten 3 hier genannten Dialogprinzipien.

Zur Illustrierung der Dialogprinzipien halten wir uns an die folgende Aufgabe: "Einen Mietwagen buchen".

Aufgabenangemessenheit

Ein interaktives System ist aufgabenangemessen, wenn es den Benutzer unterstützt, seine Arbeitsaufgabe zu erledigen, d. h., wenn Funktionalität und Dialog auf den charakteristischen Eigenschaften der Arbeitsaufgabe basieren, anstatt auf der zur Aufgabenerledigung eingesetzten Technologie. Es kommen keine unnötigen oder nicht zur Lösung der Aufgabe benötigten Schritte vor.

Standort-Buchung hertz.de, Screenshot, aufgenommen am 13.07.2017

Beispiel: Wenn ich bei hertz.de als Standort "Kassel" auswähle, kann ich die Standortgruppe "Kassel DE (4 locations)" anwählen. Erst wenn ich alle anderen Eingaben getätigt habe und im Formular weitergehen möchte, muss ich einen spezifischen Standort auswählen. Ein unnötiger Schritt, den man direkt im ersten Formular bearbeiten können sollte.

Selbstbeschreibungsfähigkeit

Ein Dialog ist in dem Maße selbstbeschreibungsfähig, in dem für den Benutzer zu jeder Zeit offensichtlich ist, in welchem Dialog, an welcher Stelle im Dialog er sich befindet, welche Handlungen unternommen werden können und wie diese ausgeführt werden können.

Beispiel: In einem weißen Suchfeld zur Fahrzeugsuche steht neben einer Lupe der Text "Hier können Sie durch Texteingabe Fahrzeugtypen suchen"

Erwartungskonformität

Ein Dialog ist erwartungskonform, wenn er den aus dem Nutzungskontext heraus vorhersehbaren Benutzerbelangen sowie allgemein anerkannten Konventionen entspricht.

Beispiel: Ein Klick auf ein kleines Kalender-Icon in einem Auswahlbereich zur Abholung des Fahrzeugs öffnet ein Datepicker-Steuerelement.

Erlernbarkeit / Lernförderlichkeit

Ein Dialog ist lernförderlich, wenn er den Benutzer beim Erlernen der Nutzung des interaktiven Systems unterstützt und anleitet.

Beispiel: Wenn erkannt wird, dass der Benutzer die Webseite zum ersten mal besucht, wird er durch ein Assistenzprogramm und verschiedene Highlights durch den Buchungsprozess geleitet. (Abdunkeln von zum momentanen Zeitpunkt nicht benötigten Steuerelementen) 

Steuerbarkeit

Ein Dialog ist steuerbar, wenn der Benutzer in der Lage ist, den Dialogablauf zu starten sowie seine Richtung und Geschwindigkeit zu beeinflussen, bis das Ziel erreicht ist.

Negativbeispiel: Eine fehlerhafte Eingabe in einem Kontaktformular führt dazu, dass der Nutzer das gesamte Formular erneut ausfüllen muss, anstatt an den Punkt zu springen, in dem die Falscheingabe liegt.

Fehlertoleranz

Ein Dialog ist fehlertolerant, wenn das beabsichtigte Arbeitsergebnis trotz erkennbar fehlerhafter Eingaben entweder mit keinem oder mit minimalem Korrekturaufwand seitens des Benutzers erreicht werden kann.

Beispiel 1: Der Benutzer gibt im Texteingabefeld das Datum "23.12.2017" ein. Das System gibt einen Fehler aus und weist ihn darauf hin, dass das Datumsformat dem folgenden Schema genügen muss. "MM-DD-YYYY". Noch besser wäre hier allerdings, statt einer Benutzereingabe eine Auswahl durch z.B. ein Datepicker-Element zu ermöglichen.Beispiel 2: Der Benutzer gibt eine E-Mail Adresse im falschen Format  an und erhält eine Fehlermeldung, die als Beispiel ein korrektes Format anzeigt.

Individualisierbarkeit

Ein Dialog ist individualisierbar, wenn Benutzer die Mensch-System-Interaktion und die Darstellung von Informationen ändern können, um diese an ihre individuellen Fähigkeiten und Bedürfnisse anzupassen.

Beispiel 1: Ein Benutzer kann dauerhaft speichern, in welchem Format Zahlen und in welcher Sprache Texte in einer Anwendung dargestellt werden sollen.Beispiel 2: Ein Benutzer hat die Möglichkeit, ein Benutzerkonto anzulegen und dort Informationen zu speichern, die er beim nächsten Lösen der Aufgabe nicht mehr manuell eingeben muss.

Die 7 Dialogprinzipien - Fazit

So viel zu merken ist es eigentlich gar nicht. Und wenn man die ersten 3 Prinzipien verinnerlicht hat und weiß, worauf es beim Entwickeln von Benutzungsschnittstellen ankommt, kann man das Fehlerpotential seiner interaktiven Systeme drastisch senken.

In diesem Sinne, viel Spaß beim Überarbeiten und Entschuldigung im Voraus für all die Verletzungen der Dialogprinzipien, die ihr nach dem Lesen dieses Beitrags wahrnehmen werdet.

Gruß, euer "devopsdad" Patrick

1. Dokumentation
2. Versionierung

Dies liegt vor allem daran, dass man am Anfang des Skriptens viel Spaß am Experimentieren hat und bestimmt auch viel im Code springt oder ein paar Skripte parallel schreibt. Da kommt einem am Anfang gar nicht der Gedanke, dass man ja doch recht häufig speichert, aber immer unter dem gleichen Dateinamen. Vielleicht ab und zu mal eine -test oder eine-2 dranhängt. Aber mit einer ordentlichen Versionierung hat das eher nichts zu tun.

Dokumentation/Kommentierung

Bei mir hat sich bewährt, dass ich am Anfang eines Skriptes erst einmal als Kommentar das Ziel des Skriptes definiere. Dieser kann sich ja immer wieder verändern, aber später spart man sich auch diese Arbeit, wenn man das Skript einmal in andere Hände geben möchte, denn dann gehört so ein Text einfach dazu.

Wenn ihr Funktionen schreibt, dann sollten folgende Punkte aufgeführt sein:

• SYNOPSIS
  • Hier sollte in 1-2 Sätzen die Bestimmung der Funktion stehen
• DESCRIPTION
  • Eine ausführlichere Beschreibung was diese Funktion macht
• PARAMETER param1
  • Beschreibung des param1
• PARAMETER param2
  • Beschreibung des param2
• Notes
  • Zusätzliche Notizen
• LINK
  • Zugehörige URLs
  • Die erste URL wird aufgerufen wenn das CDMlet Get-Help -Online <Funktionsname> aufgerufen wird
• INPUTS
  • Typen der Datenübergabe die erlaubt sind
• OUTPUTS
  • Typen der Datenausgabe die von dieser Funktion ausgegeben werden können

Funktionen benennen

Bei der Wahl des Funktionsnamens sollte man sich an die offizielle Nomenklatur halten. Das bedeutet, dass der Name mit einem Verb und einem Substantiv durch ein "-" getrennt aufgebaut sein sollte. Get-Verb gibt euch eine offizielle Liste der Verben und in welchem Kontext diese stehen.

Wenn ihr allerdings eine Funktion nur für euch schreibt die nur lokal eingesetzt wird, schreibt vor den Funktionsnamen "private:" oder „script:“

Versionierung

Beim Versionieren habe ich früher bei größeren Änderungen einfach den Versionszähler hochgesetzt und nebenbei eine Liste der Änderungen in einem Onenote Dokument gepflegt.

Ihr könnt natürlich auch die Änderungen in einem Textdokument oder direkt im Skript kommentieren.

Auch hier bieten die ISESteroids wieder eine sehr komfortable Lösung des Versionierens.

Der Pfeil im Bild zeigt euch, wie ihr den Reiter der Versionierung aufrufen könnt. Auf der rechten Seite seht ihr Die File Version History. Links ein Button „Ad New Version“ und auf der rechten Seite eine Checkbox „Auto Mode“. Wenn bei Auto Mode der Haken gesetzt ist, wird automatisch eine neue Version angelegt sobald man Änderungen durchgeführt hat und darauf folgend speichert.

In dem Reiter der einzelnen Versionen seht ihr links eine Klassifikationsmöglichkeit, wie zum Beispiel Stable, Alpha Release und weitere. Über den Knopf Compare öffnet sich das Programm WinMerge und zeigt die Veränderungen zur Vorgängerversion. Hier nutze ich den Button Notes um, wie der Name schon sagt, mir Notizen zu den Versionsunterschieden zu kommentieren.

Falls ihr noch Anregungen, Fragen oder Hinweise habt, gerne her damit.

Meine Erfahrungen im Umgang und dem ein oder anderen Tool.

Ich bin ein Freund der Powershell geworden, da man mit dieser Scripting Engine viele sich wiederholende Aufgaben schnell und vor allem dann auch fehlerfrei immer wieder erledigen kann. Sei es ein Passwort nach bestimmten Kriterien automatisiert erstellen, dem AD Account hinzufügen, das Flag für "Bei der nächsten Anmeldung Passwort ändern" setzen und einen vorgefertigten Passwortbrief ausdrucken. Oder Gruppenmitgliedschaften zwischen zwei AD Accounts übertragen. Alles was über viel Klickerei zu erreichen ist, kann man durch die Powershell eleganter lösen.

Im Grunde genommen bin ich nun so weit, dass ich alles, was ich auf Dateiebene oder im Bereich AD oder Exchange mehr als zwei Mal mache, versuche in der Powershell zu lösen. Im besten Fall wiederhole ich irgendwann noch einmal die Tätigkeit, oder führe eine ähnliche aus und muss das Skript nur ein wenig anpassen, oder im schlechtesten Fall habe ich wieder ein wenig mehr Übung im Skripten und das hilft natürlich bei den kommenden Aufgaben.

Erstmal ein paar allgemeine Überlegungen

ISE - Integrated Scripting Environment oder nicht ISE (Konsole) - das ist hier die Frage

Es gibt für mich keinen Grund der Konsole den Vorzug zu geben.

Hier ein paar Gründe:

• Kopieren und Einfügen
  • Dies ist in der Konsole nur mit der Maus und nicht mit Tastaturbefehlen möglich
  • Bei mehrzeiligen Befehlen werden der Prompt und der Zeilenumbruch mit kopiert
• Ich kann durch das Kopieren und Einfügen der gleichen Zeile untereinander mit anschließenden editieren der einzelnen Zeilen mehrere ähnliche Syntax erstellen und dann einzeln testen und somit gut experimentieren
• Wenn ich bemerke, dass eine lange gepipte Verkettung von Befehlen zu komplex wird, kann ich diese recht einfach wieder zerpflücken und in z.B. eine Funktion wandeln
• IntelliSense
  • Autovervollständigen mit einem kleinen Fenster neben dem Cursor
  • In der Konsole nur CMDlets und Parameter mit Tab durchschaltbar
• Einfärbung der Codeelemente erhöht die Übersichtlichkeit
  • Tippfehler werden schneller erkannt
• Befehls Add-on Reiter
  • Ermöglicht schnellere und einfache Erstellung eines CMDlets mit den benötigten Parametern

Add-Ons

Ein sehr schönes CMDlet ist für die Arbeit im AD ist NTFSAccess.

https://blogs.technet.microsoft.com/heyscriptingguy/2014/11/22/weekend-scripter-use-powershell-to-get-add-and-remove-ntfs-permissions/

ist von The Scripting Guys

Bei den Downloads die man aus dem Internet lädt, müsst ihr daran denken, vor dem kopieren, ausführen etc. die Eigenschaften des Downloads aufzurufen und ganz unten im allgemeinen Reiter bei dem Punkt Sicherheit den Button "Zulassen" zu drücken.

Ein besonderes Bonbon sind die Powershell ISESteroids von Powertheshell.com

Eins vorweg, die ISESteroids sind nicht kostenlos. Preise findet ihr auf Dr. Tobias Weltners Webseite http://www.powertheshell.com/isesteroids2-2/ordering-isesteroids/

Dr. Tobias Weltner ist ein Experte aus dem Team von IT-Visions (Dr. Holger Schwichtenberg). Dr, Schwichtenberg ist durch zahlreiche Publikationen, auch rund um die Powershell, bekannt. Es lohnt sich auf jeden Fall eins seiner Bücher zur Hand zu haben, sobald man mit der Powershell anfängt zu Skripten.

Aber nun zurück zu den Steroiden.

Um diese immer beim Start zu laden, müssen diese in die Profildatei geladen werden. Diese findet ihr unter dem Userverzeichnis\Dokumente\WindowsPowershell. Hier ändere ich noch die Farbe der Fehleranzeige von dem Blau in Weiß, da dies generell besser lesbar ist. Das macht ihr mit dem Eintrag (get-host).PrivateData.errorbackgroundcolor = "White"

Oder, sofern ihr die Steroids mit start-steroids schon geladen habt über die neue Leiste aufrufen.

Was die Steroids für mich mittlerweile unverzichtbar machen sind

• Gaaaanz wichtig Eine Versionierung
• Einen Simulationsmode - hier muss man nicht nach jeder ausführbaren Zeile ein -Whatif kommen
• Die Möglichkeit aus dem Skript eine eigenständig laufende EXE zu machen
• Der Variablen Explorer - Dieser zeigt alle verfügbaren Variablen und deren Inhalt an
• Win Merge File Compare - Ist im Zusammenarbeit mit der Versioncontrol einfach gut um Unterschiede in den Skripten zu finden
• PSShaper - Zeigt was in dem Skript nicht den "best practice" entspricht

Schon während des Skriptens erscheinen zahlreiche Hinweise, wenn man dabei ist einen Bock zu schießen und geben einem Möglichkeiten vor es zu verbessern. Diese Möglichkeiten werden dann bei Wunsch auch direkt umgesetzt,

Wenn man eine Klammer, egal welcher Art auch immer öffnet, erscheint gleich auch das entsprechende Gegenstück. Wem ging es noch nie so, dass man später die Klammern zählt und sucht ;-)

Ein paar Zeilen Code geschrieben und dann gedacht...das wäre auch eine gute Funktion. Hier ist nach dem Markieren des Codes mit einem Rechtsklick sofort alles erledigt sobald man sich für einen Namen für die Funktion entschieden hat und welche Variablen als Parameter übergeben werden sollen.

Vorher

Nachher

Durch einen weiteren Klick auf einem Knopf wird diese Funktion in ein Modul geschrieben oder einem Modul hinzugefügt.

Dies nur mal als einen kleinen Appetizer. In den kommenden Blogeinträgen kommt zu den Steroids bestimmt noch mehr.

auch ich möchte mich hier eben kurz vorstellen.

Ich bin der Marcel, 39 Jahre alt, verheiratet und komme aus Langenhagen bei Hannover.

Ich bin gelernter KFZ-Mechaniker und habe 2002, während meiner 12-jährigen Bundeswehrzeit, meinen KFZ-Meister im FBZ Garbsen absolviert. Zum Ende meiner Dienstzeit im Jahr 2008 entschied ich mich dann dazu, im Rahmen der Berufsförderung eine IHK-Ausbildung zum IT Administrator durchzuführen. Diese absolvierte ich an einer Privatschule in Hannover.

Ich arbeite mittlerweile seit 2011 als IT Administrator Fachrichtung Netzwerktechnik in einem sehr großen Konzern mit Hauptsitz in Wolfsburg, wobei ich aber in einem Werk in Hannover tätig bin. Hier verwalte ich mehrere hundert Router, Switches etc.

Ihr fragt euch nun evtl., was ich hier auf Fachinformatiker.de suche. Nun, ich suche eigentlich nichts sondern möchte viel eher helfen.

Während meiner gesamten beruflichen Laufbahn war ich, egal in welchem Bereich ich tätig war, immer viel mit dem Bereich Aus- und Weiterbildung beschäftigt. Sei es das Ausbilden von Lehrlingen selbst oder natürlich die eigenen Ausbildungen. Ich vermute mal das ich mittlerweile so eine Art Helfersyndrom entwickelt habe J.

Ich vertrete den Grundsatz: „Man hat erst ausgelernt, wenn alle Finger gleich lang sind“.

Während meiner IHK-Ausbildungszeit habe ich sogar ein Bildungsportal gegründet, welches ich dann aber mangels Zeit wieder auf Eis gelegt habe.

Mittlerweile habe ich es mir zum Hobby gemacht, kleine Videos zu bestimmten Themen zu erstellen. Hierbei setze ich den Focus auf Videos zum Thema Netzwerktechnik und genau hier möchte ich anknüpfen. 

Ich könnte mir gut vorstellen, dass FiSi oder ähnliche Ausbildungszweige vermehrt auf Videoinformation setzen. Natürlich sind Bücher und das darin enthaltene Wissen dem nicht gleichzusetzen, allerdings ist bekannt, dass das Lernen umso leichter fällt, je mehr Sinne angesprochen werden und Lehrvideos durchaus einen Beitrag zum besseren Verständnis liefern können. Ich möchte mein Wissen durch diese Art, auch wenn es vielleicht nicht so detailliert wie in den erwähnten Nachschlagewerken geschieht, weitergeben. Bisher habe ich zu meinen Videos sehr gute Rückmeldung in Sachen Verständlichkeit erhalten.

Nun schließt sich der Kreis. Ich werde hier also einen Videoblog starten. In diesem werde ich bereits gedrehte Videos zeigen, versuchen Fragen zu beantworten und natürlich auf Themenwünsche eingehen.

In diesem Sinne, danke für die Aufnahme und auf gutes Gelingen,

Euer Marcel.

Da dies mein erster Blog ist möchte ich mich kurz vorstellen: Ich bin Tician, 26 Jahre jung und im 2. Ausbildungsjahr zur Systemintegration (Stand 2017). Privat bin ich im Malware-Bereich aktiv - ich helfe Menschen bei der Bereinigung - und ich zocke gerne

Mein Ziel ist es alles so anfängerfreundlich wie möglich zu schreiben. Es soll also auch jemand verstehen der sich am Anfang der Ausbildung befindet und noch keine bis wenig Erfahrungenen hat.

Legen wir los!

Was ist die Registry?

Die Meisten haben vermutlich schon davon gehört, aber vielleicht noch nie damit zu tun gehabt - und genau so sollte es auch sein, denn die Registry ist seit Windows NT ein fester, sehr wichtiger und empfindlicher Bestandteil von Windows. Sämtliche Einstellungen von Windows (und den meisten installierten Programmen) werden dort gespeichert.

Einstellungen? Welche Einstellungen denn zum Beispiel?

Welche Dienste sind auf auto-start gestellt? Welches Hintergrundbild benutze ich für meinen Desktop? Ist die Firewall an oder aus? Werden die Windows-Updates automatisch gemacht oder sind sie deaktiviert? Welches Programm soll benutzt werden wenn ich eine *.txt Datei öffnen möchte (Editor, Notepad++ oder doch etwas ganz anderes)? Das und vieles mehr sind Beispiele die in der Registry zu finden sind.

Kommen wir auch kurz zu einem anderen Beispiel: Gruppenrichtlinien! Was passiert wenn wir auf vielen PCs Einstellungen setzen möchten ohne an jeden PC einzeln zu rennen (z.B. wollen wir nicht das Benutzer die Registry verändern dürfen )? Wir benutzen Gruppenrichtlinien und die (meisten) machen auch nichts anderes als Registry-Einträge zu verändern.

Wo ist die Registry?

Jetzt wird es interessant. Die Registry lässt sich durch ein Windows-eigenes Tool öffnen. In unserem Fall die Regedit.exe die sich (wie manch andere Windows-Tools) standardmäßig unter C:\Windows befindet. Jetzt ist uns das aber zu mühselig jedesmal dort hin zu navigieren (das machen wir ja mit dem Editor oder der Kommandozeile auch nicht) und diese exe-Datei anzuklicken. Wir drücken einmal gekonnt die Windows-Taste+R (r für das englische 'run' also 'ausführen') und haben ein kleines Fensterchen offen mit dem wir die Windows-Tools aufrufen können. Wir geben 'regedit' ein und drücken einmal auf OK.

Und woher weiß Windows jetzt wo es nach der Regedit.exe suchen soll wenn ich das da eingebe?

Ich gebe euch einen Tipp: Das steht auch in der Registry (* siehe Bonus-Wissen ganz unten!)

Bis hierhin kann man nichts falsch machen, reinschauen kostet also nichts! Was wir links sehen sollte einem Windows-Benutzer doch recht vertraut sein. Wir haben 'Ordner' die wir auf und zu klappen können und davon (meistens) ganze 5 Stück!

'Ordner'?

Vom aussehen her könnte man sie als 'Ordner' bezeichnen, aber wir lernen es gleich richtig. Alles was hier als 'Ordner' dargestellt wird nennt sich Schlüssel. Und wenn wir schon bei Begrifflichkeiten sind erkläre ich euch gleich auch was ein 'Hive' ist.

Aber gehen wir mal kurz einen Schritt zurück.

Habt ihr euch schonmal gefragt wo man das ganze Zeug auf der Festplatte überhaupt findet?

Da ist eine rießengroße Struktur mit vielen, vielen Schlüsseln ('Ordnern'), das kann ja nicht einfach so aus dem nichts auftauchen. Und genau darum findet man die Registry in folgenden Dateien:

C:\Windows\system32\config\System 	(HKEY_CURRENT_CONFIG)
C:\Windows\system32\config\SAM		(HKEY_LOCAL_MACHINE\SAM)
C:\Windows\system32\config\Security	(HKEY_LOCAL_MACHINE\Security)
C:\Windows\system32\config\Software	(HKEY_LOCAL_MACHINE\Software)
C:\Windows\system32\config\System 	(HKEY_LOCAL_MACHINE\System)
C:\Windows\system32\config\Default	(HKEY_USERS\.DEFAULT)
C:\Users\Benutzername\ntuser.dat	(HKEY_CURRENT_USER)

Hier mal ein Bild:

Diese 7 oben genannten Schlüssel nennen sich Hives und sind alles woraus die Registry besteht.

Moment mal, ich sehe doch noch andere Schlüssel! Wo ist denn zum Beispiel HKEY_CLASSES_ROOT?

Die simple (und vermutlich erstmal verwirrende) Antwort ist: Den Schlüssel selbst gibt es nicht.

... ?

Wir schauen uns das natürlich an:

Der Aufbau der Registry

Was wir sehen wenn wir die Registry öffnen (also diese 5 großen Schlüssel) ist eine von Windows benutzerfreundlich gemachte Ansicht.

Nehmen wir mal an wir haben ein x-beliebiges Stück Software. Dessen Standard-Einstellungen werden unter diesem Schlüssel gespeichert:

HKEY_LOCAL_MACHINE

und gelten erstmal für alle Benutzer des PCs. Wenn ich mich nun am PC anmelde, die Software öffne und irgendwelche Einstellungen mache (die natürlich nur mich betreffen sollen und nicht alle anderen user, z.B. einen blauen Hintergrund haben möchte), dann befinden sich diese Einstellungen hier:

HKEY_CURRENT_USER

Der Schlüssel HKEY_CLASSES_ROOT führt diese 2 oben genannten Schlüssel visuell zusammen, damit wir nicht rumsuchen müssen. Nach demselben Schema bilden sich auch die übrigen Schlüssel die nicht zu den Hives gehören. Ich zeig euch das mal anhand dieses Beispiels:

Ich habe hier einen Schlüssel (den Pfad könnt ihr im unteren Bereich des Bildes sehen) und einen x-beliebigen Eintrag erstellt:

Ich habe nochmal einen gleichnamigen Schlüssel für den Benutzer erstellt und dem ebenfalls einen Eintrag verpasst:

Ich habe die oben genannten Schlüssel benutzt. Ohne mein weiteres Zutun sieht es in dem HKEY_CLASSES_ROOT Schlüssel nun so aus:

Seht ihr wie beide Einträge angezeigt werden? Windows hat die 2 gleich benannten Schlüssel (in HKLM und HKCU - die Kurzschreibweise)  zusammen gelegt.

Und das war schon das ganze Hexenwerk für heute!

Ich wollte es kurz halten, es würde so viel mehr zu erzählen geben! Ich wollte euch aber nicht mit der Entstehungsgeschichte langweilen, es sollte wirklich nur mal ein leichtes Kratzen der Oberfläche sein, da die Meisten vermutlich eh nie direkt in die Registry gehen müssen.

Wenn ihr also Fragen, Anmerkungen, Lob und Kritik habt immer her damit - am Besten in die Kommentare.

_____________________________________________________

Bonus-Wissen:

(*)Hier geht es um die sogenannte Path-Umgebungsvariable.

Bitte was?

Ja, das 'Ding' schimpft sich so, ist aber auch wichtig und vorallem nützlich!

Folgendes Szenario: Ich öffne ein Konsolenfenster (ganz ohne Administrator-Rechte) und befinde mich standardmäßig in meinem Benutzer-Verzeichnis (C:\Users\Tician). Gebe ich jetzt ein 'notepad.exe' und drücke die Eingabe-taste öffnet sich ein Editor. Das läuft für viele schon automatisch. Aber denkt mal über folgendes: Muss man nicht eigentlich erst in das Verzeichnis navigieren oder den ganzen Pfad angeben um eine Datei darin auszuführen?

Ja... Aber dabei befindet sich die 'notepad.exe' doch gar nicht in meinem Verzeichnis!

Jupp, richtig und trotzdem öffnet es sich. Zum Verständnis müssen wir etwas weiter gehen. Geben wir also mal 'putty.exe' ein. Wir werden mit der Meldung "Der Befehl 'putty.exe' ist entweder falsch geschrieben oder konnte nicht gefunden werden" begrüßt. 'Konnte nicht gefunden werden' trifft es in unserem Fall auf den Punkt.

Aber ich hab putty! Liegt doch direkt auf meinem Desktop!

Auch korrekt. Was ist also passiert? Windows (und übrigens auch Linux) haben diese Path-Variable. Wir finden sie unter Windows in der Registry in diesem Schlüssel:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment

Hier gibt es den Eintrag 'Path'. Wenn ich nun also einen Befehl oder eine Datei zum öffnen/ausführen in die Kommandozeile eingebe sucht Windows erstmal in dem Verzeichnis in dem ich mich befinde danach. In unserem Beispiel das Benutzerverzeichnis (keine Unterordner!). Wenn Windows den Befehl dort nicht findet greift es auf diese PATH-Variable zu. Da stehen einige Pfade durch Semikolon getrennt drin und Windows geht sie alle nacheinander von links nach rechts durch und sucht in den Ordnern nach meinem Befehl, also 'putty.exe'.

Das heißt also...?

Wenn ich jetzt diesen Path-Eintrag veränder und ';C:\Users\Tician\Desktop\' anhänge kann ich auch mein Putty jederzeit - und unabhängig davon in welchem Pfad ich mich in der Konsole befinde - aufrufen!

Ich spare mir mal die übliche Anrede und komme direkt zur Sache. Mathematik, mit allem was man sich so vorstellt. Ich gebe zu, vor dieser Klausur hatte ich die größte Angst. Eine Woche Urlaub davor konnten mir die auch nicht nehmen. Aber nun zum Modul: Es gliederte sich in drei große Bereiche:

I. Grundlagen

1. Aussagenlogik
2. Mengenlehre
3. Stellenwertsysteme
4. Folgen und Reihen

II. Lineare Algebra

1. Matrizen und Vektoren
2. Lineare Gleichungssysteme
3. Inverse Matrizen
4. Determinenten
5. Leontief Model

III. Analysis

1. Funktionen
2. Wichtige Punkte
3. Differential-Rechnung
4. Integral-Rechnung

An sich war alles nicht so schwer wie gedacht. Wenn ich auch Probleme hatte, der Vorlesung zu folgen, so war in der Vorbereitungsphase eigentlich alles halb so wild. Mit Matrizen hatte ich immer meine Probleme, aber im Endeffekt waren auch die machbar. Für viele ist ja Mathe so der große Blocker zum Studium, der große dunkle Endgegner, der einen gleich im ersten Semester auf die Intensivstation schickt. Diese Angst kann ich euch nehmen. Ich bin sicherlich keine Mathe-Genie, aber ein gesundes logisches Verständnis kann einem da ganze Welten an Arbeit ersparen. So bin ich auch in die Klausur, nach einer Woche intensiver Vorbereitung gab es kein Feld mehr, dass ich nicht bearbeiten konnte. Nur die Zeit, die war mir etwas zu knapp. Aber als dann die Mail mit den Ergebnissen kam, da war ich zufrieden und freue mich nun auf Statistik. Das kommende Semester wird eh der Wahnsinn, viele spannende Module, wo ich sicher auch als Fachinformatiker noch das eine oder andere neue hören werde. Aber dazu komme ich in einem anderen Eintrag.

Wie seht ihr das? Ist Mathematik wirklich der Nemesis aller Studenten, oder ist es längst nicht mehr der große Blocker? Gerne können wir das in den Kommentaren diskutieren.

Bis dahin grüßt euch

SebastianB.

um den Fachinformatiker-Blog mit etwas mehr Leben zu füllen, würde ich gerne wissen, welche Themen euch interessieren.

Womit können wir euch am besten helfen? Eher technische Themen oder Tipps zur Prüfungsvorbereitung? Lieber Projektdokumentation oder Fachgespräch? Besser Blog-Beiträge oder Podcast-Episoden? Oder, oder, oder...

Ich freue mich über euer Feedback! Schreibt mir gerne eure Wunschthemen oder Vorschläge für deren Gestaltung! Und auch Kritik an den bisherigen Blog- und Podcastinhalten nehme ich gerne an. Dadurch könnten wir im nächsten Jahr diese Seite mit noch mehr relevanten Inhalten für alle Azubis und Prüflinge da draußen füllen.

Viele Grüße!
Stefan