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

[0:08] für Anwendungsentwicklung. In dieser Episode geht der Buchclub zum Handbuch für Fachinformatiker

[0:14] mit Kapitel 9 weiter. Viel Spaß!

[0:20] Hallo und herzlich Willkommen zur inzwischen 93. Episode des Anwendungsentwickler-Podcasts.

[0:27] Mein Name ist Stefan Macke und heute geht es weiter mit Teil Nummer 12, ist es glaube ich schon,

[0:33] des Buchclubs zum Handbuch für Fachinformatiker von Sascha Kersten. Und zwar habe ich noch ein

[0:39] paar Kapitel offen in dem über 1000 Seiten starken Buch und zwar genau die, die eigentlich für die

[0:45] Anwendungsentwickler am interessantesten sind, nämlich die zur Programmierung. Und wir machen

[0:49] heute weiter mit dem Kapitel 9. Das sind die Grundlagen der Programmierung und dann haben wir

[0:53] noch zwei Kapitel offen, die wir durchgehen müssen. Das ist einmal Software Engineering und dann noch

[0:58] eben die Konzepte der Programmierung. Und dann haben wir das ganze Buch endlich durch. Wahnsinn!

[1:03] Ich bin damals ja genau andersherum angefangen, weil ich zu einem Zeitpunkt startet bin, wo meine

[1:08] damaligen Azubis alle schon, ich sag mal, programmieren konnten und wir deswegen nicht mit dem

[1:12] Programmierkapitel angefangen sind, sondern mit anderen, die gerade bei mir reinpassten. Und jetzt

[1:16] ist es aber Zeit, die für Anwendungsentwickler eigentlich wichtigsten oder interessantesten

[1:20] Kapitel nachzuholen. Und damit machen wir heute weit. Also Kapitel 9, Grundlagen der Programmierung. Ganz

[1:26] allgemein vielleicht zum Kapitel 9 schon mal vorab. Es ist in der neueren Auflage des Handbuchs für

[1:31] Fachinformatiker aufgeteilt in drei Unterkapitel, die jeweils eine Programmiersprache beschreiben.

[1:37] Und zwar sind das die Programmiersprachen C, Java und Python. Relativ unterschiedliche

[1:42] Programmiersprachen und kann man auch unterschiedliche Sachen rausziehen als Leser dieser

[1:47] Kapitel. Da gehe ich dann gleich im Detail nochmal drauf ein. In früheren Auflagen des Buchs gab es

[1:52] noch zwei andere Programmiersprachen, und zwar Perl und Ruby. Die wurden jetzt aber gestrichen und

[1:57] inzwischen ersetzt durch Python. Ob man das gut findet oder nicht, ist jetzt eigentlich mir persönlich

[2:02] egal. Wichtig ist, dass die beschriebenen Programmiersprachen die gleichen Eigenschaften

[2:07] eigentlich teilen. Nämlich Perl und Python und Ruby sind alle dynamische Skriptsprachen, nennt man

[2:12] sie ja auch gerne. Von daher ist es gar nicht so schlimm, dass die anderen beiden jetzt rausgeflogen

[2:16] sind. Aktuell haben wir halt mit C eine völlig basic Programmiersprache, die es schon ewig gibt,

[2:22] die strukturiert und prozedural arbeitet und die so tolle Konzepte wie Appointer zum Beispiel hat.

[2:28] Dann haben wir Java als objektorientierte und statisch und stark typisierte Programmiersprache

[2:33] und dann halt Python als eine dynamisch typisierte Programmiersprache. Es ist also eigentlich für

[2:37] jeden was dabei, so dass man nach diesen drei Kapiteln, oder Entschuldigung, nach diesem einen

[2:41] Kapitel 9 schon einiges gesehen hat, sage ich mal. Also ganz viele verschiedene Programmierkonzepte

[2:47] und halt sogar auch Sprachen. Mag für den Einsteiger vielleicht ein bisschen schwierig

[2:51] sein, jetzt auch noch gleich die Syntax von drei verschiedenen Sprachen sich anzueignen,

[2:55] aber ich persönlich empfinde das Kapitel nicht unbedingt als Literatur, um danach dann drei

[2:59] Sprachen zu beherrschen, sondern eigentlich eher als Einführungskapitel in die Konzepte. Auch wenn

[3:04] das Kapitel Konzepte noch kommt, das ist nämlich das nächste, ich glaube Kapitel 10, aber die

[3:08] Grundlagen der Programmierung, finde ich persönlich, kann man sehr schön nutzen, um eben genau das,

[3:13] sowas wie eine Vorschleife, eine If-Bedingung und so weiter, mal im Detail sich anzuschauen. Und

[3:18] halt auch Grundlagen der Böckter-Rotierung sind da halt im Kapitel Java drin. Von daher,

[3:21] ich fand dieses Kapitel sehr sehr hilfreich, gerade auch für Einsteiger kann man das absolut

[3:26] empfehlen, die Sachen durchzugehen. Man wird danach die drei Programmiersprachen nicht in

[3:29] Tiefe beherrschen und dann gleich seine ersten Projekte umsetzen können damit, das ist klar,

[3:33] aber so als ersten Einstieg finde ich das Kapitel eigentlich sehr gut geeignet. Ja,

[3:39] dann steigen wir doch vielleicht direkt mal ein. Also unter Glieder ist das Kapitel in 9.1,

[3:43] die Programmiersprache C, dann 9.2 Java und 9.3 Python. Und ich würde sagen, wir steigen einfach

[3:49] mal dann direkt ins Kapitel 9.1 ein mit der Programmiersprache C. Aus meiner inzwischen

[3:55] mehrjährigen Erfahrung als IHK-Prüfer kann ich sagen, dass C für Abschlussprojekte nicht

[4:00] allzu verpreist ist, zumindest bei meiner IHK. Also ich habe noch nicht ein einziges Abschlussprojekt

[4:04] mit C wirklich gesehen. Es werden da schon eher, sage ich mal, in Anführungszeichen modernere

[4:09] Programmiersprachen benutzt, aber C ist heute immer noch immens wichtig in der Praxis. Also

[4:15] wenn ich mir anschaue, was für Hardware und Software alles mit C läuft, also wenn man sich

[4:19] an die ganzen Embedded-Systemen zum Beispiel orientiert, ja die laufen alle mit C. Also

[4:25] ich weiß nicht, eine Kühlschranksteuerung und so weiter oder irgendwie Hardware in der Bahn

[4:31] oder keine Ahnung was. Also es wird alles mit C heute noch gemacht, außer natürlich, sobald die

[4:37] Geräte irgendwie mehr Speicher und mehr CPU kriegen, kann man es inzwischen natürlich auch mit

[4:40] anderen Plattformen machen, Java und so weiter, das ist klar. Aber es gibt immer noch sehr viele

[4:43] Embedded-Systeme, die halt mit C laufen. Und C ist halt so ein Urgestein der Programmierung und

[4:48] da gibt es halt auch ganz viele tolle Konzepte, was heißt toll, also Pointer, ich weiß es nicht.

[4:52] Wer damit schon mal gearbeitet hat, findet die vielleicht nicht unbedingt ganz so toll,

[4:55] gerade als Einsteiger. Aber es ist halt ein wichtiges Prinzip und ich selber musste auch

[5:00] noch C lernen in meinem Studium und ich fand es auch richtig und wichtig, das zu tun, weil man

[5:04] dabei halt noch viel, viel mehr über den Computer und die Arbeitsweise des Computers lernt, als wenn

[5:09] man halt eine noch higher-level-Programmiersprache benutzt, wie zum Beispiel Java oder C-Sharp oder

[5:14] sowas. Bei C kann man sich halt auch ziemlich ins Bein schießen, gibt es auch so ein lustiges

[5:18] Comic für, irgendwie fällt mir gerade nicht ein, vielleicht finde ich das wieder und packe das in

[5:21] die Show-Notes, dass man sich mit C also wirklich nicht nur in den Fuß schießen kann, sondern so

[5:25] ziemlich überall hin, weil man nämlich gerade mit diesen Pointern einfach die wildesten Dinge tun

[5:29] kann. Aber genug der Vorrede, also C ist eine wichtige Programmiersprache, wobei es halt in

[5:33] der Praxis, in der IHK-Prüfung wie gesagt nicht so häufig vorkommt, aber wenn du gerade in einem

[5:37] Unternehmen arbeitest, wo C oder C++ quasi als objektorientierter Aufsatz auf C eingesetzt wird,

[5:43] dann weißt du da sicher mehr drüber als ich. Also ich kenne C persönlich auch nur aus der

[5:48] Vorlesung, wo ich das mal benutzen durfte, um nebenläufige Programmierungen zu lernen,

[5:53] ansonsten ist C halt eine prozedurale Programmiersprache, es hat also nix mit Objektorientierung

[5:59] oder sonst was zu tun, sondern ich kann damit ausschließlich die Sachen benutzen, die ich auch

[6:02] in meiner Lernzyklone zu Algorithmen schon mal durchgekaspert habe, nämlich die Prozedur,

[6:07] ach die Prozedur sag ich schon, die Sequenz, also das Abarbeiten von Arbeitsschritten nacheinander,

[6:12] dann die Verzweigung, sowas wie if und switch case und dann die Wiederholung, also sowas wie

[6:16] eine Vorschleife, Y-Schleife und so weiter und das kann man wunderbar mit C alles machen. Außerdem

[6:20] kann ich natürlich noch Prozeduren und Funktionen definieren, deswegen ist es halt eine prozedurale

[6:24] Programmiersprache. Ich finde den Einstieg in die Programmierung mit der Sprache C eigentlich auch

[6:29] sehr gut gewählt. Hier im Handbuch für Fachinformatiker werden in diesem Kapitel so

[6:33] richtig allgemein grundlegende Begriffe erklärt, wie zum Beispiel Unterschied zwischen Syntax und

[6:38] Laufzeitfehler oder solche Dinge wie zum Beispiel eine Variablen-Deklaration, eine Wertzuweisung,

[6:44] eine Kontrollstruktur, was ist das überhaupt? Also wirklich so völlige Basics, die jeder

[6:48] Programmierer eigentlich kennen muss, nicht nur eigentlich, die muss man kennen, weil es die in

[6:52] jeder anderen Programmiersprache auch gibt und die werden hier wirklich von Null an sauber eingeführt

[6:57] und gut erklärt. Von daher kann ich dieses Kapitel absolut empfehlen, auch für jemanden,

[7:01] der noch nicht programmiert hat, einfach für diese Grundlagen. Also gerade für solche

[7:05] Begriffsdefinitionen hat mich überrascht. Ich wusste schon gar nicht mehr, dass es in dem Kapitel

[7:09] halt so beschrieben ist. Ich habe halt nur im Inhaltsverzeichnis mal durchgeguckt und gesagt,

[7:13] das wird ja spannend. Aber dass halt genau diese Grundlagen da drin sind, finde ich eigentlich ganz

[7:17] toll. Also ich habe es auf jeden Fall nochmal wieder auf meine Liste genommen für meine

[7:20] zukünftigen Azubis, dass gerade für solche allgemeinen Sachen, wo man eigentlich jeder

[7:26] irgendwie denkt, dass er das weiß, also zum Beispiel sowas wie der Begriff der Variable.

[7:29] Das muss eigentlich jeder wissen, was das ist, aber wenige Prüflinge können das natürlich

[7:33] erklären. Und ich sehe dann hier zum Beispiel im Kapitel direkt unter der Überschrift Variablen,

[7:39] wie bereits erwähnt, ist eine Variable ein benannter Speicherplatz. Punkt. Das ist eine

[7:43] knackige, kurze und korrekte Definition und das sind genau die Dinge, die ich auch brauche,

[7:47] um meine Azubis vorzubereiten auf die Prüfung. Und von daher würde ich dieses Kapitel absolut

[7:51] empfehlen für diese ganzen Grundlagenbegriffe. Außerdem werden auch bestimmte Datentypen

[7:56] eingeführt, wie zum Beispiel int, char, double, alles, was man so kennen muss, sage ich mal,

[8:00] was es auch in so ziemlich jeder anderen Programmiersprache gibt. Das wird hier schön

[8:03] erklärt mit Wertebereich und was man damit tun kann, Operatoren, Kontrollstrukturen, natürlich

[8:08] if wird selbstverständlich hier eingeführt und natürlich auch ein Switchcase, wobei man das in

[8:12] der Praxis vielleicht heute nicht mehr so häufig benutzen sollte, aber das ist eine andere Frage.

[8:16] Aber auch sowas wie eine Funktion, eine Prozedur, das wird hier alles erläutert, sodass man das

[8:21] also wirklich wunderbar lesen kann und noch mal diese Grundlagen wiederholen kann, auch ohne

[8:25] vielleicht im Hinterkopf zu haben, dass man danach wirklich mit c jetzt programmieren will,

[8:28] sondern ich verstehe die ersten Seiten des Kapitels tatsächlich so als allgemeine Einführung in die

[8:33] Programmierung. Genau dafür kann ich es auch absolut weiter empfehlen. Die ganzen Inhalte,

[8:37] die wir da sehen, sind natürlich auch dann hochgradig prüfungsrelevant, sodass es also

[8:41] auch sehr gut passt, wenn du dich auf die Prüfung noch mal vorbereiten willst und so ein paar allgemeine

[8:45] Begriffsdefinitionen dir noch mal anschauen willst, kann ich das Kapitel absolut empfehlen.

[8:49] Ja und dann gibt es natürlich auch noch einen großen Bereich, um die Pointer zu erläutern.

[8:53] Das ist ja auch ein wichtiges Konzept, was auch in c absolut häufig Anwendung findet,

[8:57] keine Frage, wenn man das nicht verstanden hat, also dieses kleine Sternchen zum Beispiel vor

[9:01] einem Variablenamen, was das doch für einen Riesenunterschied macht, ob das da steht oder

[9:05] nicht, das sollte man sich mal auf der Zunge zergehen lassen. Und ich finde eigentlich,

[9:08] auch wenn man in moderneren Programmiersprachen nicht unbedingt mit Pointern arbeitet oder gar

[9:12] nicht arbeiten kann, finde ich eigentlich das Pointer-Kapitel sehr schön, weil zum Beispiel

[9:16] hier erläutert wird der Unterschied zwischen Call-by-Reference und Call-by-Value und das ist

[9:20] etwas, was es auch in jeder anderen Programmiersprache gibt und was meiner Meinung nach auch jeder

[9:24] Prüfling erklären können muss, weil es auch wirklich ein grundsätzliches Verhalten in

[9:28] Programmiersprachen ist, ob halt eben Parameter bei Value oder bei Reference übergeben werden.

[9:32] Nochmal als kurze Auffrischung, Call-by-Reference bedeutet, dass, wenn ich einen Parameter in eine

[9:37] Methode oder eine Funktion übergebe und der Parameter in dieser Funktion geändert wird,

[9:42] dass sich diese Änderung auch auf den Aufrufer durchschlägt. Das heißt,

[9:46] auch in der aufrufenden Methode ist zum Beispiel der Wert einer Variable nachher verändert,

[9:50] wenn der Parameter in der Funktion, die diesen Parameter bekommt, verändert wurde und das ist

[9:55] bei Call-by-Value nicht. Bei Value wird nämlich der Wert einmal kopiert in eine neue Variable,

[10:00] die diesen Parameter darstellt und egal, was daran manipuliert wird, der Aufrufer

[10:04] kriegt nichts davon mit, wenn eben bei Value gearbeitet wird. Und das ist auch so eine ganz

[10:10] allgemeine grundsätzliche Geschichte, die man unbedingt können muss und die wurde hier,

[10:14] wie ich finde, schön im Kapitel erklärt. Allerdings geht es dann weiter im letzten

[10:20] Unterkapitel des Kapitels, die C-Standard-Bibliothek und da werden jetzt einige Sachen

[10:24] durchgesprochen, die für die Praxis jetzt nicht ganz so relevant sind, sind aber auch nicht mehr

[10:28] allzu viele Seiten, fünf, sechs Stück, glaube ich, und da wird jetzt auf C-Besonderheiten

[10:32] eingegangen und das würde ich mir dann tatsächlich sparen. Zumindest für die Prüfungsvorbereitung

[10:36] ist es irrelevant, denn, das habe ich schon öfter mal hier im Podcast erzählt, alles,

[10:39] was spezifisch für eine Programmiersprache ist, wird niemals in einer Prüfung abgefragt,

[10:44] weil halt nicht sichergestellt sein kann, dass jeder Prüfunger draußen eine bestimmte

[10:48] Programmiersprache kennt, denn es gibt so viele verschiedene Programmiersprachen,

[10:51] da kann man jetzt nicht genau abfragen, wie ist denn das jetzt in C gelöst. Das wäre einfach

[10:56] unfair, deswegen wird so etwas nicht abgefragt. Das gibt es in den anderen beiden Kapiteln auch

[11:00] noch. Bei Java und bei Python gibt es auch eine kleine Vertiefung oder, sage ich mal,

[11:04] einen Ausblick in die Standard-Bibliotheken oder in Spezifika der Programmiersprachen und

[11:09] das spare ich mir dann hier für das Review auch. Das ist natürlich, wenn ich mit Java,

[11:12] Python, C arbeite. Eine andere Frage, da muss ich das kennen, keine Frage, das ist dann mein

[11:17] Alltagsgeschäft, sage ich mal, aber für so eine Prüfungsvorbereitung ist das irrelevantes Wissen,

[11:21] deswegen überspringe ich das jetzt auch und bin dann auch damit mit C schon durch und komme jetzt

[11:26] direkt zum nächsten Unterkapitel, nämlich zu Java. Und das Kapitel beginnt eigentlich sehr

[11:32] schön mit einer kleinen Einführung, wo Java herkommt und dann gefällt mir eigentlich ganz

[11:35] gut, dass es auch direkt eine Liste der Unterschiede gibt zu C. Also das heißt,

[11:40] wenn ich jetzt mit einer neuen Programmiersprache weiter mache und weitergehende Konzepte mir

[11:43] angucke, dann sollte ich vielleicht auch verstehen, wo denn jetzt eigentlich der

[11:46] Unterschied liegt zwischen beiden Programmiersprachen. Und ich finde es auch sehr

[11:50] wichtig, gerade für die Prüfung, dass ich meine Programmiersprachen auch voneinander abgrenzen

[11:54] kann und die zum Beispiel, sage ich mal so, kategorisieren kann. Ich hatte es in einer

[11:58] früheren Episode schon mal gemacht, so was wie, wie ist die Typisierung oder gibt es,

[12:03] sind die C-ähnlich, also zum Beispiel mit geschreiften Klammern oder eher sowas wie

[12:07] Ruby, wo halt mit do und do and und solche Sachen irgendwie, do und end, Entschuldigung,

[12:12] nicht do end, gearbeitet wird. Und da gibt es halt verschiedene Klassifizierungen,

[12:16] wie ich Programmiersprachen einsortieren kann. Und das finde ich eigentlich sehr schön,

[12:19] auch an diesem Kapitel, dass man halt drei völlig unterschiedliche Sprachen sich mal

[12:22] anschaut und dann wirklich auch hoffentlich am Ende versteht, was denn die konkreten

[12:27] Unterschiede eigentlich jetzt in der Praxis auszeichnet und wie ich das merke oder was

[12:31] meine Vor- und Nachteile sind bei der Programmierung. Ja, was natürlich dann im Java-Kapitel als erstes

[12:36] dazukommen muss, ist logischerweise die Objektorientierung. Ohne die geht natürlich

[12:39] nichts in Java und so würde ich dieses Kapitel jetzt auch so ein bisschen verstehen. Nicht

[12:44] unbedingt als Einführung in Java, sondern als allgemeine Einführung in die Objektorientierung.

[12:48] Wie man beim C-Kapitel so ein bisschen die prozedurale Programmierung kennenlernte,

[12:52] ist es jetzt hier bei Java die Objektorientierung, die da im Fokus steht. Natürlich brauche ich eine

[12:57] konkrete Sprache, um die Syntax zu zeigen und auch die Konzepte zu verdeutlichen, aber ich

[13:02] empfehle dieses Kapitel weiter als allgemeine Einführung in die Objektorientierung. Denn als

[13:06] Einführung in Java ist es mir viel zu kurz. Also das reicht auf keinen Fall. Da kannst du dir zum

[13:11] Beispiel die Java-Insel angucken mit selbst über 1000 Seiten nur für eine Einführung in Java. Also

[13:17] da kommen wir mit. Ich gucke mal eben nach, wie viele Seiten sind das hier. Kann ich das irgendwie

[13:20] sehen? Das sind 20 Seiten. 20 Seiten Einführung in Java, das reicht natürlich bei weitem nicht aus.

[13:27] Für das gesamte Kapitel. Und das ist natürlich für so eine Prüfungsvorbereitung lächerlich,

[13:32] aber als Einstieg, wenn ich davon noch nie was gehört habe, finde ich es sehr gut geschrieben.

[13:35] Da kann man die wichtigen Konzepte, wie zum Beispiel Objektorientierung inklusive Vererbung

[13:40] und auch Interfaces, werden hier auch schon genannt. Das heißt also, das ist ein kurzer

[13:44] Überblick über so wirklich zentrale Konzepte, die auch immer wieder in der Abschlussprüfung

[13:48] gefragt werden. Aber um das natürlich dann zu beherrschen und in der Praxis anzuwenden,

[13:52] reicht das bei weitem nicht aus. Es kann wirklich nur ein kleiner Überblick sein.

[13:56] Weiter geht es dann auch im Kapitel mit etwas java-spezifischen Sachen, obwohl das schon eher

[14:03] in vielen Sprachen heutzutage vorhanden ist. Sowas wie eine Collection, also eine List auf

[14:08] irgendwas. Also eine generische Klasse. Das wird jetzt hier als nächstes erläutert. Und am Ende

[14:12] auch noch mal Enumerations. Die gibt es ja auch in so ziemlich jeder anderen PoE-Sprache,

[14:16] die ich mir vorstellen kann. Also C-Sharp, Java, welche von denen jetzt noch einen? Weiß ich nicht.

[14:21] Auf jeden Fall sehr viele andere PoE-Sprachen haben auch dieses Konzept einer Enumeration,

[14:24] sodass ich die Einführung in diese beiden Begrifflichkeiten, also Collections und Enums,

[14:29] eigentlich sehr sinnvoll finde hier an der Stelle und ich das auch so ein bisschen losgelöst von

[14:33] Java betrachten würde. Der Rest des Kapitels ist dann allerdings wirklich wieder java-spezifikum.

[14:38] Wie kann ich zum Beispiel eine Datei öffnen mit Java? Das sind natürlich Sachen, klar,

[14:42] für die Praxis interessant, für die Prüfung eher weniger. Deswegen überspringen wir das einfach

[14:47] mal und landen auch schon am Ende der 20 Seiten, das geht nämlich ratzfatz, mehr ist da gar nicht

[14:51] mehr drin im Kapitel und sind dann beim weitaus längsten Kapitel, also Unterkapitel von 9 und

[14:57] zwar die Sprache Python. Und Python, das sind, ich rechne das gerade mal durch, so um die 70

[15:05] Seiten ungefähr, ist also von den drei Kapiteln das längste und hier wird auch einiges noch mal

[15:09] im Detail behandelt. Das gehen wir doch vielleicht mal eben kurz durch. Python ist jetzt, wie schon

[15:15] erwähnt, eine komplett andere Programmiersprache als C und Java, ist halt als allererstes mal

[15:19] dynamisch typisiert. Das heißt, das Programmieren ist erstmal völlig anders als zum Beispiel in

[15:23] Java, wo ich jeden Typ am besten 37 mal kennzeichnen muss und der Compiler mir alle

[15:28] möglichen Sachen verbietet. Python ist halt dynamisch, da brauche ich erstmal gar keine

[15:31] Typen und ich kann zum Beispiel einen String, einem Integer zuweisen und hin und her, denn

[15:36] die Variablen haben zum Beispiel gar keine Datentypen. Und was ich an Python noch insbesondere

[15:40] ganz interessant finde, ist, dass sie whitespace-sensitive, nennt man das so, weiß ich

[15:44] gar nicht, ist, also dass das whitespace, das Leerzeichen, das Einrücken relevant ist. Und das

[15:50] finde ich ganz schön deswegen, weil das mich dazu zwingt, meinen Code sauber zu formatieren. In Java

[15:56] und in C, da kann ich halt schreiben, wie ich will, da kann ich mit Tabs einrücken oder überhaupt

[16:00] nicht einrücken, alles in eine Zeile klatschen, ganz egal. Das geht in Python gar nicht, weil

[16:04] der Compiler das dann nicht kompiliert. Das heißt, wie ich eine Zeile einrücke, das hat

[16:11] automatisch eine Auswirkung auf die Interpretation des Codes. Und das finde ich eigentlich eine ganz

[16:15] tolle Sache. Ich kenne wenig andere moderne Sprachen, die diese Eindrückung so forcieren

[16:20] wie Python. Eigentlich kenne ich keine andere, muss ich ehrlich sein. Von daher, das ist wieder

[16:25] so ein kleines Alleinstellungsmerkmal von Python. Finde ich aber irgendwie auch echt ganz cool,

[16:29] weil ich halt keinen gruseligen, schlecht eingerückten, schlecht strukturierten Code

[16:34] schreiben kann und mir auch solche Dinge wie zum Beispiel bei einer if-Anweisung, wo ich keine

[16:40] geschweiften Klammern setze, kann es mir halt nicht passieren, dass ich dann, wenn ich irgendwas

[16:43] in dem if-Statement, in dem Body des if-Statements ergänzen will, dass es dann auf einmal nicht mehr

[16:49] zum if zählt, weil zum Beispiel ich die Klammer vergessen habe und jetzt auf einmal zwei Zeilen im

[16:52] Body stehen, aber nur die erste für das if herangezogen wird. Das kann mir in Python nicht

[16:57] passieren. Wenn die Einrückung korrekt ist, dann sind die Klammern im Prinzip egal. Nicht nur im

[17:02] Prinzip egal, die Klammern sind egal. Ich brauche sie nämlich nicht, weil halt die Einrückung die

[17:06] ganze Struktur des Codes für mich vorgibt. Auch sehr interessant zu sehen, noch mal, wenn du es

[17:11] noch nie in anderen Polymer-Sprachen gesehen hast, ist, dass halt nicht mehr CamelCase gearbeitet

[17:15] wird, standardmäßig zum Beispiel für Variablen, sondern mit der SnakeCase. Das heißt, Wörter

[17:19] werden mit Kleinbuchstaben komplett geschrieben und neue Wörter werden mit einem Unterstrich,

[17:24] einem Underscore, hintereinander geschrieben. Da das so ein bisschen aussieht wie eine kleine

[17:28] Schlange, nennt man das auch SnakeCase. Das heißt, wenn ich jetzt erstmal von Java direkt zum

[17:33] Python-Kapitel wechsle, dann sieht das erstmal alles komplett anders aus. Die Bezeichner sehen

[17:38] anders aus, die Typisierung ist nicht vorhanden. Also das ist schon ein krasser Umstieg und genau

[17:42] deswegen würde ich auch jedem Prüfling mal empfehlen, einfach in einer dynamisch typisierten

[17:47] Sprache zu arbeiten, beziehungsweise in einer statischen, wenn man noch nie in einer solchen

[17:51] gearbeitet hat. Also wenn du zum Beispiel in deinem Tagesjob mit Java arbeitest, schau dir

[17:56] unbedingt mal eine dynamische Polymer-Sprache an. Wenn du in deinem Tagesjob mit Python arbeitest,

[18:00] schau dir mal eine statisch typisierte Polymer-Sprache an, einfach weil diese beiden

[18:05] Welten so extrem unterschiedlich sind und beide haben halt ihre Vor- und Nachteile. Man kann gar

[18:09] nicht pauschal sagen, das eine ist besser oder schlechter als das andere. Sie sind einfach

[18:12] komplett anders und du musst halt auch am Ende deiner Ausbildung eigentlich entscheiden können,

[18:17] welche Art von Polymer-Sprachen denn für welche Sachen gut oder schlecht geeignet ist. Von daher

[18:22] würde ich dir einfach empfehlen, einfach mal eine andere Polymer-Sprache auszuprobieren,

[18:26] die anders typisiert ist als die, die du den ganzen Tag lang benutzt.

[18:30] Was Python auch cooles mitbringt, das ist eine sogenannte REPL, R-E-P-L, das ist die

[18:36] Abkürzung für Read, Eval, Print, Loop. Also einlesen, evaluieren, ausgeben und dann

[18:43] das ganze von vorne anfangen. Die REPL. Das ist quasi eine interaktive Shell, wo

[18:47] ich die Befehle der Programmiersprache direkt eingeben kann und auch das

[18:51] Ergebnis sofort sehe. Und viele moderne Programmiersprachen bringen so eine REPL

[18:54] mit. In Java 9, was irgendwann 2017 angeblich kommen soll, wird auch so eine

[19:00] REPL integriert endlich. Das kennst du vielleicht schon von anderen

[19:04] Programmiersprachen oder gar nicht von Programmiersprachen, vielleicht sogar von einer Shell. Die PowerShell

[19:07] zum Beispiel ist ein sehr gutes Beispiel dafür. Alles, was du auf der Shell

[19:10] direkt eingibst, könntest du auch eins zu eins in einem Skript hinterlegen und

[19:14] dann wäre es quasi ein ausführbares Programm. Und du kriegst aber durch diese

[19:17] interaktive Shell ein ganz schnelles Feedback. Du musst dir jetzt nicht wie

[19:20] zum Beispiel in Java immer eine public static void main definieren, um

[19:24] irgendwelche kleinen Codeschnipselchen auszuprobieren, sondern du könntest einfach

[19:27] eine Shell aufmachen, tippst das da ein und kriegst vielleicht sogar, keine Ahnung,

[19:30] mit Steuerung, Leertaste oder wie auch immer, eine Codevervollständigung in

[19:33] dieser Shell. Sodass du also wirklich ganz, ganz schnell einfach mal einen

[19:37] Prototypen basteln kannst und ausprobieren kannst. So ein bisschen

[19:40] gucken kannst, welche Methoden gibt es denn an dem Objekt, was passiert denn,

[19:43] wenn ich die Methode aufrufe mit diesem Parameter, wie, was kommt da zurück und so

[19:46] weiter. Also es ist wirklich so ein bisschen fürs Explorative Entwickeln.

[19:49] Einfach mal ausprobieren, was gibt es denn. Gucken, wie das funktioniert, wie

[19:52] sich das verhält. Dafür ist so eine REPL echt cool.

[19:56] Ich muss sagen, der Rest des Python Kapitels ist nicht mehr ganz so

[20:00] interessant. Es wird jetzt sehr, sehr viel Code gezeigt, sehr viel Spezifika von

[20:04] Python, wie die Listenverarbeitung ist und Maps und Objektorientierung und so

[20:09] weiter und so fort. Ist eine tolle Sache, sollte man auch können, aber vielleicht

[20:13] nicht unbedingt in Python, wenn man nicht täglich damit arbeitet. Und es sind

[20:16] jetzt auch keine so neuen Konzepte mehr dabei, dass ich sage, Mensch, das muss ich

[20:20] mir noch mal angucken für eine Prüfung. Das Einzige, was im Kapitel noch

[20:23] eingeführt wird, sind Lambda-Ausdrücke und die würde ich mir unbedingt anschauen.

[20:28] Das ist eigentlich in fast jeder Programmiersprache, in jeder modernen

[20:31] heute Standard, dass ich Lambdas benutzen kann. Und diese kleine Einführung, die ist

[20:34] insgesamt vielleicht auch ein bisschen kurz geraten, aber trotzdem ist es so ein

[20:38] erster Hinweis darauf, was es ist. Was ist ein Lambda-Ausdruck? Also quasi einfach

[20:41] eine anonyme Funktion. Wenn du bislang noch nichts davon gehört hast, ein

[20:45] Lambda-Ausdruck ist eine Möglichkeit, um eine anonyme Funktion schnell

[20:50] und mit wenig Code zu definieren. Das heißt, in den meisten Programmiersprachen ist es ein

[20:53] Einzeiler, um so eine Funktion zu definieren und die kann ich dann zum

[20:57] Beispiel an andere Funktionen als Parameter geben. Und damit ermöglichen

[21:01] sich mir ganz neue Wege der Programmierung. Ich kann zum Beispiel

[21:05] solche higher-order-functions aufrufen, so etwas wie zum Beispiel eine

[21:09] Filterfunktion an einer Liste. Und dieser Filterfunktion gebe ich eine Funktion

[21:13] rein als Parameter und die Filterfunktion führt diese Funktion dann

[21:17] für jedes Element der Liste aus und wenn diese Funktion zum Beispiel

[21:22] true zurückgibt, dann packt sie das Ergebnis, packt die Elemente, für die die

[21:27] Funktion true zurückgibt, in eine neue Liste und somit ist dann am Ende des

[21:31] Filteraufrufs meine Liste eben gefiltert, wie der Name schon sagt. Und ich muss

[21:36] aber nicht jedes Mal in der Filterfunktion programmieren, wie sie

[21:39] gefiltert werden soll, sondern diese Funktion wird von draußen als Parameter

[21:43] reingegeben, so dass ich also eine Möglichkeit bekomme, Funktionen zu

[21:47] programmieren, die sich auf andere Funktionen verlassen und somit eine ganz

[21:51] generische Funktion schon wieder bereitstellen. Und diese generischen

[21:57] Funktionen sind halt zum Beispiel map, filter und reduce. Die werden jetzt im

[22:01] Kapitel hier zwar nicht erklärt, aber die solltest du dir unbedingt mal für die

[22:04] Prüfung angucken, denn es ist ein ganz wichtiges Prinzip eigentlich heute in

[22:07] allen Sprachen. Von daher, das jetzt nur als kleiner Ausflug hat jetzt nichts

[22:11] mit dem Kapitel hier direkt zu tun, aber da Lambdas halt so einen schönen Einstieg

[22:14] in diese funktionale, ich sage jetzt mal nicht die funktionale Programmierung, aber

[22:18] diese Konzepte der funktionalen Programmierung bieten, würde ich das

[22:22] doch als Anlass nehmen und nochmal ein bisschen zu vertiefen und mal gucken, zu

[22:25] gucken, was kann ich denn mit diesen Lambdas eigentlich anstellen. Ich weiß

[22:28] jetzt, wie die funktionieren und wie ich den definiere, aber was habe ich denn

[22:31] jetzt davon? Was bringt mir das? Und da würde ich dieses Kapitel als ersten

[22:35] Anlass nehmen, da mal einfach nachzuforschen.

[22:38] Ansonsten haben wir halt ganz viel weiteren Kram hier drin, der irgendwie

[22:42] auf Python eingeht und dann auch die Standardbibliothek, wieder ein paar

[22:45] Sachen, die in Python eingebaut sind und so. Ist eine tolle Sache, für die Prüfung

[22:48] wie gesagt irrelevant, deswegen gehen wir das jetzt nicht im Detail durch, sondern

[22:52] schließen das Kapitel im Prinzip schon ab. Also wir sind jetzt heute mal ein

[22:55] bisschen schneller fertig als sonst, finde ich auch gar nicht schlimm.

[22:58] Wie gesagt, das Kapitel kann ich absolut empfehlen, guckst dir unbedingt mal an.

[23:01] Du kriegst einen guten Überblick über drei völlig unterschiedliche

[23:05] Primiersprachen, einen guten Einstieg in unterschiedliche Konzepte, aber auch die

[23:09] absoluten Basics wie Variabendefinitionen, Deklarationen, Schleifen, Objektorientierung

[23:14] und auch Lambda-Ausdrücke sogar, was heutzutage ja auch wirklich wichtig ist.

[23:17] Und das alles auf wie viele Seiten hat das ganze Kapitel? Ich habe jetzt gar

[23:21] nicht geguckt, es ist jetzt nicht unbedingt das längste Kapitel, aber mit

[23:24] 120 Seiten hat das Ding insgesamt. Und du musst aber noch die

[23:28] Übungsaufgaben abziehen. Also ich sage jetzt mal roundabout so 100 Seiten.

[23:31] Auf den 100 Seiten wirklich einen guten Überblick und hast am Ende auch einiges

[23:35] an Grundlagen noch mal aufgefrischt, wenn du sie nicht schon kanntest. Von daher

[23:39] absolute Leseempfehlung von meiner Seite für dieses Kapitel. Aber die absoluten

[23:44] Details der einzelnen Primiersprachen, die kannst du dir dann tatsächlich auch

[23:48] sparen. Das wird auf jeden Fall nicht prüfungsrelevant. Und wenn du in einer

[23:52] der Primiersprachen in deinem Dayjob arbeitest, dann reicht das Kapitel

[23:55] natürlich auch auf keinen Fall. Dann wirst du dir ein separates Buch natürlich

[23:58] angucken müssen, wie zum Beispiel die Java Insel. Für Java und für C und Python

[24:04] kann ich dir nichts empfehlen, denn da habe ich noch kein Buch gelesen, ehrlich

[24:06] gesagt. Aber das wirst du dann selber besser wissen, wenn du mit den Sprachen

[24:09] arbeitest. Aber wichtig nur, dieses Kapitel reicht natürlich nicht als

[24:12] Einstieg in eine Primiersprache. Es gibt wirklich nur einen Überblick. Gut, damit

[24:17] wäre ich also durch mit Kapitel 9. Dann sage ich wie immer, schau doch mal in die

[24:22] Shownotes zur Episode, wenn du die ganze Links und so weiter dir einschauen willst.

[24:26] Zum Beispiel auch zum Open Book, wo einige der erwähnten Kapitel auch noch

[24:30] online verfügbar sind, komplett kostenfrei. Natürlich beim Galileo Verlag.

[24:33] Die Shownotes findest du wie immer unter anm.wiklapodcast.de

[24:37] slash 93 für die 93. Episode hier heute. Und da findest du auch noch zwei Links zu

[24:43] Podcast-Episoden, wo ich die ganzen Grundlagen, die da erwähnt werden in

[24:47] Kapitel 9 auch wirklich mal abfrage. Das sind sogar zwei Podcast-Episoden, häufige

[24:52] Fragen im Fachgespräch zur Programmierung, Teil 1 und Teil 2. Und da

[24:56] wird alles das abgefragt, was du auch in diesem Kapitel hoffentlich dann gelesen

[25:01] hast. Von daher, wenn du dich dann so ein bisschen auf die Prüfung etwas

[25:03] konkreter vorbereiten willst und schauen willst, was werden denn da jetzt vielleicht

[25:06] für Fragen wirklich im Detail zugestellt, dann hör dir doch die beiden

[25:10] Podcast-Episoden noch mal an. Da kriegst du dann auf jeden Fall meine

[25:15] Antworten auf oder meine erwarteten Antworten, sagen wir mal so, auf die Themen,

[25:20] die vielleicht in der Prüfung dann abgefragt werden. Als Literaturempfehlung

[25:23] zur weiteren Vertiefung hatte ich jetzt schon ein paar mal gesagt, die Java-Insel

[25:27] von Christian Ullenbohm ist der Klassiker, wenn du irgendwas mit Java machen

[25:30] musst. Selber über 1.000 Seiten, also was da nicht drinsteht, das gibt es nicht in

[25:33] Java. Wobei, ne, das stimmt nicht. Es gibt auch noch Version 2 der Java-Insel, das

[25:38] heißt irgendwie, ich weiß den Namen gerade nicht mehr, auf jeden Fall ist das auch

[25:40] noch mal über 1.000 Seiten dick. Und da sind dann alle Sachen drin, die in der

[25:43] Java-Insel 1 nicht drin sind. Und es gibt auch noch der Weg zum Java-Profi, auch

[25:49] noch mal über 1.000 Seiten, da ist noch mal mehr drin. Also ich glaube zu Java. Und es

[25:52] gilt aber sicherlich auch für alle anderen Programmiersprachen. Da wirst du intensiv

[25:55] dicke, fette Literatur finden, wenn du dich da einarbeiten willst. Wenn du aber

[26:00] analog zu diesem Kapitel 9 im Handbuch für Fachinformatiker einfach mal einen

[26:03] netten, kleinen, kurzen Überblick haben willst über verschiedenste

[26:07] Programmiersprachen und was ihre Stärken und Schwächen sind, dann kann ich dir

[26:10] ganz, ganz, ganz wärmstens empfehlen Seven Languages in Seven Weeks. Das ist

[26:16] eines meiner absoluten Lieblingsbücher, ist inzwischen schon ein paar Jährchen

[26:19] alt. Aber da drin werden, wie der Name schon sagt, sieben verschiedene

[26:22] Programmiersprachen vorgestellt. Und zwar auch wirklich mit ganz unterschiedlichen

[26:25] Konzepten. Objektorientiert, funktional, Mischprogrammiersprachen. Da drin ist Scala,

[26:31] Ruby, Haskell, ganz wilde verschiedene Programmiersprachen. Und da kann man

[26:36] wirklich auf, ich glaube, 30, 40 Seiten je Programmiersprache mal die Highlights

[26:40] von teilweise relativ unbekannten Programmiersprachen sich reinziehen und

[26:44] am Ende wirklich mit einem ganz tollen, neuen Eindruck rausgehen. Und

[26:48] vielleicht auch seine eigene Programmierweise so ein bisschen

[26:51] überdenken. Also das ist eine absolute Leseempfehlung von mir.

[26:53] Inzwischen gibt es sogar schon Seven More Languages in Seven Weeks, weil das

[26:58] erste Buch nie ausgereicht hat, weil es immer noch mehr coole Programmiersprachen

[27:01] gibt. Und das ist wirklich was, wo man richtig noch mal so ein bisschen

[27:04] Motivation rausziehen kann und ein bisschen Anregungen für die eigene

[27:07] Programmierung. Das kann ich dir, wie gesagt, wärmstens ans Herz legen, dir das

[27:11] Buch mal anzuschauen. Habe ich in den Shownotes auch verlinkt, wie alles andere,

[27:14] was ich hier heute auch erwähnt habe. Ja, dann kannst du dich, wenn du magst,

[27:19] auch einfach in meinen Newsletter eintragen, wenn du zum Beispiel über die nächsten

[27:22] Termine der Buchclubs, die noch vor uns liegen, informiert werden möchtest.

[27:26] Unter anwendungsentwicklerpodcast.de slash Newsletter kannst du das tun.

[27:30] Kostet nichts. Du kannst dich auch jederzeit wieder austragen, wenn du

[27:33] möchtest. Und du kriegst dann einmal die Woche gesammelt von mir alle neuen

[27:37] Informationen der Websites und auch meine ganzen Links der Woche. In den

[27:40] letzten Wochen habe ich immer so, ja, ziemlich genau zehn Links mit

[27:43] interessanten Inhalt rund um die Ausbildung, Programmierung und so weiter

[27:46] verschickt. Also abonniere das doch einfach, wenn du möchtest. Und wenn nicht,

[27:50] dann trägst du dich einfach wieder aus, wenn es dir nicht mehr gefällt.

[27:52] Außerdem kriegst du natürlich auch Zugriff auf meine ganzen Ressourcen. Hatte ich

[27:55] noch ganz vergessen. Meine Checkliste zum Beispiel zur Projektdokumentation mit

[27:59] über 100 Punkten, was du dir alles angucken solltest, wenn du deine Doku,

[28:02] bevor du deine Doku abgibst hoffentlich und so weiter und so fort. Also schau doch

[28:06] einfach rein, wenn du möchtest. Und als allerletztes habe ich noch eine

[28:11] kleine Bitte an dich. Ich hatte es schon mal erwähnt, bald ist die Episode 100

[28:15] meines Podcasts dran. Und die würde ich ganz gerne so gestalten, dass ich einfach

[28:19] Fragen meiner Hörer dort ganz konkret beantworte. Einfach einen ganzen Haufen

[28:23] an Fragen, der mir so zugetragen wird. Und wenn du noch konkrete Fragen rund um

[28:27] die Prüfung hast oder die Ausbildung oder die Programmierung oder es ist mir

[28:30] eigentlich ganz egal was, wenn du irgendwas hast, was du mich fragen willst,

[28:33] dann schick mir doch einfach eine Mail oder schreib mich bei Facebook an oder

[28:36] bei Twitter oder bei Xing oder sonst wo. Du findest mich überall. Und dann nehme

[28:41] ich diese Fragen gerne in die Episode 100 mit auf. Würde mich freuen, wenn ich

[28:44] mit Hörerfragen dieses coole Jubiläum eigentlich füllen kann.

[28:51] Von daher, nimm einfach Kontakt mit mir auf und schreib mir deine Fragen. Das

[28:55] würde mich sehr freuen. Ansonsten sage ich für heute erstmal

[28:58] vielen Dank fürs Zuhören und bis zum nächsten Mal. Tschüss!