Okay. Darf ich aus der Folge mit an sich rausgehen?
Ja, dankeschön. Okay. Ja, ist jetzt natürlich die Frage,
was habt ihr denn eigentlich von der Funktion Anprogrammierung mitgenommen?
So, vielleicht so das Kernkonzept als allererstes wäre ja schon
mal nicht schlecht. Das ist eher mathematisch.
Ah, das ist schon gut
Vielleicht erlernbar nach. Paradig. Ich hoffe es nicht.
Ich bin kein Deutschlehrer, habe ich gar nicht schreiben.
Okay, ja, genau. Also das Wichtigste ist natürlich
mathematisch angehorcht. Was ist vielleicht so im Gegensatz zur Objektorientierung
? So Objektorientierung hat einen Zustand, hat funktionale Programmierung
im Zustand
Ja, nein, vielleicht. Genau. Oder man sagt dann auch immer,
gerne ist State Fless. Zustandslos. Was für Vorteile fallen denn,
würden euch denn jetzt so einfallen an einen zu,
wenn ich ein Programmierparadigma habe, was zustandslos ist?
Man könnte ja dann quasi auch gerne Ja,
ich kann während der Laufzeit relativ gut Code schrauben, ja.
Oder wenn wir uns jetzt,
also das betrifft euch jetzt natürlich noch nicht ganz so sehr,
aber wahrscheinlich habt ihr alle schon mitbekommen,
so selbst euer Smartphone hat mittlerweile irgendwie so acht Kerne, CPU-Kerne.
Und ein sehr großer Vorteil von zustandslosen Programmierparasigmen ist natürlich,
die kann ich wunderbar auf mehreren CPU-Kernen gleichzeitig laufen lassen.
Weil bei Zustandsbehafteten Programmierparasigmen wie dem Objektorientierten,
da habe ich ja irgendwie das Problem, was passiert eigentlich,
wenn CPUs, tatsächlich wirklich in derselben Nanosekunde auf denselben Speicherbereich zugreifen,
ihn lesen und verändern wollen.
Welche Änderung gewinnt jetzt? Und solche Sachen.
Das habe ich natürlich bei den funktionalen Programmierungen nicht,
weil ich habe gar keinen Zustand.
Ich habe eine Funktion, die halt Eingaben und da kommt
ein Materiebnis raus.
Genau. Was haben wir noch
Er hat nicht nur einen Kumpel, sondern auch einen.
Ja, gut, du hast es jetzt so eine spezielle
Eigenschaft von sehr, sehr vielen Sprachen, der funktionellen Programmierung.
Das hat man aber auch, also zum Beispiel,
wenn man sich Programmiersprachen wie Python anguckt oder JavaScript,
das sind halt auch welche,
die sind mehr oder weniger objektorientiert oder imperativ und sie sind halt auch interpretierte Sprachen.
Also das ist jetzt nicht etwas, was sich
funktionale Programmiersprachen speziell sind. Beispielsweise Java kann man auch interpretiert
laufen lassen
Das habt ihr zum Beispiel damals gemacht mit in hier im Blue Jay,
mit dieser Eingabekonsole da, wo ihr dann so interaktiv Java ausführen konntet.
Das war ja auch eine etwas, eine gewisse Art von Interpretation.
Kann man einen funktionalen Code relativ gut lesen? Ja,
allein vielleicht. Ja, okay, gut. Genau,
er ist erst, er ist Squats und man kann ihn
tatsächlich in den meisten Fällen ein bisschen besser verstehen,
was da eigentlich gerade konkret passiert.
Das werde ich euch jetzt einfach mal, ich habe
noch mal was vorgewartet. Ich habe mir mal gedacht,
ich versuche mal den Verleih-Service-Impel ein bisschen zu funktionalisieren.
Das muss ich nur noch finden. Ja, genau.
Kann man das... Geht es noch größer?
Ich hätte gern einen größeren Fund
Ja, das ist schon ein bisschen besser. Okay.
Genau. Wenn man sich nämlich jetzt einfach mal anschaut,
wie sieht denn eigentlich funktionale Programmierung in Java aus?
Dann merkt man direkt, da ist es deutlich weniger Klammern,
als das, was ihr an Source Code da vorhin mit Racket gesehen habt.
Aber statt Klammern kriegen wir ganz viele Punkte. Ist doch
auch was Schönes. Genau. Jetzt komme ich nämlich direkt zu
dem Punkt, warum ist denn das einfacher zu lesen?
Wenn wir uns jetzt hier diese Methode angucken, Vielleicht etwas Einfaches, genau.
Sind alle nicht verliehen. Na, dann ist ja das Traditionelle,
was wir gemacht haben, ist ja das, was ich hier auskommentiert habe.
Wir machen irgendwie eine lokale Variable. Wir müssen,
wir machen dann da weiter zur Vorschleife, iterieren dann über die gesamte,
über die gesamte Liste drüber und gucken halt auf etwas verliehen ist.
Und wenn wir jetzt uns das im funktionellen Parasik mal angucken,
dann haben wir jetzt, sagen wir jetzt erstmal,
okay, ich möchte das Ding dieses, diese Liste
Du sollst einfach nur noch einen Datenstrom sein,
weil wir wissen, weil funktionale Programmierung arbeitet meistens damit,
ja, ich habe irgendwie so einen Strom an Sachen,
die kommen halt in die Funktion rein und hinten raus kommen,
dann kommt dann das Ergebnis.
Also das ist halt hier so eine Eigenart, die man in Java machen muss,
damit man dann halt sozusagen in dieses funktionale Paradigma eintaucht.
Ja, und was ich da dran halt machen kann,
ist dann, jetzt sagen, okay,
ich habe jetzt diesen Strom an Medien,
die da rauskommen und ich möchte dann auf den Filter anwenden
Das heißt, ich möchte auf jedes Objekt,
was sich in dieser Lüste befindet, möchte ich,
möchte ich einen Filter anwenden und der Filter,
der sieht so aus, dass ich,
dass ich möchte, ich habe hier mein Medium,
das ist meine Variable, die ich gleich benutzen werde.
Dann sage ich, okay, benutzt diese Variable Medium,
um zu prüfen, ob das Medium verliehen ist.
Das gibt mir einen Bujen zurück. Und dieser Bujen entscheidet
darüber, ob aus dieser Filterfunktion das Objekt wieder rauskommt.
Ja, das heißt, wenn jetzt ein Medium nicht verliehen ist. Ja,
also wenn wir uns jetzt das einfach mal anschauen würden,
ich nehme jetzt, nee, nicht Harflife,
sondern... Ich habe hier jetzt irgendwie mein Medium.
Ja, und das hat ja irgendwie sein,
hat ja irgendwie hier
so Zustände
So. Und das nehme ich jetzt und packe das in
diesen Filter rein. Und in diesen Filter ist ja,
habe ich hier erstmal, sage ich, okay,
ich möchte, ich gebe dem, was da jetzt gehen,
was da jetzt hier reinkommt, dieses Medium,
das ist ja erstmal jetzt nur ein namenloses Objekt,
was da reinkommt.
Dieser Referenz, da gebe ich jetzt erstmal einen variablen Namen,
in diesem Fall Medium
Und danach sage ich, was soll mit dieser,
mit diesem Bindestrich und der geschlossenen Krokodilklammer, sage ich dann aus,
was soll denn mit diesem, mit dieser Variable passieren?
Ja, und da rufe ich dann ja die Methode auf, ist verliehen.
In diesem Medium. So. Und wenn jetzt das,
was, und das Wichtige ist, dass Dass das,
was ich hier hinschreibe, das muss ganz am Ende,
wenn das komplett ausgeführt worden ist,
muss das zu einem Buhlen-Evaluiert sein.
Also das darf jetzt irgendwie kein Inwitcher sein oder ein String sein,
sondern das muss in dem Fall ein Buhlen sein.
Weil dann kann jetzt natürlich der Filter sagen,
wenn True, wenn das wahr ist,
dann geht das sozusagen wieder in meinen Stream rein
Und mit diesem Stream könnte ich jetzt, gönne ich beispielsweise,
noch einen weiteren Filter oder sonst was machen. Aber,
also auf diesem Stream kann ich dann wieder jede funktionale,
jedes funktionale Konzept, was in Jahber vorhanden ist, wieder anwenden.
Und wenn das zu Falls evaluiert, ist,
wie das Ding halt schon sagt,
dann geht das dann halt in das Ether.
Das hat irgendwie keine Ahnung
Sonst wohin. Aber es ist halt, also es befindet sich dann danach nicht mehr wieder da drin. Ja. So,
das heißt, wenn wir uns das jetzt angucken, ist,
ich sage hier erstmal, ich möchte, dass das,
dass diese Liste so eins streamen wird, dann,
wenn nicht auf diesen Stream, diesen Filter an, der sagt,
okay, alles, was nicht verdienen ist, fällt weg,
weil dann ist ja, wenn es nicht verliehen ist,
dann kommt da ja Falls raus.
Und jetzt kann ich, und jetzt mache ich Gut,
dass es jetzt eine einige Art von Jahr war.
Ich kann nämlich fragen, wie viele Elemente eigentlich noch in so einem Stream vorhanden sind.
Ja, und das ist halt diese Count-Operation. Genau,
und hier sage ich, okay, wenn das,
was aus diesem Filter rauskommt, wenn das nur null Elemente sind,
dann ist ja das erfüllt,
was wir hier oben haben.
Sind alle
nicht verliehen
Für euch ist es wahrscheinlich jetzt noch,
hier würde ich mir jetzt wahrscheinlich nicht zustimmen, wenn ich sage,
ich finde diesen funktionalen Ansatz deutlich angenehmer zu lesen,
weil halt sehr viel schneller klar wird, was eigentlich passiert.
Aber wenn man sich das,
wenn man das erstmal so ein bisschen so vielleicht zu Hause
auch mal so ein bisschen rumprobiert hat,
es gibt ja hier noch ein paar mehr Klassen in diesem Projekt,
wo man dann halt auch mal versuchen könnte,
wo könnte sich eventuell
irgendwelche Four-It-Schleifen mit diesem funktionalen Paradigma benutzen
Genau. So. Und jetzt habe ich ja schon irgendwie gesagt,
okay, ich habe hier irgendwie, na,
ich habe ja hier diesen Filter und der sah und
da purzelt dann halt auch wieder so ein Stream raus.
Und bei Kauen purzelt jetzt kein Stream raus.
Das heißt, was man da so ein bisschen unterscheiden muss,
ist ein Java.
Wir haben sogenannte Nicht-Terminale
Die machen nichts anderes, als zu sagen,
ich habe einen, ich habe hier einen Stream, Stream.
Dann habe ich halt hier meinen Nicht-Terminal, wenn die Nicht-Terminale Funktion,
und da kommt dann wieder ein Stream raus. Das hat natürlich einen Vorteil,
dass ich jetzt im Gegensatz zu dem,
was ich in der imperativen Programmierung mache oder in der Objekte oder in Produktziehern Programmierung,
wo ich das dann halt immer in so mehrere Zeilen machen muss und dann halt das irgendwie immer wieder in Datenstrukturen reinpacken muss, sich zwischen Ergebnisse.
Kann ich hier machen, kann ich hier einfach sagen,
okay, ich verkette einfach so viele Nicht-Terminale, wie ich lustig bin,
bis ich zu dem Ergebnis komme, was ich haben möchte.
Und dann gibt es noch, wenn es Nicht-Terminale gibt,
dann gibt es natürlich auch noch Terminale.
Die sind dann so aufgebaut, ich habe einen,
die nehmen einen Stream auf, Also die nehmen einen Datenstrom auf.
Und am Ende kommt dann halt irgendein Objekt oder Intelshaw oder
sonst was raus. Aber wichtig ist es,
dass wenn ich so ein Terminal erstmal gemacht habe,
kann ich danach keine weiteren funktionalen Sachen wieder drauf aufrufen.
Okay. Genau, das ist jetzt hier noch eher
was Einfaches
Was soll ich noch? Genau. Na,
und hier an diesem Beispiel kann man das dann doch schon deutlich,
schon mal deutlich ein bisschen besser sehen, was hier eigentlich passiert.
Das heißt, ich habe hier erstmal wieder den Pfad,
dass ich, wir haben ja hier die Pfeilerleihkarten,
das ist ja diese Hashmap,
die ist ja so ein hier Key und dann Value
Und da kann ich mir ja mit der Funktion, äh,
mit der Funktion sage ich schon, mit der Methode Values,
kann ich mir ja, gebe ich mir ja dann an eine Liste.
Auf dieser Liste kann ich dann, wie bei allen anderen Listen,
Laber dann auch wieder sagen, okay, ich möchte,
dass das jetzt keine Liste mehr ist, sondern,
äh, ein Datenstrom, den ich mit funktionalen,
äh, ja, mit funktionalen Funktionen.
Weil Funktionen benutzen kann. Und, ähm,
hier haben wir hier wieder das, äh, der Filter,
den, Haben wir uns ja schon zur Genüge angeguckt.
Dann kommt jetzt etwas, was eventuell in der Vorlesung auch heute dran war.
Das sind Mappings. Das heißt, was da passiert,
ist ja beim Mapping, sage ich ja, ich habe...
In diesem Fall zum Beispiel, ich habe jetzt hier meine Verleihkarte.
Und diese Verleihkarte ist, möchte ich jetzt,
dass ich möchte die Verleihkarte nicht mehr haben,
sondern ich möchte irgendwie
Danach nur noch Medien haben. Also ein Medium.
Das heißt, hier habe ich einen Datenstrom von Vailaikaten.
Und am Ende möchte ich einen Datenstrom von Medium haben.
Warum möchte ich das haben, wenn wir uns jetzt angucken?
Da geht es ja darum, bei dieser Methode,
dass ich Alle Medien haben möchte, also ich möchte eine
Liste von Medien haben, die ein bestimmter Kunde ausgeliehen hat.
Das heißt, das Erste, was ich ja mache,
ist, ich möchte erstmal nur noch alle Verleihkarten haben von diesem Kunden.
Das passiert hier mit diesem Filter. Und da ich ja
jetzt nicht die Verleihkarten selber zurückgeben möchte,
sondern das Medium, mache ich halt hier dieses Mapping.
Das heißt, ich möchte, ich möchte Verleihkarten stecke ich
in die Map rein und Medium soll rauskommen.
Und das passiert dann hier auch wieder mit, dass ich erstmal sage,
okay, ich gebe der, ich gebe den Verleihkarten,
die reinkommen, weil das sind ja erstmal nur Referenzen.
Es ist ja jetzt erstmal nur Daten, denen gebe ich erstmal wieder einen Namen,
damit ich halt das als variablen Namen benutzen kann.
Und dann sage ich, was möchte ich da mit
diesen Karten machen? Und hier sage ich dann,
okay, ich möchte, dass ich aus dem Verleihkarte
das Medium rausziehe
Ja. Und dann habe ich, nachdem ich dieses Mapping angeführt gemacht habe,
habe ich dann einfach nur noch wieder einen Datenstrom von Objekten vom Typ Medium.
Und das ist ja jetzt etwas, was zumindest in dem,
was ich jetzt in der kurzen Zeit der Recherche rausgefunden habe,
in Java, denn ich programmiere fungiere funktional nicht im Jahr,
also ich habe noch nie in Java viel funktional programmiert,
sondern eher ein C,
deswegen war das auch ein bisschen Neuland für mich
Ja, aber ich habe leider keine gute Möglichkeit gefunden,
wie man einen Datenstrom wieder zurückverwandeln kann in eine Liste.
Weswegen ich dann mich hier dazu entschieden habe,
das relativ billig zu machen, indem ich sage,
okay, mach bitte einfach mal ein For-Each,
auch von jedem Medium.
Ich gebe dem Medium den Referenzen,
gebe ich einen Variablennamen und ich fühle das dann halt einfach
eine Liste hinzu und diese Liste gebe ich dann zurück
Das heißt, statt dieser For-Each-Leife mit dem If drin,
irgendwie so als Art,
kann ich das halt auch mit diesen Datenströmen mit den Funktionen machen.
Ja, und das hat dieses, dieses Konzept hat halt natürlich den Vorteil,
dass wenn man erstmal weiß, wie das funktioniert,
dass man damit sehr viel mächtiger ist in der Ausdrucksweise.
Genau, und unsere Ja,
also ich werde die veränderte Verleihsservice-Impult-Klasse auch noch mal hochladen,
wenn ich es nicht eigentlich schon getan habe.
Muss ich mal kurz schauen. Ja, spannend. Dürfte
ich bitte auch. Internet? Nicht? Okay. Gut
, dann nicht. Aber hier darf ich doch Internet,
oder? War das das Richtige? Nee. Okay.
Muss ich noch das richtige Zipp hochladen? Das ist Netzwerk
noch gerade, das ist Falschwisse.
Aber genau
Also das heißt, das könnt ihr euch noch mal
ein bisschen genauer anschauen, was da eigentlich passiert.
Aber eigentlich könnt ihr das,
was ihr heute alles so in der Vorlesung gehört habt,
was in der Kategorie Funktion höhere Ordnung ist.
Das heißt,
wenn ich
Genau, also alles, was in diesem Teilbereich Funktion höhere Ordnung ist,
das ist eigentlich genau das, was ich,
was ich euch gerade in Java gezeigt habe.
Also das, was ihr in Java an funktionalen Paradigma
drin habt, sind halt überwiegend diese Funktion
höhere Ordnung
Funktion, höhere Ordnung, deswegen, weil ich ja,
ich habe ja hier diese Funktion Filter und die nimmt ja entgegen eine Funktion.
Also halt eine Beschreibung, wie denn gefiltert werden soll.
Und das ist halt eine der großen Vorteile der funktionalen Programmierung,
dass ich halt die Code Wiederverwendbarkeit durch solche Funktionen höherer Ordnung,
die dann halt einfach Andere kleinere Funktionen annehmen,
um sie zu beeinflussen, was sie eigentlich machen.
Das könnt ihr euch so ein bisschen vorstellen, wie das,
was ihr mit den Template-Methoden und den Einschubmethoden gemacht habt,
wenn ich jetzt die richtigen Fachbrücke für genutzt habe.
Also es gibt irgendwie mehrere verschiedenen, wie man das nennen kann,
aber ich glaube, das waren die richtigen, oder?
Template. Nee, Einschubmethode ist auf jeden Fall richtig und
das andere ist Schablonen-Mythode, genau, so war das deutsche Wort.
Genau. Also Funktionen, Hörer, Ordnung sind im Prinzip nicht großartig anders zu dem,
nur dass die halt noch ein paar weitere Vorteile haben.
Und zwar, wenn wir uns jetzt einfach mal vorstellen,
was ist denn hier,
genau, wenn wir uns jetzt einfach mal vorstellen,
wir haben unsere Verleihkarten Map hat irgendwas,
wir sind dann irgendwann so im Bereich,
so Verleihsystem hat eine Million Medien drin.
Ja, dann könnte man ja vielleicht schon mal so auf
die Idee kommen, aber ich möchte das gerne parallelisieren.
Ich möchte mehr als einen CPU-Kern benutzen. Wer wüsste jetzt ad hoc,
wie man das hier mit so einer 4each-Leife macht,
dass man dafür sorgt,
dass die auf mehr als einer CPU ausgeführt wird und dass
die Arbeitslast auf alle CPUs richtig verteilt wird und dass dann,
nachdem die Arbeit gemacht worden ist,
die Einzelergebnisse auch wieder richtig zusammen aggregiert werden
Niemand, okay. Ich übrigens auch nicht. Also nicht,
wie es in die Aber geht. Weil in Java muss ich
ernsthaft gestehen, habe ich noch nie parallele Programmierung gemacht.
Das tue ich entweder in eine Sampler oder NC.
Aber deswegen weiß ich halt nicht, wie Java da umgeht mit.
Aber wenn ich das jetzt hier mit diesen funktionalen Sachen mache,
dann sage ich einfach, statt streamen sage ich einfach so,
ja, mach mir mal bitte einen parallelen Stream draus.
Und zack, kümmert sich Java komplett darum
Das heißt, ich habe so eine Zeile Code geändert und
auf einmal benutze ich mehrere CPU-Kerne. Das Problem ist jetzt natürlich,
dass, obwohl wir ja dadurch,
dass wir das Funktionale benutzen und damit ja größtenteils zustandslos sind,
in diesem Datenstrom, spätestens,
wenn wir uns dann ja irgendwie so dieses Ding hier angucken,
so dieses For-Eat,
wo ich dann doch irgendwie auf eine Liste,
die einen Zustand hat,
drauf zugreife,
damit es dann schon
ein bisschen kritisch war
Da muss man dann vielleicht hoffen, dass die Standardlisten Implementation
von Java in irgendeiner Art und Weise damit umzugehen weiß,
wenn mehrere CPU-Kerne gleichzeitig auch wieder zugreifen.
Aber was sie da dann halt beachten müsst,
ist dann halt eventuell mal in die Dokumentation reinzuschauen.
Es gibt da in der Java-Dokumentation zu diesen ganzen Funktionen
Funktionen höherer Ordnung. Steht sehr gut beschrieben, welche,
wenn hier zum Beispiel hier diesen Parallelstream macht,
welche Operation ihr nur noch benutzen dürft auf diesen Parallelen
da an Strom
Ja. Also natürlich filtern ist alles, ist wunderbar okay,
weil der schmeißt ja einfach nur Sachen raus.
Mapping machen ist auch okay. Ja,
es gibt dann auch noch, es gibt dann auch noch
das Falten, was ihr auch in der Vorlesung habt.
Das heißt, ich reduziere alle meinen kompletten Datenstrom dann auf einen Wert.
Das kann man ja auch wunderbar paralysieren. Ich habe,
wenn ich mir das jetzt zum Beispiel anschaue,
ich mache es mir jetzt einfach erstmal einfach,
ich habe zwei CPU-Kerne.
Das ist mein Eierkern, das ist mein zweiter Kern
Ja, und wenn die jetzt halt irgendwie so ein Mapping machen,
also das sind jetzt hier zum Beispiel meine Elemente hier drin.
Ja, und das wird jetzt auf irgendwas Neues gemappt.
Keine Ahnung, gibt es... Die Vierecke werden auf Dreiecke
gemappt und so weiter und so fort. Ist ja das,
was dann zum Schluss passiert, wenn beide fertig sind.
Ja, ich packe das einfach wieder zusammen.
Ja, und das ist dann halt, ja,
mein Datenstrom voll mit Dreiecken
Das lässt sich wunderbarer palparallerisieren, weil Lap ist halt vollkommen unanhänglich,
in welcher Reihenfolge ich das ausführe. Filter ist,
das ist dasselbe Spiel, nur dass ich da nicht sage,
okay, ich sage, vier Ecke sind jetzt drei Ecke,
sondern ich schmeiße dann einfach vier Ecke weg,
stört auch, stört auch nicht die anderen CPU-Kerne,
wenn ich das tue.
Beim Falten, also das Falten ist dann halt so ein bisschen interessant,
also das war hier, das war ja die Map,
parallel, beim Falten Ist da, was da passiert?
Ich habe ja hier meinen Datenstrom 1. Datenstrom 2. Und der
ganze Datenstrom wirkt jetzt irgendwie zu der Zahl 10. Zusammengefaltet und der wird 20.
Was dann halt am Schluss passiert, ist halt,
gut, nehmen wir das Plus und raus um 30.
Das ist ja auch zustandsunabhängig. Je nachdem, da ist es ja egal,
ob ich jetzt In welcher Reihenfolge ich die Sachen falte.
Zumindest in dem Sinne, wie das Falten in Java implementiert ist.
Und solange ich bei Zahlen bin. Wenn ich jetzt natürlich irgendwie anfange,
Strings zu konkatinieren, dann ist es ja doch wieder interessant,
in welcher Reihenfolge das passiert.
Also in den meisten Fällen. Es sei denn,
ich möchte irgendwie so eine Autorenliste mit Komma getrennt machen,
dann ist es ja auch egal, in welcher Reihenfolge die Autoren drinstehen.
Genau. Na, aber das ist halt etwas,
also ja, es kommt,
also es kommt so diese ganze Parallelisierung,
die irgendwie allen Kopfschmerzen bereitet und Menschen zur Verzweiflung bringt
Und auch so lustige Bugs einführen, die, wenn man sie anfängt,
zu deep buggen, auf einmal nicht mehr da sind,
weil man damit die Zeitkomponente in wie die beiden CPU-Kerne miteinander arbeiten,
auf einmal beeinflusst durch das Deebuggen.
Und dann ist der Bug auf einmal weg.
Das sind dann die schönsten Bugs. Na,
also das hat man alles, das hat man fast alles nicht,
aber man muss halt darauf aufpassen,
dass man nicht Dinge macht,
die eventuell dann doch nicht mehr ganz so statelist sind,
wie es eigentlich
die funktionale Programmierung haben möchte
Okay. Aber, also eigentlich,
auch wenn das jetzt halt irgendwie aus der Sicht von Frau Fischer
doch ein bisschen gemein ist zu sagen,
eigentlich interessiert euch wirklich nur diese Funktion höherer Ordnung,
weil das jetzt so das ist,
was ihr eigentlich mitnehmen könnt für das, für,
das kann ich in Java anwenden.
Wenn ihr ernsthaft funktional programmieren lernen wollt,
dann müsst ihr dieses schöne Dr. Recket da euch runterladen,
installieren und damit rumspielen
Ja, aber ich kann euch schon,
also ich kann euch aus Erfahrung sagen, euer, sobald ihr anfangt,
das zu lernen, ist euer neuer Erzfeind die Klammer.
Weil es gibt sehr viele verschiedene Sorten von Klammern.
Und ja, Record benutzt sie alle. Und nein,
es ist nicht egal, welche Klammer ihr schließt.
Also es ist nicht egal, welche Sorte von Klammer ihr Wand schließt,
sondern es muss schon die richtige Sorte von Klammer sein.
Ansonsten drückt ihr was anderes aus. Also es ist dann
schon so ein bisschen, das macht viel, viel Spaß.
Aber man kann damit halt ganz viel schöne Sachen machen,
die halt sehr einfach zu Deep Bugs sind.
Weil so eine Funktion, da packt ihr was rein und dann kommt was raus.
Wenn nicht das rauskommt, was ihr wollt, müsst ihr die Funktion angucken.
Weil in Java ist das so, ja,
ich packe da was in die Methode rein und kommt irgendwie nicht das raus,
was es soll, dann kannst du ja,
muss es nicht unbedingt daran liegen, dass es die Implementation falsch ist,
sondern es kann ja auch daran liegen, dass der Zustand falsch war.
Gut, aber genau, aber Genau. Es könnte eventuell auch hilfreich sein,
euch auch die ganzen Definitionen,
auch wenn ich das selber nicht so mag,
aber sich mal die ganzen Definitionen hier nochmal anzugucken,
was ist eigentlich bei der funktionalen Programmierung, was ist das,
was ist eine Funktion, was ist eine Funktion höherer Ordnung.
Was sind Closures oder das gute Curry, das,
was man, also ich habe mal versucht, so rauszufinden,
wie man diesen Curry-Operator in Java macht und Hab keine zufriedenstellende Antwort gefunden, deswegen.
Ja. Ja, also vieles ist zwar nice to have,
aber das einzig wirklich anwendbar sind die Funktionen höherer Ordnung.
Und was vielleicht auch wichtig ist, das,
was ich hier in diesen Klammern geschrieben habe,
das hat tatsächlich sogar einen Namen und das nennt sich einfach nur Lamda.
Deswegen auch der Einstiegswitz mit dem Half-Life sowohl.
Oder dass das Lamba-Symbol ist.
Genau. Okay
Ja, also soviel jetzt erstmal zum Crashkurs,
was kann ich eigentlich aus der heutigen Vorlesung mitnehmen,
um es dann in Java umsetzen zu können?
Genau. Ja, also gibt es, nimm es erstmal Fragen.
Schau mal, noch einmal speziell jetzt zu dem gezeigt. Und ich hoffe,
dass es jetzt vielleicht so ein bisschen klarer wurde,
warum das vielleicht doch gar nicht mal so schlecht ist,
funktionale Programmierung mal gehört zu haben.
Aber im Idealfall hört man das eigentlich ein Semester lang.
Aber gut. Okay. Okay, gut. Ja.
Wo haben wir noch ein bisschen bei funktionalen Programmierungen sein?
Oder gibt es eventuell etwas, wo der Schuh gerade auch
besonders tockt in die Übung?
Das kommt jetzt eigentlich auch in den Übungen
Nein. Also in den Übungswärtern, die mir bisher
zur Verfügung stehen, habe ich das nicht gesehen.
Und ich bezweifle auch mal sehr stark, dass das noch drankommen wird,
weil das, also das ist auch etwas,
was ich gemerkt habe, als ich das da reinbauen wollte.
Da hatte mir erst mal Eclipse gesagt, so ja,
hm, das Projekt ist aber noch für Java 1.6,
ne, so, da war 1.6,
das kennt ja gar keine funktionalen Sachen.
Und das heißt, das musste dann auch erst mal
umwandeln und da musste ich hoffen,
dass das nicht explodiert,
aber so explodiert
Ich gehe mal nicht davon aus,
dass das in irgendeiner Art und Weise, außer vielleicht,
irgendjemand hat jetzt noch eine wunderbare Idee bei dem Betreuer,
also bei den Betreuern, wie man das vielleicht noch irgendwie,
das Schöne vor Each einbauen könnte oder so, aber wie?
Einfach angesichts des Zeitpunktes, dass diese Vorlesungsfolien vor drei Tagen,
wo ich das letzte Mal in Mudo geguckt habe,
noch gar nicht vorhanden waren im Mudel,
würde ich jetzt mal sagen, nein,
es hört sich nichts in den Übungen ändern.
Es wurde tatsächlich auch gesagt,
dass es nicht gewonnen ist
Emotionale Programmierung langsam wird. Aber in seiner Frage finde ich das,
wie viel davon kommt nach der Ruhe an,
die wir nicht mehr da haben.
Das ist eine
sehr gute Frage