Buchclub: Handbuch für Fachinformatiker (Teil 13: Konzepte der Programmierung) – Anwendungsentwickler-Podcast #96

This entry is Teil 13 von 14 in the series Buchclub

Um Kapitel 10 (Konzepte der Programmierung) des Handbuchs für Fachinformatiker geht es in der sechsundneunzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Mit Kapitel 10 des Handbuchs für Fachinformatiker von Sascha Kersken gehe ich mit dir grundlegende Konzepte der Programmierung durch. Wenn du Algorithmen und Datenstrukturen verstehst, kannst du passende Lösungen auswählen und nachvollziehen, wie sich dein Code bei größeren Datenmengen verhält. Reguläre Ausdrücke helfen dir im Arbeitsalltag beim Bearbeiten von Texten, während ereignisgesteuerte Programmierung auch im Fachgespräch relevant ist. Die Beispiele zur systemnahen Programmierung sowie zu Netzwerkzugriffen und grafischen Oberflächen geben dir Einblicke in Arbeitsfelder, die über deinen Ausbildungsbetrieb hinausgehen.

Kapitelmarken

  • [00:00:00] Einstieg in den Buchclub zu Kapitel 10
  • [00:01:50] Warum du Datenstrukturen intern verstehen solltest
  • [00:03:46] Überblick über die Programmierkonzepte
  • [00:04:01] Sortieralgorithmen und Komplexität
  • [00:07:50] Rekursion selbst ausprobieren
  • [00:08:25] Sortieraufgaben in Praxis und Prüfung
  • [00:09:34] Lineare und binäre Suche
  • [00:10:17] Stack, Queue und weitere Datenstrukturen
  • [00:13:19] Reguläre Ausdrücke im Arbeitsalltag
  • [00:16:11] Prozesse und Pipes
  • [00:16:47] Threads und nebenläufige Programmierung
  • [00:19:26] Netzwerkprogrammierung mit Sockets
  • [00:21:08] Über den Ausbildungsbetrieb hinaus lernen
  • [00:22:53] Grafikprogrammierung und Mathematik
  • [00:24:59] Fensteranwendungen und Event-Handling
  • [00:26:45] Event-Bus und Reactive Programming
  • [00:29:29] Welche Konzepte für die Prüfung relevant sind
  • [00:31:38] Das frühere Unterkapitel zu Java EE
  • [00:33:07] Fragen für Episode 100
  • [00:33:43] Reguläre Ausdrücke mit Regex Crossword üben
  • [00:34:17] Projektpräsentation, weiterführende Links und Newsletter
  • [00:35:36] Weitere Buchclub-Termine

Probeabo bei Audible (Affiliate)

Das Kapitel 10 des IT-Handbuchs für Fachinformatiker* von Sascha Kersken liefert einen Überblick über zentrale Konzepte der Programmierung: Algorithmen, Datenstrukturen, reguläre Ausdrücke, Netzwerkprogrammierung usw. Insgesamt ein spannendes Kapitel gefüllt mit viel Know-How für die Praxis. Auch wenn nicht so viel prüfungsrelevantes Wissen enthalten ist, sollte jeder Anwendungsentwickler die beschriebenen Inhalte kennen, da man ihnen früher oder später sehr wahrscheinlich bei der eigenen Arbeit begegnen wird.

  • 10.1 Algorithmen und Datenstrukturen
    • Sortieralgorithmen zeigen gut die Unterschiede bei der Komplexität verschiedener Lösungen für das gleiche Problem (BubbleSort vs. QuickSort).
    • In einer der letzten Prüfungen war ein kleiner Sortieralgorithmus enthalten.
    • Der kleine Ausflug zur Rekursion und Iteration ist wichtig.
    • Suchalgorithmen sind für die Praxis nicht ganz so wichtig, bilden aber die Grundlage von Datenbanken. Daher begegnen sie uns – wenn vielleicht auch unbewusst – jeden Tag.
    • Die abstrakten Datenstrukturen Stack, Queue und Baum sind absolutes Grundwissen für jeden Entwickler. Es gibt keine Ausrede dafür, sie nicht zu kennen! Ich lasse sie in meinem Java-Tutorial auch immer einmal selbst programmieren.
  • 10.2 Reguläre Ausdrücke
    • Ich bin immer wieder erstaunt, wie selten fertige Anwendungsentwickler sich mit regulären Ausdrücken auskennen. Ich könnte ohne sie nicht leben 🙂
    • Es gab schon einmal eine Aufgabe zu Textmustern in der IHK-Prüfung, die allerdings eine eigene Syntax vorgab. Aber die Idee der regulären Ausdrücke ist daher wohl als prüfungsrelevant einzustufen.
  • 10.3 Systemnahe Programmierung
    • Prozesse und Pipes sind wichtige Konzepte für die systemnahe Programmierung, sie jeder Entwickler einmal gehört haben sollte. In der Praxis werden sie aber wohl nur relevant, wenn man halt systemnah programmiert 🙂
    • Threads sind ein Konzept, das heutzutage immer wichtiger wird. Da Prozessoren nicht mehr (oder kaum noch) vertikal skalieren, sondern horizontal, sollte jeder Entwickler sich mit der nebenläufigen Programmierung auseinandersetzen.
    • Viele moderne Sprachen bieten Abstraktionen für die nebenläufige Programmierung an, sodass man nicht selbst mit Threads hantieren muss.
  • 10.4 Einführung in die Netzwerkprogrammierung
    • Jeder Entwickler sollte wissen, was eine Socket ist.
    • In der Praxis wird man aber wahrscheinlich wenig damit arbeiten, da einem moderne Sprachen das Low-Level-Coding abnehmen.
  • 10.6 GUI- und Grafikprogrammierung
    • Ein netter Ausblick auf die eigene Programmierung von grafischen Ausgaben, aber für die Praxis und die Prüfung eher uninteressant, da man heutzutage sehr wahrscheinlich Frameworks dafür nutzen würde.
    • Das Unterkapitel zur fensterbasierten Programmierung und dem Event Handling ist allerdings wieder sehr praxisrelevant.
    • Auch in der mündlichen Prüfung haben wir schon öfter nach Events und Event Handlern gefragt.

Frühere Inhalte

Literaturempfehlungen

Was sonst? 🙂

Sascha Kersken - IT-Handbuch für Fachinformatiker: Für Fachinformatiker der Bereiche Anwendungsentwicklung und Systemintegration. Inkl. Prüfungsfragen und Praxisübungen (Affiliate)*
(direkt beim Rheinwerk-Verlag bestellen*)

Die erwähnten Bücher zum Buchclub und zur Einarbeitung in Java EE gibt es hier:

Links

Zusammenfassung

Algorithmen und Datenstrukturen verstehen

Für dich als IT-Azubi in der Anwendungsentwicklung bespreche ich Kapitel 10 des Handbuchs für Fachinformatiker von Sascha Kersken. Die Codebeispiele zeigen, wie grundlegende Konzepte intern funktionieren. Dieses Wissen hilft dir dabei, Datenstrukturen passend auszuwählen und Ursachen für langsame Programme zu erkennen. In meinem Java-Tutorial lässt sich jede:r Azubi deshalb unter anderem mit einer selbst programmierten Queue und einer verketteten Liste auf diese Grundlagen ein.

Sortieren, Suchen und Rekursion

An Bubble Sort und Quick Sort führt das Kapitel in Sortieralgorithmen ein. Bubble Sort lässt sich einfach programmieren und hat durch seine geschachtelten Schleifen einen quadratischen Aufwand: Bei doppelt so vielen Elementen steigt der Aufwand auf das Vierfache. Quick Sort teilt die Liste und arbeitet rekursiv. An solchen Beispielen kannst du nachvollziehen, wie der Aufwand eines Algorithmus mit der Datenmenge wächst.

Bei der linearen Suche werden Elemente nacheinander geprüft. Die binäre Suche grenzt den Bereich schrittweise ein, wodurch sie bei großen Datenmengen erheblich weniger Vergleiche braucht. Das Kapitel behandelt diese Suchverfahren auf wenigen Seiten.

Zum Üben empfehle ich dir, selbst etwas Rekursives zu programmieren. Dabei lernst du die besondere Art kennen, ein Problem rekursiv zu lösen, und begegnest den Schwierigkeiten, die daraus entstehen. Der kurze Kasten im Buch reicht dafür als Einstieg.

In einer von mir betrachteten IHK-Prüfung musste innerhalb einer Programmieraufgabe eine Liste sortiert werden. Der Algorithmus war frei wählbar, sodass Bubble Sort für die Aufgabe ausreichte. Auch im Arbeitsalltag kann eine eigene Sortierlösung erforderlich sein, wenn die vorhandenen Sprachmittel die Aufgabe nicht abdecken.

Stack, Queue und Bäume

Mit Codebeispielen stellt das Buch ausgewählte Datenstrukturen vor:

  • Ein Stack folgt dem LIFO-Prinzip, also "Last In, First Out". Das zuletzt abgelegte Element wird zuerst entnommen. Rücksprungadressen bei Methodenaufrufen werden beispielsweise auf einem Stack verwaltet.
  • Eine Queue arbeitet nach FIFO, also "First In, First Out". Das zuerst eingefügte Element wird zuerst verarbeitet, wie bei einer Warteschlange.
  • Bäume gehören ebenfalls zu den behandelten Grundstrukturen.
  • Ergänzend zum Buch erwähne ich die Double Ended Queue, bei der du an beiden Enden Elemente einfügen kannst. Damit lässt sich beispielsweise eine dringende Nachricht vorne einordnen.

Beim Lernen hilft dir die Frage, für welche Aufgabe eine Datenstruktur geeignet ist. Ihre interne Arbeitsweise erklärt auch, warum bestimmte Operationen mehr Zeit brauchen. Stack und Queue bieten sich als Themen für das Fachgespräch an.

Reguläre Ausdrücke im Arbeitsalltag

Zum Einstieg in reguläre Ausdrücke empfehle ich dir die rund 18 Seiten des Kapitels. Dort werden wichtige Syntaxelemente sowie Gruppen und Klammerungen behandelt.

Mit regulären Ausdrücken kannst du Textmuster erkennen und Texte bearbeiten. Beispielsweise lassen sich Leerzeichen am Zeilenende entfernen oder Logdateien anhand bestimmter Muster auswerten. Viele Texteditoren und IDEs unterstützen die Suche mit regulären Ausdrücken samt Ersetzen. Auf der Linux-Kommandozeile gehört grep zu den entsprechenden Werkzeugen.

In einer schriftlichen Prüfung habe ich bereits eine Aufgabe zu Textmustern gesehen, die eine eigens definierte Syntax vorgab. Für die Praxis empfehle ich dir, die gebräuchliche Regex-Syntax zu lernen. Beim Regex Crossword kannst du sie spielerisch üben.

Systemnah und nebenläufig programmieren

An C-Beispielen zeigt das Buch, wie Prozesse über Pipes kommunizieren. Wie weit du diese Details vertiefen solltest, hängt von deinen Aufgaben im Betrieb ab. In den von mir betrachteten Prüfungen sind mir solche Programmieraufgaben bislang nicht begegnet.

Bei Threads geht es darum, mehrere Abläufe nebenläufig auszuführen. Mehrere CPU-Kerne können dabei Arbeit übernehmen. Für Entwickler:innen wird es anspruchsvoll, die möglichen Abläufe nachzuvollziehen und fehlerfreien Code zu schreiben.

Viele Programmiersprachen bieten dafür Abstraktionen an. Als Beispiel bespreche ich async und await in C#, mit denen du asynchronen Code schreiben kannst. Asynchronität und Nebenläufigkeit bezeichnen unterschiedliche Konzepte. Das Buch liefert eine Einführung samt Java-Beispiel; für deine praktische Arbeit solltest du zusätzlich nachlesen, welche Möglichkeiten deine Programmiersprache bietet.

Über Netzwerke kommunizieren

Mit einem Python-Beispiel führt das Kapitel in Sockets ein. Ein Socket bildet einen Netzwerkendpunkt mit IP-Adresse und Port, über den Daten mit einem entfernten Gegenüber ausgetauscht werden können. Das Beispiel startet einen kleinen Server und zeigt einen HTTP-Request.

Wenn du das Beispiel nachvollziehst, erhältst du einen Einblick darin, wie HTTP unter der Oberfläche funktioniert. Im Arbeitsalltag übernehmen Bibliotheken häufig diese Zugriffe. Eigener Socket-Code ist vor allem dann relevant, wenn du systemnah arbeitest. Die gezeigten Details ordne ich für die Prüfung als wenig relevant ein.

Grafiken und Oberflächen entwickeln

Beim Zeichnen von Formen begegnen dir mathematische Funktionen, darunter Sinus und Cosinus. Besonders für angehende Spieleentwickler:innen zeigt das Beispiel, welche Rolle Mathematik und physikalische Berechnungen spielen. Grafikbibliotheken übernehmen im Alltag viele dieser Aufgaben.

Für die fensterbasierten Java-Anwendungen verwendet das Buch AWT und Swing. Ich empfehle dafür in der Episode JavaFX. An den Beispielen kannst du vor allem das Event-Handling nachvollziehen: Ein:e Benutzer:in klickt auf einen Button, wodurch ein Ereignis ausgelöst wird. Der zugehörige Programmcode reagiert darauf. Dieses Prinzip gilt auch für Weboberflächen.

Über einen Event-Bus können Komponenten Nachrichten austauschen und lose gekoppelt zusammenarbeiten. In dem besprochenen asynchronen Ablauf verschickt eine Methode ein Ereignis und läuft weiter, während registrierte Komponenten darauf reagieren. Auch Reactive Programming greift dieses Prinzip auf. Ereignisgesteuerte Programmierung habe ich bereits mehrfach im Fachgespräch abgefragt.

Durch solche Beispiele lernst du Arbeitsweisen kennen, die über die Aufgaben deines Ausbildungsbetriebs hinausgehen. Wenn du täglich in einem dieser Spezialgebiete arbeitest, brauchst du weiterführende Literatur, weil das Handbuch jeweils einen Überblick bietet.

Ergänzende Literatur und Hinweise

In einer früheren Auflage gab es zusätzlich ein Unterkapitel zu verteilten Anwendungen mit Java EE, darunter EJBs und SOAP. Für das Vertiefen dieses Themengebiets empfehle ich ein eigenes Fachbuch, beispielsweise das in der Episode genannte Buch zu Java EE 7.

Auf meiner Website findest du ergänzende Links zu Reactive Programming und zu einer Projektpräsentation, die bei der IHK München mit 100 Prozent bewertet wurde. Mein wöchentlicher Newsletter enthält neue Beiträge und ermöglicht dir den Zugriff auf Checklisten für deine Projektdokumentation und Präsentation.

Für Episode 100 sammle ich Fragen rund um die IT-Ausbildung und die Abschlussprüfung. In der Episode kündige ich außerdem zwei Buchclub-Termine aus dem Jahr 2017 an: Am 27.03.2017 steht Pragmatic Unit Testing with JUnit an, am 17.04.2017 folgen die Kapitel 11 und 12 des Handbuchs zu Mobile Development und Software Engineering.

Transkription der gesamten Episode

Automatisch erzeugte Transkription der Episode

[0:00] Herzlich willkommen zum Anwendungsentwickler-Podcast, dem Podcast rund um die Ausbildung zum Fachinformatiker

[0:09] für Anwendungsentwicklung. In dieser Episode geht es weiter mit dem Buchclub zum Handbuch

[0:13] für Fachinformatiker, Kapitel 10. Viel Spaß! Hallo und herzlich willkommen zur 96. Episode

[0:24] des Anwendungsentwickler-Podcasts. Mein Name ist Stefan Macke und heute geht es weiter mit dem

[0:30] Buchclub zum Handbuch für Fachinformatiker von Sascha Kersken. Das wird die vorletzte Episode

[0:35] heute sein, aber wir sind ja auch immerhin schon bei Nummer 13 angekommen in der Reihe. Also Wahnsinn,

[0:41] wie lang wir uns schon mit diesem Buch beschäftigen, aber es ist ja auch definitiv wert,

[0:45] deswegen habe ich das Ganze hier angefangen. Und heute haben wir ein Kapitel vor, das eigentlich

[0:50] sehr interessant ist, wie ich finde, auch gerade für uns Entwickler. Da draußen sind ja auch einige

[0:54] Dinge in dem Buch beschrieben, die nicht so viel mit Softwareentwicklung zu tun haben, was ja auch

[0:58] völlig okay ist. Aber für uns sind natürlich die Programmierthemen viel interessanter als der

[1:02] ganze Rest. Und heute haben wir ein Kapitel vor, nämlich Nummer 10 mit den Konzepten der

[1:07] Programmierung, wo es sich wirklich intensiv um die Softwareentwicklung dreht und wo auch viele

[1:12] spannende Sachen erklärt werden und vorgestellt werden. Und heute die vorletzte Episode. Wir

[1:18] machen noch einen Buchclub zum letzten Kapitel, was ich noch nicht besprochen habe, bzw. zu den

[1:22] zwei letzten Kapiteln Nummer 11 und 12, nämlich Mobile Development und Software Engineering. Die

[1:28] Episode kommt dann auch bald in einigen Wochen. Ich habe jetzt gerade nicht drauf, wann genau.

[1:32] Auf jeden Fall dauert es nicht mehr lange. Von daher, wenn du auch noch mitmachen willst, liest

[1:36] die Kapitel doch bis zu dem Termin. Die Info, wann das rauskommt, kriegst du auch immer in meinem

[1:40] Newsletter, wenn du dich da einträgst. Gut, aber dann lasst uns mal starten mit den Inhalten,

[1:45] denn da haben wir jetzt halt einiges vor uns und ich möchte wieder die 30 Minuten einhalten. Von

[1:50] daher, let's go! Also Kapitel 10 vielleicht erst mal so grob vorweg. Ich persönlich fand das sehr,

[1:56] sehr interessant. Sehr viele spannende und wichtige Inhalte auch drin. Meine beiden Azubis,

[2:01] mit denen ich das Kapitel schon durchgesprungen habe, die fanden das jetzt so, geht so eher.

[2:05] War halt auch viel Code drin und viele abstrakte Datenstrukturen vor allem, die man vielleicht so

[2:11] in der Praxis weniger selber programmieren muss, sondern die einfach schon fertig da sind. Zum

[2:16] Beispiel so ein Stack oder eine Queue, die programmiere ich normalerweise nicht selbst.

[2:19] Die gibt es halt schon eingebaut in meine Programmiersprache. Das ist zwar richtig,

[2:23] das sehe ich genauso. Das werde ich in der Praxis niemals selber machen, sowas. Aber das heißt nicht,

[2:27] dass ich nicht verstehen muss, wie das funktioniert und was der Sinn dahinter ist. Und vor allem,

[2:31] wann ich welche dieser Datenstrukturen benutze. Das finde ich eigentlich sehr viel wichtiger,

[2:36] als sie selber programmieren zu können. Auf der anderen Seite finde ich es aber auch gut,

[2:39] dass einmal gezeigt wird, wie man sie programmiert. Denn das ist viel viel besser zu verstehen,

[2:44] wenn ich mal gesehen habe, wie quasi die Innereien solcher Datenstrukturen funktionieren und warum

[2:48] sie so funktionieren, wie sie funktionieren. Wenn man also dann zum Beispiel in der Praxis

[2:52] die Wahl hat, das wird jetzt zwar im Kapitel nicht beschrieben, aber ist so ein Klassiker,

[2:55] den ich immer nehme, Arraylist oder Linked List zum Beispiel. Und ich habe nachher ein

[3:02] Performance-Problem zum Beispiel mit einer Arraylist, dann kann ich mir das vielleicht

[3:05] gar nicht erklären, wenn ich nicht weiß, wie die Arrayliste intern funktioniert. Denn wenn ich

[3:09] nicht weiß, dass die zum Beispiel jedes Mal, wenn ich Elemente hinzufüge, intern eigentlich

[3:12] ein Array redimensioniert und die ganzen alten Inhalte rüber kopiert, dann wundere ich mich

[3:18] vielleicht, wenn ich eine Arraylist mit einer Million Elemente fülle, warum auf einmal mein

[3:23] PC die Grätsche macht, weil er einfach viel zu langsam wird. Von daher, ich persönlich bin der

[3:27] Meinung, dass man das auf jeden Fall mal gelesen und gesehen haben sollte. Und das bietet dieses

[3:31] Kapitel und deswegen finde ich das sehr interessant. Klar, die einzelnen Sachen nachher wie die

[3:36] Netzwerkprogrammierung oder die GUI und Grafikprogrammierung, da kann man darüber

[3:39] streiten, ob man das jetzt wirklich im Detail so wissen muss oder nicht. Aber ich glaube, wir

[3:42] gehen da gleich mal dann darauf ein, wenn ich bei den entsprechenden Unterkapiteln angekommen bin.

[3:46] Also erstmal der Überblick über das Kapitel 10. Es ist unterteilt in die Unterkapitel

[3:51] Algorithmen und Datenstrukturen, reguläre Ausdrücke, systemnahe Programmierung,

[3:56] Einführung in die Netzwerkprogrammierung und GUI und Grafikprogrammierung. Und wir fangen direkt

[4:01] mal an mit den Algorithmen und Datenstrukturen. Da gibt es auch gleich eine schöne Einführung,

[4:07] so in, ja, ich sage mal dieses klassische Studiumsfach. Wenn man irgendwas mit Informatik

[4:12] studiert, gibt es da eigentlich meistens irgendeine Vorlesung auch mit Algorithmen und

[4:15] Datenstrukturen. Die heißt dann meistens genauso. Und was macht man da normalerweise? Ja, so Basis

[4:21] Algorithmen programmieren und so Standard Datenstrukturen mal umsetzen. Und hier geht es

[4:24] auch gleich mit den beliebtesten davon los, nämlich mit den Sortieralgorithmen. Zwei davon

[4:29] werden vorgestellt, nämlich einmal der Bubble Sort und einmal der Quick Sort. Jetzt kann ich

[4:34] natürlich darüber streiten, muss ich Sortieralgorithmen beherrschen? Nö, muss ich nicht.

[4:38] Ich muss die wahrscheinlich nie selbst programmieren in der Praxis. Die sind ja einfach

[4:41] da. Aber was ich viel wichtiger finde, ist zu verstehen, welche Vor- und Nachteile die

[4:45] einzelnen Algorithmen haben. Denn es gibt nicht umsonst, ich sage jetzt einfach mal,

[4:48] gefühlte 20 verschiedene Sortieralgorithmen da draußen, die haben alle ihre Daseinsberechtigung,

[4:53] die haben alle ihre individuellen Vor- und Nachteile. Bubble Sort zum Beispiel, der ist

[4:58] super easy zu implementieren, den kann wahrscheinlich jeder Azubi, auch ohne den

[5:01] je gelesen zu haben, implementieren, weil es einfach so eine einfache Möglichkeit ist,

[5:07] etwas zu sortieren. Der Quick Sort, den kann man wahrscheinlich nicht auswendig

[5:10] runterschreiben, wenn man ihn nicht gelernt hat. Dafür ist er halt super, super schnell.

[5:14] Der Bubble Sort ist halt einfach zu schreiben, aber super langsam. Also die haben alle ihre

[5:18] Vor- und Nachteile, wie gesagt. Und ich finde es eigentlich sehr interessant, dass man anhand

[5:22] dieser Algorithmen so ein bisschen den Einstieg in die Komplexitätstheorie hinbekommt. Das heißt,

[5:27] eine Einschätzung, ob ein Algorithmus jetzt eigentlich schnell oder langsam ist,

[5:30] verglichen mit einem anderen. Da kann man zum Beispiel sagen, beim Bubble Sort,

[5:33] der hat zwei geschachtelte Vorschleifen. Das heißt, die Komplexität dieses Algorithmus ist

[5:38] n². Wenn das Array doppelt so lang wird, wird der Algorithmus viermal so lange brauchen,

[5:45] weil er nämlich mit zwei geschachtelten Vorschleifen quadratisch also durch das

[5:50] Array läuft. Der Quick Sort wird nur mit Logarithmus von n ansteigen, weil er die Liste

[5:55] teilt und quasi, wie nachher noch bei der Binärbaumsuche beschrieben wird,

[6:00] nicht so viele Schritte braucht, sondern halt eben nur Logarithmus von n. Und das sollte man

[6:05] in der Praxis nicht unterschätzen, dass das ein Riesenunterschied sein kann. Wenn ich nämlich zum

[6:10] Beispiel eine Liste, oder nehmen wir mal ein Suchalgorithmus, das ist einfacher zu erklären.

[6:15] Wenn ich in einer Liste mit, nehmen wir mal was einfach zu berechnendes, und zwar eine Liste mit

[6:22] 2 hoch 32 Elementen, das sind also so ungefähr 4 Milliarden Elemente, wenn ich darin ein Element

[6:28] suche und ich muss die gesamte Liste durchgehen, dann habe ich eine Komplexität von n. Das heißt,

[6:33] die Liste ist 4 Milliarden lang, ich muss 4 Milliarden Vergleichsoperationen machen,

[6:37] dann ist also die Anzahl der Vergleichsoperationen genauso groß wie die Anzahl der Elemente. Steigt

[6:42] die Anzahl der Elemente, muss ich auch mehrere Vergleiche machen, logischerweise. Wenn ich jetzt

[6:47] einen Algorithmus habe, der nicht die Komplexität n hat, also O von n heißt das, sondern die

[6:53] Logarithmus, ach, die Komplexität O von Logarithmus n, dann wird das deutlich, deutlich kleiner,

[6:58] denn das Logarithmus, der Logarithmus, der natürliche Logarithmus von 2 hoch 32 ist 32.

[7:05] Das heißt, der Algorithmus mit der Komplexität Log n, der braucht nur 32 Vergleiche, um das

[7:13] Element zu finden, während der Logarithmus, während der, oh Gott, ich bringe mich an Leute,

[7:17] während der Algorithmus mit Komplexität n 4 Milliarden Vergleiche braucht. 32 versus 4

[7:24] Milliarden. Ich glaube, das ist schon ein deutlicher Unterschied. Und wenn man davon

[7:27] noch nie vorher was gehört hat und man sucht einfach quasi linear durch die Liste durch und

[7:32] wundert sich, warum der überhaupt nicht fertig wird, dann sollte man mal, ja, im Informatikunterricht

[7:37] besser aufgepasst haben, denn dann wüsste man das nämlich. So, ich bin aber schon wieder viel zu

[7:40] sehr in die Details hier abgestiegen, ehrlich gesagt. Wir waren gerade nur bei den Einstiegsseiten

[7:44] zum Thema Algorithmen. Da werden halt hier zwei Algorithmen vorgestellt. Bubble Sort,

[7:50] Quick Sort, hatte ich schon gesagt und auch noch ein kleiner Ausflug in Richtung Rekursion wird

[7:53] da eingeschoben, denn der Quick Sort arbeitet rekursiv. Rekursion, ehrlich gesagt, ist etwas,

[7:58] was jeder Anwendungsentwickler unbedingt kennen muss. Es ist so ein wichtiges Prinzip in der

[8:02] Softwareentwicklung. Also da reicht mir diese eine Seite als Einführung nicht aus. Du musst

[8:07] unbedingt einfach mal was Rekursives auch programmiert haben, um auch die Probleme zu

[8:11] sehen, um auch diese etwas andere Art der Problemlösung zu verstehen und so weiter.

[8:16] Also das unbedingt angucken, aber das nehme ich jetzt hier mal nicht als vollwertigen Inhalt,

[8:20] weil das einfach nur so ein eingeschobener Kasten hier ist. Aber was ich jetzt eigentlich sagen

[8:25] wollte ist, sind die Sortieralgorithmen eigentlich jetzt interessant in der Praxis? Eher nicht. Nur

[8:29] wenn ich sie halt selber programmieren muss, muss ich natürlich wissen, wie sie funktionieren. Die

[8:34] Frage ist, wann muss ich denn das? Ich habe tatsächlich in einer der letzten IHK-Prüfungen

[8:38] meine Aufgabe, eine Programmieraufgabe gesehen, wo man was sortieren musste. Aber da war halt

[8:42] nicht vorgegeben, was für einen Algorithmus man benutzt. Von daher konnte man auch mit einem

[8:45] simplen Bubble Sort das Ganze lösen. Die Aufgabe war nicht explizit nach einem Sortieralgorithmus

[8:50] gestellt, sondern die Aufgabe war halt, machen Sie die und die Liste. Ach, übrigens, die muss

[8:55] sortiert sein. So nach dem Motto, das ist so ein bisschen unterschwellig eingeflossen in die

[8:59] Aufgabe, gab dann halt auch nicht so viele Punkte dafür. Aber ich sage jetzt einfach mal 5, 6 Punkte

[9:03] wird es dafür wohl gegeben haben von 25. Von daher, ein Sortieralgorithmus ist auch in der Praxis

[9:08] und natürlich auch in der Prüfung tatsächlich interessant. Von daher würde ich das nicht abtun

[9:14] so nach dem Motto, ja, Theorie, wen interessiert das? Sondern man braucht es sowohl in seinem

[9:18] Programm eventuell mal, wenn man zum Beispiel eine Sprache benutzt, wo es keine eingebaute

[9:22] Sortierung gibt, oder man irgendwas sortieren muss, was man mit den eingebauten Sprachmitteln

[9:26] nicht so hinkriegt und man sich doch irgendwie selber was stricken muss. Das hatte ich auch schon

[9:29] mal in der Praxis. Von daher würde ich nicht unterschätzen und mir unbedingt mal anschauen. Von

[9:34] daher ein guter Einstieg in die Algorithmen. Dann geht es auch gleich weiter mit den Suchalgorithmen.

[9:39] Da gibt es dann zum Beispiel diese lineare Suche oder eben die binäre Suche, die hier auch

[9:43] vorgestellt wird. Und wie gesagt, da ist also die Komplexität enorm unterschiedlich. Von daher,

[9:49] unbedingt mal angucken. Allerdings wird das hier auch nur auf zwei Seiten erklärt. Das ist also

[9:52] relativ oberflächlich an der Stelle. Gut, aber wir studieren ja auch nicht Informatik,

[9:57] zumindest wahrscheinlich die meisten da draußen, die das hier hören. Ich weiß nicht, ob du studierst

[10:01] oder nicht, aber wenn, dann solltest du sowieso mal was davon gehört haben. Und wenn du eine

[10:05] ganz normale Ausbildung machst, dann solltest du trotzdem was davon gehört haben. Das sind

[10:08] absolute Grundbegriffe der Informatik und so eine Suche auf dem Baum zum Beispiel,

[10:12] ja, das sollte jeder Informatiker mal gehört haben. Ja, dann geht es weiter im Kapitel mit

[10:17] ausgewählten Datenstrukturen. Und da haben wir zum Beispiel die Stacks und die Queues und die Bäume,

[10:23] die hier vorgestellt werden. Auch mit Code-Beispielen, was ich wirklich sehr sehr gut

[10:26] finde. Es geht zwar nicht so sehr in die Tiefe, was die Theorie hier angeht, aber es sind einige

[10:32] Seiten mit Beispiel-Code tatsächlich dabei, so dass man sich also im Detail angucken kann,

[10:37] wie man so etwas denn jetzt programmiert. Ich persönlich, wie gesagt, finde wichtig,

[10:41] dass man weiß, wozu diese Datenstrukturen da sind, was sie können, was sie aber auch

[10:44] nicht können und vor allem, wann man sie einsetzen sollte. Ein Stack zum Beispiel,

[10:49] wann brauche ich den? Ja, das ist ein Speicher, auf den ich nur oben was drauflegen kann und auch

[10:53] nur oben wieder was runternehmen kann. Das heißt, wie heißt diese Datenstruktur? Auch vielleicht

[10:58] eine beliebte Prüfungsfrage. Das ist dann das sogenannte LIFO-Prinzip. Last In, First Out.

[11:04] Was ich oben drauflege, also zuletzt draufgelegt habe, muss ich als erstes auch wieder runternehmen.

[11:11] Also Last In, First Out. Auf Deutsch nennt man den auch ab und an mal Stapelspeicher oder

[11:16] Kellerspeicher, gibt es auch den Begriff dafür, aber ich würde ihn einfach Stack nennen. Da kann

[11:20] eigentlich jeder, der Informatik mal gehört hat, was mit anfangen. Und was ist so ein Stack? Was

[11:25] ist zum Beispiel im Computer damit umgesetzt? Die ganzen Rücksprungadressen bei Methodenaufrufen

[11:29] zum Beispiel, die liegen auf dem Stack. Das heißt, die grundsätzliche Ablauflogik bei

[11:34] deinem Programm wird intern mit einem Stack verwaltet. Von daher allein deswegen sollst

[11:39] du schon mal was davon gehört haben. Eine Queue ist dann gegenüber dem Stack ein sogenannter

[11:43] FIFO-Speicher. First In, First Out. Also wie eine Warteschlange. Die Person, die sich zuerst

[11:50] angestellt hat, darf auch zuerst an die Kasse zum Beispiel oder an den Postschalter oder wo auch

[11:55] immer. Das ist dann eine Queue. Es gibt übrigens, das wird im Buch nicht erklärt oder erwähnt,

[12:00] aber auch noch eine weitere Datenstruktur, die heißt Dequeue oder wie auch immer man das

[12:05] ausspricht, auf jeden Fall soll das heißen Double Ended Queue. Das heißt, ich kann sowohl

[12:09] vorne als auch hinten etwas anfügen. Wofür ist sowas wichtig? Kann man sich vorstellen,

[12:14] eine Prioritätswarteschlange. Wenn ich gewisse Nachrichten in diese Schlange einstelle,

[12:19] dann werden die erst mal von vorn nach hinten abgearbeitet. Wenn jetzt aber eine hoch priorisierte

[12:23] Nachricht reinkommt, dann kann ich die auch direkt vorne vor die Queue stellen, sodass die direkt als

[12:27] nächstes verarbeitet wird. Und dafür brauche ich zum Beispiel eine Double Ended Queue. Das war es

[12:33] dann auch schon mit dem Kapitel zum Thema Datenstrukturen. Also viel war jetzt hier nicht

[12:37] drin und auch relativ oberflächlich, dafür aber mit viel Code. Ich persönlich bin der Meinung,

[12:41] jeder Entwickler muss diese Datenstrukturen kennen und du solltest dich damit auch intensiv

[12:45] auseinandersetzen. Ich habe die zum Beispiel alle in meinem Java Tutorial drin, das ich mit meinen

[12:48] Studenten, meinen Auszubildenden mache. Die müssen das alles einmal programmieren, zum Beispiel auch

[12:52] eine Queue selber programmieren und auch eine verkettete Liste zum Beispiel selber programmieren.

[12:57] Das sind so absolute Basisstrukturen, die jeder einmal gesehen haben muss, am besten einmal

[13:02] programmiert haben muss. Und man kann die auch hervorragend in Prüfungen abfragen. Ich habe es

[13:06] zwar noch nicht so oft in schriftlichen Prüfungen gesehen, wobei Stack und Queue habe ich da glaube

[13:10] ich auch schon mal gelesen, bin ich mir nicht mehr ganz sicher. Aber in einer mündlichen Prüfung kann

[13:14] man da natürlich wunderbar nachfragen. Der nächste Unterpunkt, das nächste Unterkapitel sind die

[13:19] regulären Ausdrücke. Und da möchte ich gar nicht allzu viel zu sagen, denn das ist für mich einfach

[13:24] völlig anders. Ich fange jetzt mal ganz normal an. Jeder Informatiker muss reguläre Ausdrücke

[13:31] kennen. Es gibt für mich keinerlei Ausrede, die nicht zu beherrschen. Ich will allerdings jetzt

[13:35] nicht das ganze Kapitel durchgehen und jeden kleinen Buchstaben und jedes Zeichen hier durchgehen,

[13:39] denn das wird in einem Podcast sicherlich nicht funktionieren. Gab es übrigens auch schon mal eine

[13:43] Prüfungsfrage zu den regulären Ausdrücken. Nicht nach der offiziellen in Anführungszeichen Syntax,

[13:48] sondern sie haben sich dann so eine eigene Syntax irgendwie ausgedacht und mit der sollte man dann

[13:53] so Textmuster quasi in der Prüfung nachbauen. Fand ich ganz ganz gruselig, weil die nämlich die

[13:58] richtigen Zeichen benutzt haben, aber in unterschiedlichen Bedeutungen. Also das fand

[14:01] ich wirklich ganz schrecklich, diese Aufgabe. Aber soviel nur am Rande. Man muss also mit Textmustern

[14:05] sich mal auseinandersetzen. Aber für die Praxis sind diese regulären Ausdrücke so unerlässlich.

[14:10] Also ich glaube, die Tage, an denen ich keine regulären Ausdrücke benutze in meinem Arbeitsalltag,

[14:16] die kann ich an einer Hand abzählen wahrscheinlich. Also es gibt so viele Einsatzgebiete für reguläre

[14:21] Ausdrücke. Und sei es nur irgendwie, ich weiß es nicht, eine Liste umformatieren und alle

[14:25] Leerzeichen am Ende der Zeile rausschmeißen oder so. Regulärer Ausdruck, zack, ein Zeiler,

[14:30] bumm, alles fertig. Ich weiß es nicht, in einem Programm irgendwelche Logdateien auswerten,

[14:36] die ein bestimmtes Muster haben. Oder, also ich weiß nicht, es gibt so viele Ansatzpunkte für

[14:41] reguläre Ausdrücke und jeder vernünftige Texteditor beherrscht die heute. Sei es auch deine IDE,

[14:46] zum Beispiel Eclipse kann nach regulären Ausdrücken suchen und ersetzen und so weiter.

[14:49] Jede Programmiersprache kann das. Jeder Editor, die Kommandozeile mit GREP zum Beispiel auf Linux.

[14:55] Also das ist überall eingebaut und zwar aus gutem Grund, weil es einfach so ein wichtiges Tool ist

[15:00] und du damit so viele coole Sachen machen kannst. Ich will deswegen, wie gesagt, nicht hier die

[15:05] einzelnen Sachen durchgehen, aber ziehe dir das unbedingt rein. Ich finde das Kapitel im

[15:08] Handbuch für Fachnummermanika sehr gut als Einstieg geeignet. Ich empfehle das tatsächlich

[15:12] auch meinen Azubis. Das sind auch einige Seiten, wenn ich hier mal kurz durchzähle. Das sind

[15:18] ziemlich genau 18 Seiten zur Einführung in reguläre Ausdrücke. Alle wichtigen Sachen

[15:24] drin. Alle wichtigen Syntaxelemente, Klammerungen, Gruppen und so weiter. Alles dabei. Und ich schlage

[15:30] immer die Hände über dem Kopf zusammen, wenn irgendwelche Anwendungsentwickler nicht mit

[15:33] regulären Ausdrücken umgehen können. Ja, die mögen am Anfang ein bisschen kryptisch sein,

[15:37] das gebe ich zu. Aber die sind so enorm mächtig und ich kann damit so viele Dinge einfach lösen,

[15:42] die ich sonst mir, also wo ich mich totprogrammieren müsste. Ich kann es nicht nachvollziehen,

[15:47] wenn man das nicht beherrscht. Also ganz eindringliche Empfehlung, zieh dir das rein.

[15:51] Wenn du es nicht für die Prüfung machst, dann für deine Praxis. Es gibt wenige Tools,

[15:57] die auf Programmiersprachen unabhängig so gut funktionieren und die ich dir so wärmstens ans

[16:02] Herz lege. Also unbedingt reguläre Ausdrücke angucken. Und das Kapitel im Buch ist ein

[16:05] herrlicher Einstieg. Gut, danach geht es jetzt weiter mit der systemnahen Programmierung. Und

[16:11] da geht es dann zum Beispiel um Prozesse und Pipes, wie also zum Beispiel zwei Prozesse

[16:15] miteinander kommunizieren können, wenn die sich gegenseitig irgendwie Nachrichten schicken wollen

[16:19] zum Beispiel. Hier sind auch einige Codebeispiele, selbstverständlich in C, wie sollte es anders

[16:24] sein, dabei. Und da muss ich persönlich sagen, wichtiges Thema, sollte man auch mal gelesen

[16:30] haben. Wenn du es aber in der Praxis nicht selber brauchst, weil du zum Beispiel nicht mit C auf

[16:34] Linux oder so programmierst, dann ist das ja nice to know, aber es wird dir in der Praxis dann auch

[16:39] nicht richtig weiterhelfen. Und in der Prüfung habe ich es auch noch nie gesehen, dass irgendwie

[16:43] davon was abgefragt wird. Nächstes Unterkapitel, das sind die Threads. Das ist dann schon ein

[16:47] bisschen was anderes, denn nebenläufige Programmierung wird heute immer, immer wichtiger. Ich habe es

[16:52] schon in so vielen Blogartikeln und Links der Woche und so immer wieder erwähnt, funktionale

[16:56] Programmierung ist groß im Kommen aktuell. Alle Programmiersprachen, Java, C Sharp, Ruby, wie auch

[17:02] immer, bauen da Sachen von ein quasi. Warum ist das so? Weil die Hardware einfach nicht mehr

[17:08] vertikal skalieren kann heute. Die CPUs, die werden nicht mehr schneller. Wir kriegen immer

[17:12] nur mehrere CPU-Kerne in den CPUs mehr, weil einfach physikalische Grenzen erreicht sind. Von

[17:17] daher skalieren die Systeme heute horizontal. Man geht also in die Breite, man macht einfach

[17:22] mehrere Kerne nebeneinander. Das Problem ist, wenn du so programmierst, dass nur einer dieser

[17:26] Kerne gleichzeitig benutzt wird, dann hast du nichts gewonnen. Dann ist einfach irgendwann die

[17:30] physikalische Grenze der CPU erreicht und dann wird dein Programm nicht mehr schneller. Von daher

[17:34] kann es nur die Lösung sein, dass wir in die Breite gehen und das kriegen wir nur mit

[17:38] nebenläufiger Programmierung hin. Und eine Möglichkeit, das zu tun, sind halt Threads.

[17:42] Wobei Threads für den Programmierer, also den Menschen, der das umsetzt, relativ schwer zu

[17:48] verstehen sind. Es ist einfach sehr problematisch für Menschen, parallel zu denken. Das können wir

[17:53] einfach nicht. Wir sind biologisch so angelegt, dass wir ein Ding verfolgen können und das war

[17:59] es dann schon. Haben wir zwei, drei, vier oder noch mehr parallele Abläufe, dann ist es für

[18:04] uns Menschen sehr schwierig, das nachzuvollziehen und dann auch sauber und fehlerfrei sogar noch zu

[18:08] programmieren. Von daher gibt es in vielen modernen Programmiersprachen bestimmte Abstraktionen,

[18:13] die es einem ermöglichen, diese Threads zum Beispiel gar nicht mehr selber programmieren

[18:17] zu müssen. Denken wir zum Beispiel an Async und Await, die beiden Keywords, die in .NET-Sprachen

[18:22] inzwischen drin sind, in C-Sharp unter anderem, die mir quasi eine asynchrone Programmierung

[18:27] erlauben, obwohl mein Code weiter quasi synchron aussieht, sage ich mal. Im Hintergrund wird

[18:34] eventuell sogar ein neuer Thread gestartet, wenn irgendwas im Hintergrund ablaufen muss

[18:37] und so weiter. Also es ist jetzt nicht hundertprozentig dasselbe. Nebenläufig und asynchron

[18:41] ist nicht synonym. Es gibt noch kleine Unterschiede, aber grundsätzlich ist es schon so,

[18:48] dass ich, wenn ich etwas zum Beispiel im Hintergrund abarbeiten lassen möchte,

[18:51] wahrscheinlich einen Thread dafür benutze. Von daher ein wichtiges Thema, aber wenn man dann

[18:56] auch wirklich einsteigen will, reicht das Kapitel hier auch nicht aus. Es kratzt dann doch mehr an

[19:00] der Oberfläche hier. Von daher ist eine schöne Einführung. Man hat das dann mal gehört. Es ist

[19:04] auch ein Code-Beispiel in Java zum Beispiel dabei, wie das dann gut funktioniert. Aber für die Praxis

[19:08] würde mir das hier dann doch noch nicht ausreichen. Und die meisten Programmiersprachen

[19:12] bieten sowieso irgendeine Abstraktionsschicht an, sodass man dann sowieso für seine eigene

[19:17] Programmiersprache nochmal nachschauen sollte, wie man denn da jetzt konkret nebenläufig

[19:21] oder asynchron programmiert. Okay, nächstes Kapitel wäre dann die Einführung in die

[19:26] Netzwerkprogrammierung. Da fangen wir dann mit so tollen Sachen an wie einer Socket.

[19:30] Was ist eine Socket und wie arbeite ich damit? Kurz vorweg, der Code, der da gezeigt wird,

[19:35] ist für die Prüfung nicht so ganz relevant. Für die Praxis auch nur, wenn du tatsächlich mal

[19:38] Low-Level-Programmierung machst. Die meisten Programmiersprachen bieten dir auch hier wieder

[19:43] eine Abstraktionsschicht an. Also du wirst zum Beispiel in den seltensten Fällen hardcore

[19:47] über Sockets, was weiß ich, HTTP-Verbindungen programmieren, sondern du wirst einfach eine

[19:50] HTTP-Bibliothek aufrufen, die das dann für dich macht. Also wir beschäftigen uns jetzt,

[19:54] außer wenn du wirklich in der Systementwicklung tätig bist, täglich nicht damit, irgendwelche

[19:59] HTTP-Protokolle per Hand nachzubauen. Dafür ist die Zeit viel zu schade. Wir nehmen einfach

[20:05] fertige Bibliotheken und fertig. Von daher wirst du wahrscheinlich in der Praxis selten mit Sockets

[20:09] in Berührung kommen. Aber du solltest schon wissen, was es ist. Eine Socket ist im Prinzip

[20:13] ein Netzwerkendpunkt, der besteht aus einer IP-Adresse und einem Port dahinter. Und darüber

[20:19] kann ich jetzt mit einem entfernten Netzwerkteilnehmer kommunizieren. Ich kann also quasi

[20:22] Bytes hin und her schicken über diese Socket-Verbindung.

[20:26] Im Buch wird jetzt hier auch ein kleines Beispiel gezeigt mit Python, um selber so einen Server zu

[20:31] starten und sogar tatsächlich als Beispiel ein HTTP-Request dahin zu schicken und so weiter.

[20:36] Finde ich eine schöne Geschichte. Auch allein um das Protokoll mal runterzubrechen, dass man

[20:41] nochmal HTTP im Einsatz sieht, wie das denn tatsächlich unter der Haube funktioniert. Also

[20:45] von daher, ich finde das sehr, sehr spannend. Würde ich mir auch unbedingt angucken und

[20:48] durchlesen und vielleicht auch vertiefen, wenn es dich interessiert. In der Praxis ist es allerdings

[20:53] wenig wahrscheinlich, dass du damit weiter irgendwas zu tun haben wirst, weil halt in

[20:57] allen Sprachen heute irgendwelche Möglichkeiten bestehen, um von diesen absoluten Low-Level-

[21:02] Netzwerkzugriffen zu abstrahieren. Ja, dann sind wir auch schon beim letzten Unterkapitel,

[21:08] nämlich GUI und Grafikprogrammierung. Auch hier wieder der gleiche Hinweis eigentlich wie bei

[21:13] den vorherigen jetzt auch, ob du es in der Praxis brauchst oder nicht. Ja, hängt jetzt wirklich

[21:17] davon ab, wie dein Einsatzspec ist, was du eigentlich in deinem Tagesgeschäft so programmieren musst.

[21:22] Wenn du keine grafischen Oberflächen baust, dann wirst du dich auch nicht für die GUI-Programmierung

[21:25] interessieren, erst recht nicht für die Grafikprogrammierung. Aber grundsätzlich finde

[21:29] es wichtig, dass jeder Entwickler das mal gehört hat, denn wir können nicht davon ausgehen, dass

[21:32] wir in der Ausbildung nur das lernen müssen, was wir auch im Unternehmen brauchen, sondern wir

[21:36] sollen ja auch ein bisschen generalistisch ausgebildet werden, sodass wir also auch links

[21:44] und rechts mal gucken, was gibt es denn sonst noch so. Von daher, wenn du den ganzen Tag Linux

[21:48] Kommandozeilen-Befehle programmierst, dann solltest du eventuell auch mal eine Kleinigkeit im

[21:53] Web entwickeln oder vielleicht sogar eine Windows-GUI mal bauen, einfach um mal was anderes

[21:57] gesehen zu haben. Denn das wird auch deine Entwicklung in deinem täglichen Arbeitsumfeld

[22:01] doch stark beeinflussen. Das sehe ich immer, wenn ich mal links und rechts gucke, was es noch für

[22:05] coole neue Programmiersprachen gibt, was es da so für Möglichkeiten gibt, um zum Beispiel Code

[22:10] kürzer zu machen, Nebenläufe zu programmieren und so weiter. Die Ideen, die ich davon mitnehme,

[22:15] die bringen mich eigentlich auch bei meiner eigenen Programmierung weiter, auch wenn ich es

[22:19] nicht direkt vielleicht in der Sprache, die ich dann da benutze, umsetzen kann. Von daher,

[22:23] ich sehe dieses gesamte Kapitel 10 auch so, dass man mal guckt, was es denn sonst noch so da draußen

[22:28] gibt. Was machen denn C-Entwickler auf Linux? Ah, die kommunizieren mit Pipes und Sockets über

[22:34] Netzwerke und Prozessgrenzen hinweg oder wie auch immer. Oder die Windows-Leute, die bauen sich da

[22:39] irgendwie GUIs, wo sie dann draufklicken und eventbasiert irgendwas. Also einfach nur, dass man

[22:44] mal was anderes gesehen hat, finde ich eigentlich sehr schön, dieses Kapitel dafür geeignet, weil

[22:47] man so viele verschiedene Konzepte, wie das Kapitel auch heißt, hier mal einmal gezeigt bekommt. Und

[22:53] das letzte Kapitel ist genau das gleiche. Es geht hier los mit einer Grafikprogrammierung. Das heißt,

[23:00] wir zeichnen hier auf deutsch gesagt so ein paar Linien mal auf dem Bildschirm und gucken mal,

[23:04] wie das dann aussieht. Kann man jetzt darüber streiten, ob das wirklich wichtig ist? Ich finde

[23:09] es ganz interessant, mal für so einen Azubi, der das noch nie gesehen hat, wie man denn überhaupt

[23:13] so Symbole oder irgendwelche Formen auf dem Monitor quasi darstellen kann und wie man die

[23:18] zeichnet. Das ist letztlich alles irgendwie Mathematik, die dahinter steht. Und man braucht

[23:22] halt ganz viele tolle Sachen, wie zum Beispiel, wird hier auch jetzt gezeigt, im Beispiel Sinus-

[23:27] und Cosinus-Funktion und so. Und das ist halt viel Rechnerei, was man da macht. Und das finde

[23:31] ich eigentlich nur deswegen interessant, weil man zum Beispiel als Spieleentwickler das den ganzen

[23:36] Tag eigentlich macht. Die meisten Leute denken, ja, geil, Spiele entwickeln, das ist mein Traumjob.

[23:40] Und dann fangen sie an und sehen, oh, ich muss irgendwelche physikalischen Funktionen umsetzen

[23:44] und irgendwie Kollisionsberechnungen mit hochkomplexen mathematischen Formeln umsetzen.

[23:48] Also das hat jetzt so mit, keine Ahnung, ich zeichne mal lustige Waffen auf dem Bildschirm

[23:54] oder so wenig zu tun. Es geht da eigentlich um reinste Mathematik. Und ich finde ganz gut,

[23:58] dass man das dann hier mal einmal so ein bisschen zu Gesicht bekommt. Ansonsten finde ich es für

[24:02] die Praxis relativ uninteressant, wie ich eine Linie auf dem Bildschirm zeichne. Außer,

[24:06] du bist halt jemand, der, keine Ahnung, eine eigene Grafikbibliothek schreibt. Ansonsten

[24:10] gibt es auch hier natürlich ohne Ende Bibliotheken da draußen, wo ich einfach sagen kann, zeichne mir

[24:15] einen Kreis dahin, Punkt. Und da muss ich nicht selber mit dem Radius und Durchmesser und Umfang

[24:19] und irgendwas ausrechnen und hin und her, sondern das macht die Bibliothek für mich. Also wieder

[24:24] das Gleiche wie vorhin. Wenn dich das interessiert, schau dir das einfach mal an. Fand ich eigentlich

[24:28] auch sehr gut beschrieben. Im Praxisbeispiel auch, dass man es nachvollziehen kann, gut zu lesen,

[24:32] auch sehr viele Codebeispiele vor allem wieder dabei. Von daher lesenswert für die Prüfung,

[24:37] aber meiner Meinung nach absolut irrelevant. Sowas wird da normalerweise nie abgefragt. Das

[24:41] ist viel zu speziell, genau wie die Netzwerk- und die Pipe-Programmierung und so weiter. Das kann

[24:48] halt nicht jeder Azubi in der Tiefe gelernt haben in seinem Beruf und deswegen wird sowas auch sehr,

[24:54] also es wird eigentlich nie abgefragt, habe ich zumindest noch nie gesehen. Das letzte Unterkapitel,

[24:59] das ist die Programmierung fensterbasierter Anwendungen. Da wird es aber wieder ein bisschen

[25:03] praxisrelevanter. Das wird zwar hier in Java gemacht und dann werden halt relativ veraltete

[25:08] Sachen benutzt, also zum Beispiel AWT und Swing. Würde ich heute in Java so nicht mehr nutzen. Da

[25:14] würde ich inzwischen einfach JavaFX benutzen. Das ist eigentlich der Standard jetzt für grafische

[25:17] Oberflächen. Aber was mich eigentlich viel mehr interessiert in diesem Kapitel, das ist der Bereich

[25:22] zum Event-Handling. Denn das sollte wirklich jeder Entwickler mal gehört haben. Was heißt es,

[25:27] Ereignis-Gesteuert zu programmieren? Und das machst du eigentlich immer dann, wenn du eine

[25:32] grafische Oberfläche im Hintergrund hast. Und sei es tatsächlich eine Fensteranwendung, wie jetzt

[25:36] hier im Kapitel, oder auch eine Web-Oberfläche. Das ist genau das Gleiche. Denn die Idee ist,

[25:41] dass bei der Event-Gesteuerten oder bei der Ereignis-Gesteuerten Programmierung nicht dein

[25:46] Programm sich steuert, sondern dass der Benutzer Entscheidung trifft und das Programm steuert. Denn

[25:52] der Benutzer entscheidet zum Beispiel, jetzt klicke ich mal hier auf diesen Button und darauf

[25:55] muss dann dein Programm reagieren. Das heißt, dein Programm läuft nicht einfach, wie man das so

[25:59] schön kennt, von oben nach unten durch und ist dann fertig, sondern das wartet quasi darauf,

[26:04] dass der Benutzer irgendeine Eingabe tätigt. Und sobald das getan ist, wird ein Event ausgelöst,

[26:10] ein Ereignis zum Beispiel, auf diesen Button wurde geklickt und dann muss dein Programm genau

[26:15] darauf reagieren und da weiterlaufen, wo es weiterlaufen muss, um diesen Button-Event

[26:19] halt zu verarbeiten. Und das ist schon eine etwas andere Art der Programmierung. Wenn du

[26:23] sonst zum Beispiel nur auf der Konsole irgendwas programmiert hast, startest, so nach dem Motto

[26:26] Batch-Betrieb, läuft irgendwie eine halbe Stunde, dann ist er fertig, dann ist das natürlich erstmal

[26:30] eine Umstellung, überhaupt die Kontrolle abzugeben und darauf zu warten, dass ein Benutzer irgendetwas

[26:37] tut, damit du weitermachen musst. Und das finde ich auch eine ganz wichtige Art der Programmierung,

[26:41] hat jetzt nicht zwangsläufig nur was mit Oberflächen zu tun, denn du kannst diese Events

[26:45] zum Beispiel auch in einem ganz normalen Programm, in einem Batch-Betrieb oder wie auch immer benutzen.

[26:49] Das heißt, du musst zum Beispiel nicht Methodenaufrufe hart koppeln, die eine Methode

[26:54] ruft die andere auf, sondern man kann zum Beispiel auch mit einem sogenannten Event-Bus dafür sorgen,

[26:58] dass das Ganze asynchron läuft. Wenn eine Methode eine andere Methode aufruft, dann muss sie halt

[27:02] darauf warten, dass was zurückkommt. Macht die Methode aber einfach nur eine Nachricht an einen

[27:08] Event-Bus, also schickt eine Nachricht an den Bus und der verwaltet die dann und reicht die

[27:13] eventuell weiter an alle, die das interessiert, dann kann die erste Methode einfach weiterlaufen.

[27:17] Die sagt einfach nur, so jetzt ist hier irgendein Ereignis eingetreten, feuerfrei und alle Leute,

[27:22] die das interessiert, also alle Leute nicht, alle Methoden zum Beispiel oder alle Klassen,

[27:27] wie auch immer sich dann da registriert hat, der macht dann irgendwas damit, aber darauf muss halt

[27:31] die Methode, die dieses Ereignis erzeugt hat, nicht warten. Und genau so ist es halt, wenn dein

[27:36] Benutzer auf den Button klickt, da wird halt so ein Event ausgelöst und du musst darauf reagieren.

[27:41] Von daher, das ist ein allgemeineres Konzept, dieses Event-Handling und diese Ereignis-steuerte

[27:46] Programmierung, die auch für dich relevant ist, nicht wenn nur anders. Mein Gott, ich weiß nicht,

[27:52] was heute los ist. Die nicht nur für dich relevant ist, wenn du Windows-Oberflächen programmierst,

[27:57] sondern die könnte auch in deinem ganz normalen Programmieralltag interessant werden, wenn du

[28:01] gar nichts mit Oberflächen baust. Einfach weil dieses Prinzip der Ereignisse und der losgelösten

[28:06] oder der der losen Kopplung zwischen den einzelnen Komponenten über so einen Event-Bus auch heutzutage

[28:13] immer wichtiger wird. Stichwort Reactive Programming. Das ganze Zeug läuft komplett event-gesteuert

[28:18] zum Beispiel. Ich registriere mich an einer Event-Quelle und höre hier darauf, dass irgendwelche

[28:23] Dinge auftreten, sei es, keine Ahnung, der Börsenkurs von irgendwem hat sich verändert und darauf reagiere

[28:28] ich dann. Also dieses ganze hippe, moderne Zeug, das basiert alles auf Dingern, die eigentlich schon

[28:33] 100 Jahre, ist jetzt ein bisschen übertrieben, aber die alle schon 20, 30 Jahre alt sind, denn die

[28:38] ersten Windows-Programme, das ist immer noch das gleiche Konzept wie damals. Das sollte man

[28:42] einfach gehört haben. Einfach also, weil es nichts direkt mit der Window-Programmierung zu tun hat,

[28:47] sondern weil es ein Programmierkonzept ist, das losgelöst von irgendwelchen Technologien

[28:51] umgesetzt werden kann und auch unabhängig von irgendwelchen Programmiersprachen. Also du kannst

[28:55] auch in C-Low-Level irgendwelche Event-Geschichten programmieren. Du brauchst nicht Java oder C-Sharp

[29:00] oder was auch immer dafür. Aber in dem Kapitel hier wird jetzt am Ende halt nochmal die klassische

[29:06] Button-Anwendung quasi gebastelt, auch ein mehrseitiges Code-Beispiel dabei, sodass man

[29:12] das also mal gesehen hat und auch vielleicht hoffentlich dann versteht, wie das Ganze dann

[29:16] funktioniert. Das Code-Beispiel ist tatsächlich auch in Java dann umgesetzt und kann man also im

[29:23] Prinzip so nachbauen, wenn man mal ein bisschen Oberflächen bauen will. Wow, ich gucke mal auf

[29:29] die Uhr. 30 Minuten gerade so eingehalten. Wunderbar. Das heißt, ich mache jetzt hier mal

[29:33] Feierabend. Die vorletzte Episode des Buchclubs zum Handbuch für Fachinformatiker ist damit

[29:38] abgehakt. Ich gehe nochmal ganz grob die Inhalte durch. Also wir haben über Algorithmen und

[29:42] Datenstrukturen geredet. Wichtiges Grundwissen für jeden Informatiker, meiner Meinung nach. In

[29:47] der Prüfung kommt es ab und an auch mal dran, aber in der mündlichen Prüfung vor allem würde ich

[29:51] persönlich durchaus danach fragen, was zum Beispiel ein Stack ist, wofür der benutzt wird und so

[29:55] weiter. Dann haben wir reguläre Ausdrücke. Das ist meiner Meinung nach ein absolutes Pflichtprogramm

[30:00] für jeden IT-ler. Kam schon mal so ähnlich in der schriftlichen Prüfung dran, aber ich

[30:05] persönlich finde es einfach in der Praxis so unerlässlich, das zu wissen. Das musst du dir

[30:09] unbedingt angucken. Dann haben wir die letzten drei Kapitel Systemnahe Programmierung,

[30:13] Netzwerkprogrammierung, GUI und Grafikprogrammierung. Das sind Dinge, die würde ich mir einfach mal

[30:17] angucken, um so deinen Horizont zu erweitern, wenn du das alles selbst noch nie gemacht hast. Für

[30:21] die Prüfung sind das eher irrelevante Themen, bin ich mal ganz ehrlich. Bis auf die GUI-Geschichte

[30:27] mit der eventbasierten Programmierung, denn das ist etwas, was heute durch das Reactive Programming

[30:32] zum Beispiel auch immer mehr wieder wichtig wird und auch völlig programmiersprachenunabhängig ist.

[30:37] Einfach ein Konzept, ein Vorgehen bei der Programmierung, was jeder Entwickler können

[30:41] muss und danach habe ich auch schon des Öfteren in den Fachgesprächen gefragt. Also nach dem Motto,

[30:46] wenn man da jetzt auf den Button klickt in der Webanwendung, wie nennt man denn diese Art der

[30:50] Programmierung und was passiert eigentlich genau, wenn ich auf den Button klicke, wer horcht da

[30:55] drauf und so weiter und so fort. Da kann man schöne Prüfungsfragen zu stellen. Also von daher

[30:59] auch Pflichtprogramm für jeden Anwendungsentwickler. Ansonsten solltest du tatsächlich täglich mit

[31:04] diesen Sachen zu tun haben in den drei Kapiteln, dann bist du sicherlich gut beraten, wenn du dir

[31:09] über dieses Buch hinaus noch mehr Literatur besorgst, denn dafür sind sie dann doch ein

[31:13] bisschen oberflächlich, die Einführung. Aber wie gesagt, soll ja auch nur einen Überblick geben.

[31:18] Von daher mein persönliches Fazit. Kapitel 10, eines meiner Lieblingskapitel des gesamten Buches.

[31:23] Viele spannende Sachen für Entwickler drin, reguläre Ausdrücke, mein absolutes Lieblingsthema

[31:27] überhaupt. Eventbasierte Geschichten, Rekursionen haben wir hier erklärt und so. Also viele coole

[31:33] Sachen drin für jeden Anwendungsentwickler. Wirklich ein gutes Kapitel, wie ich persönlich finde.

[31:38] In einer früheren Auflage des Handbuchs gab es noch ein Unterkapitel zum Thema

[31:43] verteilte Anwendungen mit Java EE. Ich habe schon mal das Open Book bei Galileo geguckt,

[31:48] was da so drin stand. Habe ich auch wieder in den Shownotes verlinkt. Übrigens wie immer unter

[31:52] www.anwendungsentwicklerpodcast.de.96 für die 96. Episode heute zu finden. Und das Kapitel wurde

[32:01] meiner Meinung nach zurecht gestrichen, denn die Sachen, die da beschrieben wurden, sind

[32:04] heutzutage in Java auch nicht mehr so ganz relevant. So EJBs, Enterprise Java Beans und

[32:08] Soap war da drin und so. Also das sind so schwergewichtige Enterprise Dinger, die heute

[32:13] sowieso niemand mehr benutzt, wenn er die Wahl hat und nicht diese Uhr in Sachen benutzen muss,

[32:18] weil er dazu gezwungen wird zum Beispiel. Also in modernen Anwendungen mit zum Beispiel Java EE 7,

[32:23] da brauchen wir diesen Kram eigentlich so nicht mehr. Von daher habe ich auch kein Problem mit,

[32:27] dass das hier gestrichen wurde. Und wenn du dich mit Java und der Enterprise Geschichte

[32:31] auseinandersetzen musst, dann reichte dieses Buch sowieso nicht als Einführung. Dann guck

[32:35] dir mal ein vernünftiges Java Buch an, zum Beispiel Java EE 7, auch aus dem Galileo Verlag.

[32:40] Das ist ein über tausendseitiges Buch allein für die Java Enterprise Edition. Also von daher finde

[32:46] ich es okay, wenn er die, ich glaube es waren auch nur ein paar Seiten, hier streicht. Denn das kann

[32:50] man in der Kürze sowieso nur anreißen, aber wirklich nur oberflächlich anreißen, worum es

[32:55] da eigentlich geht. Und ich finde die Inhalte so jetzt ganz okay und die EE hat mir jetzt hier

[33:01] nicht gefehlt, muss ich ehrlich sagen. Okay, damit wäre ich dann für die Inhalte heute durch. Ich

[33:07] habe nochmal einen kleinen Aufruf, wie die letzten Wochen auch. Wenn du konkrete Fragen rund um die

[33:12] Ausbildung hast, zur Programmierung, zur Abschlussprüfung, wie auch immer, dann schreib

[33:16] mich gerne an. Denn in der baldigen Episode 100 gehe ich auf alle diese Hörerfragen ein, die mir

[33:22] bis dahin gestellt werden. Von daher schick mir eine Mail, schreib mir einen Kommentar bei Twitter,

[33:27] bei Xing, bei Facebook, ganz egal. Du wirst mich überall finden, wenn du nach mir suchst oder halt

[33:31] einfach auf der Website guckst. Da ist es überall verlinkt. Und dann kann ich vielleicht dir

[33:35] persönlich eine Antwort geben in der Episode 100, die im April erscheint. Ich habe zur heutigen

[33:43] Episode nur einen einzigen Link als Empfehlung, nämlich das Regex-Crossword. Ich finde Regexe,

[33:49] wie gesagt, so so wichtig. Und mit dem Crossword kannst du dich einfach mal ein bisschen mit der

[33:54] Syntax von regulären Ausdrücken beschäftigen und die, sage ich, spielerisch lernen. Fand ich sehr,

[33:59] sehr witzig. Habe ich auch schon einige von durchgespielt. Mich hat es dann auch so ein

[34:02] bisschen gepackt, weil ich halt die regulären Ausdrücke einfach so cool finde. Vielleicht macht

[34:06] dir das ja auch Spaß und du wagst dich dann etwas mehr an die teilweise sehr seltsame Syntax der

[34:12] regulären Ausdrücke ran. Wenn du schon im Web so ein bisschen umhersurft und zum Beispiel auf

[34:17] die Shownotes gegangen bist, dann guck doch einfach mal auch in die Blogartikel von letzter

[34:21] Woche. Da habe ich zum Beispiel eine fantastische Präsentation, eine Projektpräsentation veröffentlicht

[34:28] von einem Hörer von mir. Der hat 100 Prozent für die Präsi bekommen von der IAK in München. Und

[34:34] da schau doch einfach mal rein, wenn du ein bisschen Inspiration vielleicht für deine noch

[34:38] eventuell anstehende Projektpräsentation brauchst. Und da wir heute schon über die

[34:42] nebenläufige Programmierung und verschiedene Kerne und so geredet haben, mein Link der Woche letztes

[34:46] Mal ging auch um Functional Core und irgendeine Shell darüber, zum Beispiel auch die Reactive

[34:51] Shell. Da habe ich dann auch einen Link hinterlegt, was überhaupt Reactive Programming ist und so

[34:56] weiter. Und wenn dich das interessiert und du so ein bisschen dich mit auch etwas moderneren

[35:00] Konzepten auseinandersetzen willst, schau doch einfach mal rein. Übrigens, diesen ganzen Kram,

[35:03] den kriegst du auch alles immer per Newsletter. Wenn du dich da einträgst,

[35:07] anbx-podcast.de slash Newsletter ist die Adresse dafür. Kostet nix, du kannst dich auch jederzeit

[35:12] wieder austragen, aber meine ganzen Links der Woche und die Podcast-Episoden und alles,

[35:17] was ich da so hochlade und Artikel und so, kriegst du dann immer einmal die Woche am Montagmorgen von

[35:21] mir per Mail zugeschickt, sodass du nichts verpasst. Außerdem kriegst du auch Zugriff auf

[35:26] meine ganzen Checklisten zur Projektdoku, zur Projektpräsie und so weiter. Kannst dir alles

[35:30] direkt runterladen, wenn du dich angemeldet hast. Wenn dir die Buchclub-Episode heute gefallen hat,

[35:36] dann sei mir noch ein letzter Hinweis. Erlaubt auf die nächsten Buchclub-Episoden. Am 27.03.2017

[35:43] kommt die Buchclub-Episode zum Buch Pragmatic Unit Testing with J-Unit und das finde ich ein

[35:51] absolutes Grundlagenbuch, wenn es um die Programmierung und die testgetriebene

[35:55] Programmierung und das Unit Testen geht. Habe ich hier auch schon mehrfach erwähnt im Podcast

[35:59] und im Blog. Da hättest du also noch zwei Wochen Zeit, das zu lesen, wenn du mitmachen willst.

[36:03] Und die allerallerletzte Buchclub-Episode zum Handbuch für Fachinformatiker gibt es dann am

[36:09] 17.04.2017. Da besprechen wir die Kapitel 11 und 12 Mobile Development und Software Engineering.

[36:15] Das wird auch noch mal richtig, richtig spannend. Denn Software Engineering ist ja quasi mein

[36:19] Steckenpferd, mein Lieblingsfach. Das unterrichte ich selber an der Uni und so weiter. Und von daher,

[36:26] da bin ich noch mal sehr gespannt, was in diesem letzten Kapitel noch so auf uns wartet und vor

[36:29] allem auch, was meine Azubis dazu sagen. Die müssen es ja auch noch lesen. Also würde mich freuen,

[36:34] wenn du mitmachst. Schick mir auch gerne vorab irgendwelche Kommentare oder Fragen,

[36:38] wenn du noch irgendwie was unterbringen möchtest in dieser Podcast-Episode. Ich bin da immer offen,

[36:43] kontaktiere mich gerne. Ich habe schon gesagt, du findest mich überall in sozialen Netzwerken

[36:46] und auf meiner Website natürlich. Ansonsten sage ich für heute jetzt aber auch endlich vielen Dank

[36:52] fürs Zuhören und bis zum nächsten Mal. Tschüss!

Polyglot Clean Code Developer
About the Author
Ausbildungsleiter für Fachinformatiker:innen Anwendungsentwicklung, IHK-Prüfer und ehemaliger Hochschuldozent für Programmierung und Software-Engineering.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert