Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python Podcast Episode 58.
Wow, 58.
Ja, gar nicht so schlecht, oder?
Überraschend, wir reden heute über Fluen, Python. Hi Jochen.
Jo, halli, hallo Dominik. Herzlich willkommen.
Und hi Johannes.
Johannes, hi.
Schön, dass ihr da seid.
Ja, schön, dass ihr da seid.
Wir hatten dich ja schon ein paar mal hier, habe ich gehört.
Ich wahrscheinlich, ich glaube ein oder zweimal oder so ungefähr dabei.
Ja, glaube ich auch. Anderthalb oder so.
Wir wollen heute über ein Buch sprechen, Fluen, Python von Luciano Darmalho.
Richtig ausgesprochen? Ich weiß nicht genau.
Ja, oder das haben wir so ein bisschen als Vorlage hergenommen.
Ich würde eher denken, wir, also es wurde, es wurde, wir haben, uns erreichten, genau, uns erreichten irgendwie Zuschriften,
die sagten, ah, mach doch mal ein bisschen was mehr für Anfänger und irgendwie mehr.
Und dann hast du dir das tollste Buch ausgedrückt, wo du dann.
Mein, mein, mein tatsächlich mein Lieblings, Lieblings Python Buch.
Und dann dachte ich, ah ja, da kann man ja vielleicht mal so ein bisschen durchgehen.
Ich lese mal kurz aus dem Buch vor, weil du sagtest, Anfänger.
Anfänger, Jochen.
"If you are just learning Python, this book is going to be hard to follow.
Not only that, if you read it too early in your Python learning, it may give you the benefit that every Python script should leverage special methods and metaprogramming tricks" und so weiter.
Also das steht für alle Leute, die es nicht verstanden haben, es ist kein Anfängerbuch.
Ja, ja gut, aber wir machen ja jetzt nicht Metaprogramming.
Also Metaprogramming Zeugs ist ja auch drin, aber das machen wir ja jetzt gar nicht.
Noch nicht.
Okay, dann steigen wir leicht ein mit Datenstrukturen oder sowas.
Genau, wir fangen jetzt mit so ganz grundlegenden Dingen dann an.
Nicht, dass wir Struktur hätten in dieser Folge, aber wir versuchen es heute.
Ja, wir so ein bisschen.
Also wir hatten ja auch schon mal was zu Dicts gemacht und zu Listen.
Ja, das ist schon spannend.
Und ich weiß nicht, ob wir Strings hatten.
Hatten wir, glaube ich, noch nicht.
Also wir haben darüber schon öfter gesprochen, aber ich glaube, wir haben tatsächlich noch keine Folge dazu gemacht.
Steht noch auf unserer Möchten-wir-gerne-machen-Liste.
Aber vielleicht erst mal zu News.
Gibt es denn was Neues in Python, in der Python-Community oder in Python selbst?
Ja, seitdem wir das letzte Mal aufgenommen haben, ist nicht so wahnsinnig viel passiert.
Ist jetzt auch gar nicht mehr.
Letzte Woche war EuroPython, Jochen.
Ach ja, ja, EuroPython. Wie war denn die EuroPython? War gut, hat Spaß gemacht.
Ja, war cool. Hat sehr viele nette Leute kennengelernt und mit ihnen geschnackt, wie das halt so ist.
Ich weiß aber nicht, ob das einen News-Charakter hat.
Also außer mich persönlich natürlich.
Was ich sehr genossen habe, war tatsächlich Lukas Schlanger und der Python-Rappel-3.13-Talk,
der quasi der letzte war vor der Abschlussrede, wo man so ein bisschen interaktive Möglichkeiten sehen konnte von denen, was so möglich ist.
Das war so ein bisschen eine Mischung aus iPython mit Bund und man konnte richtig coole Sachen machen und bei den Dingen so fancy stuff.
Ist so ein bisschen Spaß-Talk gewesen.
Also er hat dabei Musik gemacht, hat Eurorec angeschlossen und seine MIDI-Synthesizer damit bedient.
Also genau, war mein Ding. Fallen die Talks raus, schaut doch mal rein. Das ist mit Sicherheit sehr nett.
Und was ich auch ganz gut fand, war, wir haben alle relativ viel darüber diskutiert, was Armin Rohnachar so erzählt hat zu,
was scheiße läuft in Python und zwar das ganze Packaging-Ding und so.
Das wissen wir wahrscheinlich alle derselben Meinung, dass das da irgendwann mal so ein Tool geben könnte,
dass sowas macht wie vielleicht Cargo für Rust oder so.
Ja, der Meinung bin ich aber nicht. Ich bin der Meinung, dass es schön wäre, wenn wir sowas hätten, aber ich glaube, ich fürchte, dass wir sowas nicht kriegen können.
Okay, aber das ist ja was anderes.
Aber da gibt es auch schon 23 Tools, die sowas machen.
Ja, genau, das ist der Punkt. Armin meinte auch, da gibt es halt noch ein 24. Das ist jetzt.
Aber das ist so ein altes XKCD-Comic.
Aber das ist so ein bisschen, vielleicht doch.
Also vielleicht sollte man einfach miteinander reden und vielleicht doch so ein Ding bauen, was dann übrig bleibt.
Weil man braucht halt was, was diese ganze Quark-Sache wie Pakete managen und PIP-Tools und PyEnv und Conda und, und, und, und, und, und,
irgendwie so schön nutzbar macht, dass irgendjemand, der das noch alles nicht kennt, einfach mal so ein Curl macht auf so eine Installation
und dann hat er ein Tool, mit dem das alles geht.
Das wäre schon ziemlich gut. Also so vom Pain-Faktor her.
Und immer dann, wenn ich jetzt Leuten versucht habe, das beizubringen oder versucht habe, bei denen Python zu installieren
oder auf so einer Schulung irgendwie kleine Sachen mit denen machen wollte oder die zum ersten Mal so einen Notebook in die Hand nehmen wollten
oder irgendwie irgendwas anderes, das war immer Schmerzen damit verbunden.
Und da ja Rust gerade so.
Nein, eigentlich ist das ganz einfach. Also du musst folgende Sachen installieren.
Das ist wirklich nur eine sehr kurze Liste.
Also erstmal brauchst du Build Essentials und dann brauchst du die ganzen Abhängigkeiten und LibJPG und LibJPG 98 und LibJPG 2K
und dann musst du PyEnv installieren und dann bist du schon fast so weit.
Und dann Apple und eine Banane und wie auch immer sagt, die ganzen Dschungel.
Und ja, also ich habe am Sprint dann für PyRun so ein paar Sachen installiert, weil ich es kompilieren wollte.
Es hat tatsächlich drei Stunden gedauert, bis es kompiliert ist auf meinem Tool langsam.
Klasse. Aber so ist das manchmal.
Ja, also ich bin mal gespannt. Also ich habe ja auch schon dann irgendwie gehört, was Leute dazu sagen, die sich mit diesem ganzen Thema schon lange beschäftigen.
Und es gab auch schon mehrere Versuche, das zu vereinheitlichen und da auch Peps zu etablieren, die quasi das standardisieren.
Und die sind gescheitert alle bisher.
Auch das letzte Mal, wie heißt der jetzt noch? Einer der bekanntesten Python-Core-Entwickler, der halt auch da irgendwie so ein großes Team bei Microsoft leitet.
Der große Kanadier, wie heißt der noch? Na, ich habe den Namen vergessen. Keine Ahnung.
Auf jeden Fall, der hat da versucht einen Peps zu machen, das hat halt gescheitert, weil ja, also mit dem Fazit, es geht nicht.
Ami meint, es braucht vielleicht noch ein Jahr, dann sind viele der Grundvoraussetzungen geschaffen, die da noch fehlen und das wären gar nicht mehr so viele.
Okay, ich bin gespannt. Also wenn das dann funktioniert, dann lasst mich überzeugen. Aber das, ja gut, werden wir dann sehen.
Was auch interessant ist, es gibt einmal diese UV-Geschichte, da gibt es dann auch noch diese Firma von Charlie Marsh, die hat ja jetzt irgendwie übernommen, das zu maintainen, das UV.
Ja, genau. Ja, also UV und Rye, wer ist das von einem?
Der hat nicht UV übernommen, sondern Rye.
Die integrieren sich tatsächlich relativ, die reden auch voneinander und übereinander und so und die integrieren einander relativ viel und Rye benutzt das UV statt PIP-Tools, glaube ich, oder so,
und über, dann darüber, das sieht alles gar nicht so schlecht aus und die Firma ist, glaube ich, Astral oder so und die machen auch Ruff und das, was eigentlich auch relativ gut funktioniert, finde ich.
Ja, die machen so eben ganz viel in Rust. Gibt es auch eine Firma hier, also es gibt ja da irgendwie auch eine schnellere Alternative zu Conda, Mamba von Prefix-Dev oder weiß ich nicht, Wolf Vollprecht oder so, den könnten wir vielleicht auch mal, den können wir doch mal zu diesem Thema fragen.
Ja, du weißt ja gerade, dass du für dich zuhörst.
Ja, und genau, genau, und das kommt da auch irgendwie mit rein, deren Geschichten sollen da auch irgendwie mit integriert werden, weil das ist halt unten drunter auch alles Rust und ja, also okay, es tut sich was, also insofern ist es schon mal gut. Ja, mal gespannt.
Ja, und ich finde es auch gut, dass man tatsächlich jetzt echt irgendwann durch ist mit diesem ganzen, das nervt.
Und vielleicht also Standards, also ich mag ja zum Beispiel diesen Go nicht, weil zu viel Standard und so, da ist immer zu viel Opinion und so. Und dann, okay, dann nutzt man dann doch Black. Aber vielleicht gibt es da so ein paar…
Moment, das habe ich nicht verstanden, was?
Also ich mag Standards nicht, also ich mag es eigentlich nicht, wenn irgendjemand sagt, wie es sein muss, wenn jemand so opinionated ist und sagt, wir machen jetzt, keine Ahnung, Tubs instead of Spaces, weil ich will das so, wenn ich das anders möchte.
Und das nervt mich immer so ein bisschen, weil das da schon ein Python ist, ist halt dynamisch, ich kann es mir nicht aussuchen, wie ich es mache.
Ja, aber gut, also ich meine, aber würdest du das, sozusagen, würdest du, du würdest aber nur das konfigurieren wollen, wie es aussieht, aber du würdest schon Autoformaten wollen.
Ja.
Ja, okay, na gut, kann man machen, wie man will.
Ja, also ich meine, aber wenn man jetzt bei Black dann irgendwie ein Konfigurationsdatei jedes Mal beschieben muss, ist das halt auch irgendwie Art und Absurdung, ne?
Ja, genau, weil Black gibt es das halt nicht, genau, dann muss halt was anderes sein, gibt ja auch noch andere.
Das ist so eine Sache, die denke ich mir schon lange, dass eigentlich diese ganze Codeformatting-Debatte, die ist doch Quatsch, oder?
Ja.
Eigentlich sollte doch eine Python-Datei den AST enthalten und dann hast du einen Editor und der kann dir den AST anzeigen, auf eine Art und Weise, wie es dir passt.
Ja, genau.
Wenn du die Sachen in grün oder gelb haben willst, oder in Dateien oder Modulen aufgeteilt, oder wie auch immer du es haben willst, da gibt es so viele Sachen, die man auf der Ebene machen könnte, aber stattdessen haben wir Textdateien.
Das ist so ein bisschen so, da müsste mal jemand was machen.
Da kommt dann immer der Einwand, dann mach doch mal was dagegen, dann sage ich, naja.
Naja, das Problem ist halt, wie kriegst du denn aus dem AST wieder was, wenn du jetzt tatsächlich was manuell anderes haben willst.
Möchtest du eine VR-Brille aufziehen und dann hast du vor dir den einen Balken, den einen Graphen und hast die Notes, musst du an der durchmaschinen, kannst du dich auf dein Laufband stellen und hinlaufen?
Ne, also da gibt es bestimmt Leute, die das so wollen, aber ich will ja nicht laufen, ich bin ja ein Softwareentwickler.
Aber ob du jetzt Tabs oder Spaces hast, oder ob du die Variablen so oder so nennst, oder ob du, keine Ahnung, viele Dinge, die du da, ob du Einrückungen oder Braces haben willst, das ist doch auch völlig egal.
Wenn Leute lieber Braces haben wollen, dann sollen sie halt sich ihren Editor so einstellen, dass der die Blöcke mit Braces umfasst.
Und umgekehrt, wenn ich TypeScript schreibe oder so, dann will ich da nicht überall Braces haben, dann muss doch mein Editor, muss doch smart genug sein, das umformen zu können. Und warum ist das so schwierig?
Ja, also ein Grund, der mir jetzt sofort,
Das ist so eine Debatte, die jetzt auch in die, ins Gebüsch führt.
Ja, also ein Grund, der mir direkt so einfallen würde, ist halt, was ist, weil das hatte ich jetzt letztens, ist halt, was ist, wenn ich Dinge anders machen möchte als jeder andere?
Du meinst Innovation?
Nein, einfach optisch.
Müll. Achso, äh, Entschuldigung.
Ja, das muss doch dein Editor können, das muss doch deine, das muss doch eine Einstellungssache bei dir sein, weil am Ende kommt ja der gleiche Preissencode raus.
Ja, weil wenn jetzt, wenn jetzt sozusagen, du kriegst jetzt Code von jemand anders, wie soll denn das, so wie ich das sehen will, wie soll der denn da hin transformiert werden?
Das kannste nur machen, wenn du das Modell machst.
In der Standardform geht leicht, aber der umgekehrte Weg geht halt nicht. Oder?
Ich glaub, das geht, ich glaub, das geht in alle Richtungen.
Hm.
Aber das wäre halt das, was da zu beweisen wäre. Und ich glaube, dass die, die, äh, die richtige Darstellungsart eben nicht Text in Ascii oder Unicode ist, sondern halt ein strukturierteres Modell.
Und aus diesem strukturierteren Modell kannst du dann ja mehr Sachen auch rausziehen.
Ja, gut, aber es ist unbewiesen. Ja, das ist hier so ein, wie gesagt, so ein "Jemand sollte das mal tun"-Projekt.
Ja.
In meiner vierstelligen Liste der Nebenprojekte ist es nicht auf Platz eins.
Also, jedenfalls, ich wollte eigentlich für Standards an der Stelle sprechen, weil ich tatsächlich finde, dass das so ein bisschen anstrengend ist.
Und das wäre schon gut, wenn so ein Standard das so löst, dass diese ganzen Pains und Probleme, ne, eine Lösung haben, die tatsächlich von allen so mitgetragen wird.
Das wäre schon irgendwie nice to have.
Also so ein "Kolorabotivespiel", äh, "Kolorabotivespiel", boah, Zungenbrecher. Ihr wisst, was ich meine.
"Kolorabotivespiel"?
Ja.
Aber du meinst jetzt für Codeformat?
Äh, nein.
Ach so, okay.
Ich meine für Packaging.
Packaging.
Und also Installation und Python generell und Binarys verteilen und Setup und Venfs und Dependencies und sowas alles.
Naja, ich hab mir halt diese Diskussion halt so ein bisschen angeguckt und die hat mich so ein bisschen hoffnungslos zurückgelassen, weil, also auch die Leute, die sich damit beschäftigt haben, die haben das ja auch, das war ja das Ziel und das Ergebnis war, geht nicht.
Ja, das Problem ist halt, man will sich aber damit gar nicht beschäftigen.
Doch, doch, da haben sich, oh yeah, da haben sich viele Leute ganz lange damit beschäftigt.
Ich möchte mich nicht damit beschäftigen, was für Probleme Python beim Package installieren beim Venf hat, sondern ich möchte Packages installieren, die die benutzen.
Ja, aber ...
Weil ich möchte halt Programme schreiben.
Ja, aber die Frage ist, ist das überhaupt möglich bei einer so alten Sprache? Geht das?
Und bei Rust, also die Antwort ist, warum geht das bei Rust, ist halt, die Antwort darauf ist halt, das geht deswegen, weil das eine sehr junge Sprache ist.
Und weil man all die Dinge, die man früher bei Python gemacht hat, da halt nicht drin hat.
Ja, aber da müssen wir auftimmen, Michel, das sind also ...
So jung ist Rust jetzt auch.
Das Problem ist, das war, das ist ja, ja, aber ein Großteil von dem Zeug, das verwendet wird, ist halt älter als 20 Jahre und macht Dinge, die total komisch sind.
Und dann ...
Was hier?
Ja.
Johann, was würdest du sagen, wann ist Rust erschienen, wann war das erste Release von Rust?
Ich glaube, das ist etwas mehr als zehn Jahre her.
Na ja, nicht ...
So irgendwann 2013, 2015?
15. Mai 2015, also neun Jahre.
Ah, okay.
Na gut, okay.
Nicht so schlecht.
Hab ich sogar ein bisschen zu alt geschätzt, ja.
Ja, okay, aber also ganz junge Sprache ist es auch nicht mehr.
Nee, aber viel, viel jünger als Python, viel, viel jünger, ja.
Ja, gut, das stimmt natürlich.
Wobei Python 3 ist jetzt auch noch nicht, ist doch auch erst seit ein paar Jahren.
Ja.
Ich sag ja immer, Zeit für Python 4.
Okay, ja.
Die nächste Version ist Python 8, oder?
Da gab es doch mal so einen April-Scherz, so ein Pep, wie die nächste Python-Version heißen sollte.
Und dass man dann immer additiv vorgeht.
Der große Vorteil von dem Versionsschema ist, dass man alle anderen Versionen einholt.
Das war auch ein lustiger Talk.
Wer ist nochmal der Release-Manager von 13 und 14, wisst ihr?
Äh, Thomas Wotors?
Kann der auf jeden Fall, ja.
Ich meine, der war auch lustig, weil er meinte nämlich, er möchte gerne das Versioning von Python ändern,
einfach auf Jahreszahlen anpassen.
Dann wäre es halt demnächst Python 24 einfach, dann Python 25.
Und dann aber mit drei davon, wenn man drei behalten würde, dann 3 von 25, weil es Blut wäre.
Da müssen Sie sich aber auch noch irgendwelche lustigen Tiernamen ausdenken, die da dazu passen.
Ja.
Und bitte alphabetisch aufsteigend.
Ja, genau, so ungefähr.
Ja, das war dann die Debatte.
Ja, also es gab viel Spaß und die Talks sind sicher auch irgendwann bald da, die kann man sich alle angucken.
Es gab ja verschiedene Facts, der DataTrack war relativ viel vertreten wieder.
LLMs und so sind ja wie immer hoch dabei.
Ich hatte nicht das große Glück, dass ich jetzt da so einen Talk erwischt hatte, der mich so total faszinierte.
Die waren immer sehr, ich sag mal High-Level, was auch nicht schlecht sein muss.
Aber ja, bis auf so ein paar Sachen, die halt darum gingen, so wie man das vielleicht mit dem Trainieren noch ein bisschen besser hinkriegt
oder mit dem Feintunen, das noch ein bisschen effektiver sein kann und nicht so viel Speicher dafür braucht oder so.
Aber das müssten wir uns eigentlich mal für eigene Episoden irgendwann aufheben.
Mhm.
So was.
Ja, was haben wir noch, Jochen?
Ah ja, jetzt wo es um EuroPython ging, was mir eingefallen ist, wir hatten ja letztes Mal auch über die DjangoCon Europe 2024 geredet.
Und die Vorträge sind jetzt online, kann man sich angucken.
Und da bin ich jetzt gerade dran, die so ein bisschen nach und nach anzugucken, die ich interessant finde.
Und da habe ich auch schon Interessante gesehen.
Da war auch jetzt diese Woche, war ein Treffen der Django-Cologne-Usergroup.
Wo es dann halt auch einen Vortrag gab über Background-Tasks, was ganz interessant war.
Und ja, das klingt alles tatsächlich ziemlich interessant.
Also da haben sich schon Gedanken über das Interface gemacht.
Salary ID.
Ja, könnte sein.
Was eine gute Sache wäre.
Ja, und es wäre richtig gut.
Ah ja, aber da wollte ich noch sagen, weil du gesagt hast, die ganzen Talks gucken, das war tatsächlich auch super.
Ich mag dieses hybride Format von Konferenzen.
Auch bei der Europe Heistung konnte man halt abends, wenn man schon durch war von dem ganzen Tag und die ganzen Konferenzen live gesehen hat,
sich nochmal den Track von den Sachen, die man verpasst hatte, bei YouTube auf anderthalbfach angucken zum Einschlafen oder zum Runterkommen.
Ja, das war natürlich praktisch.
Das heißt, man kann alle Sachen parallel gucken gleichzeitig.
Oder länger frühstücken, wenn man mag.
Was nicht schön ist.
Sehr zu empfehlen, sehr zu empfehlen.
Ja, ansonsten so in Ermangelung von Dingen, die jetzt mit Falten so viel zu tun haben.
Was mich hier gerade so noch ein bisschen umtreibt, ist halt, ach ja, es war bald Urlaub und ich habe ein bisschen neue Hardware irgendwie mir zugelegt.
Jochen, das ist keine Werbeveranstaltung hier.
Ne, aber was ganz cool ist, es gibt jetzt so einen, tatsächlich, also dieser Haushalt enthält Computer, kann Spuren von Computern enthalten.
Und der schnellste Computer in diesem Haushalt ist jetzt ein iPad.
Und ja, also da sind ja diese M4-Dinger drin, die sind sackschnell. Also das ist unglaublich.
Also lässt du das jetzt deine Machine Learning Modelle tunen?
Aber das ist doch kein General Purpose Computer.
Ne, leider nicht.
Es ist argumentiert, dass es kein General Purpose Computer ist.
Ja, das ist blöd. Aber es wäre voll cool, wenn es ein General Purpose Computer wäre, weil es wäre nämlich der schnellste, den ich hätte.
Bau doch einfach die CPU aus. Kannst du nicht woanders einlöten?
Ne, genau. Also ja, das ist so ein bisschen so, weil das Ding ist tatsächlich, also M4 gibt es auch noch in keinem anderen Gerät von Apple, also nur im iPad.
Ja, es ist schon so ein bisschen traurig. Es gab auch eine Tastatur diesmal mit einer Escape-Taste, sodass halt irgendwie mit der Escape-Taste kannst du eigentlich auf iOS überhaupt gar nichts anfangen.
Weil halt viele Leute gedacht haben, es kommt irgendwann MacOS für iPad, was voll cool wäre, aber nein, kam nicht.
Und jetzt habe ich ein iPad und kann es nicht benutzen. Ein bisschen doof.
Aber ja, ansonsten wirklich sehr schnell.
Da kannst du schnell YouTube gucken.
Ja, genau.
Ich habe noch so eine Platine mitgebracht, die kann man sich ankleben mit so einem Magneten und da kann man so einen Text hin und her laufen lassen.
Ne.
Und da gibt es so ein Python-Modul, da kann man dann den Text auswählen.
Und das ist dein schnellster Computer?
Pst.
Ja, genau. Und ja, ansonsten gab es noch so ein bisschen irgendwie, ja, LLM-Krams.
Ja, da gibt es doch immer was, oder?
Ja, also Xopic hat toll neue Modelle rausgebracht, die ziemlich beeindruckend sind.
Ja, und Mistral hat jetzt, ich glaube, heute ein neues Modell rausgebracht, Nemo heißt das, mit einem neuen Embedding.
Die haben einen neuen Embedder trainiert, der wohl deutlich besser ist.
Das müsste man sich mal anschauen.
Und dieses Nemo-Modell hört sich auch interessant an, das ist in Zusammenarbeit mit Nvidia entstanden.
Ach, du hast ja O/A.
Das ist ein 12b-Modell.
Das ist also etwas größer als diese 7b-Modelle und das ist wohl genau so trainiert, dass du es auf einer normalen Grafikkarte laufen lassen kannst.
Also auf einer 4090.
Ja, die haben ja alle 11, 12 Gigabyte Hauptspeicher.
Genau. Und das ist wohl auch schon so trainiert, dass es mit FP8 geht, ohne Leistungsabfall.
Und das ist natürlich direkt sehr praktisch.
Ja, ich habe auch letztens gesehen, dass irgendjemand quasi, war das Microsoft Research, ich weiß es nicht, hatte Paper veröffentlicht,
zu einem Modell, das die gleiche Performance, oder sogar eine deutlich bessere Performance über viele unterschiedliche Benchmarks hingekriegt hat als GPT 3.5,
aber auf einer einzelnen GPU läuft.
Also auf so einer Computersumma-GPU.
Und das war auch zum ersten Mal, dass es jemand geschafft hat, quasi GPT 3.5 auf so Konsumer-Hardware zu schlagen.
Und das ist auch sehr beeindruckend.
Also du kannst da wirklich auf deinem Rechner zu Hause Sachen laufen lassen, lokal, auf deiner Spiele-Grafikkarte,
die halt irgendwie das GPT vom Anfang deutlich schlagen.
Und das ist interessant. Also, ja, das geht voran.
Ja, da tun sich doch viele Dinge. Das ist schön, dass da so, auch so völlig, sag ich mal, normale Sachen,
dass sich jetzt hier GPT 4 und 4.0 und so, dass die sich weiterentwickeln und Cloud Sonnet und so weiter.
Achso, und das Mistral Nemo-Modell hatten ein 128k-Kontakts-Window.
Das ist auch eine Besonderheit.
Das ist auch was Interessantes, weil die anderen lokalen Modelle hatten ja immer nur irgendwie 4k oder 8k.
Und das macht doch nochmal einen deutlichen Unterschied aus.
Dass sich so ganz normale Sachen, sag ich mal, weiterentwickeln, dass man eben, genau wie du sagst, Jochen,
dass jetzt auf normalen GPUs laufen lassen kann und dass die Modelle größer und schneller und trotzdem skalierbar werden.
Und dass es auch in der Richtung Entwicklung gibt, das finde ich eigentlich ziemlich cool.
Das es nicht nur so eben in diesen Hochburgen und in den Diensteanbietern festhängt, sondern die Szene ist auch sehr lokal.
Und wenn man sich da mal dieses Hugging-Face anguckt, ja, und wie viele Pflege von Lamas es gibt,
und dann gibt es manche, wo das Sicherheitstraining weg ist und eins spricht nur keine Art der Sprache und eins ist nur diesen, das und jenes kann.
[Gesang]
Es ist schon schön, dass da was passiert.
Ja, genau. Ja, und die andere Seite, also OpenAI und so, das ist auch interessant.
Also überhaupt, da wollte ich auch noch wegen Apple irgendwie drauf zu sprechen kommen.
Die bauen ja jetzt dann irgendwie die Dinger ein in iOS und was eingebaut wird, ist auch GPT 4.0.
Also du kriegst halt jetzt, wenn du ein iPhone oder sonst irgendwas kaufst, wahrscheinlich dann ab jetzt, wenn die neuen Geräte kommen,
kriegst du halt, oder eine neue iOS-Version, kriegst du halt quasi die Bezahlversion von OpenAI irgendwie in deinem Gerät.
Und das ist halt ein relativ dicker Deal wohl. Und dafür kriegt, also das ist glaube ich nur ein Gerücht, das ist noch nicht bescheidigt, aber.
Ja, du hast sogar einen Bordseed.
Ja, genau, die haben jetzt, der hat jetzt,
Microsoft hat doch die Daten von allen iOS-Nutzern, haben sie wieder aufgegeben, sind nicht mehr.
Mhm.
Sowohl Microsoft als auch Apple haben ihren Bordseed aufgegeben. Es waren eh nur Beobachtende, aber es haben sich beide zurückgezogen.
Achso, okay, ich dachte eigentlich, dass jetzt sozusagen das Gerücht war, dass das Feldfühler irgendwie ins Board von OpenAI geht, aber.
Ja, haben sie aber wieder zurückgezogen.
Ah, okay. Dann, naja, dann war ich da schon nicht mehr so aktuell. Aber ich meine.
Es bewegt sich so schnell, das kannst du nicht. Wahnsinn.
Falls man hinguckt, ist schon alles ganz anders.
Aber naja, gut, also ich in gewisser Weise verstehe es ja auch, also das große Problem von OpenAI ist ja irgendwie, dass sie halt zwar irgendwie ganz gute Modelle haben, aber sie haben halt die Geräte nicht da draußen.
Also sie haben halt einen strukturellen Nachteil gegenüber sowas wie Google oder so. Google braucht das alles nicht.
Die können einfach irgendwie über Android, haben sie da halt einen riesen Hebel.
Und, aber OpenAI, wenn sie halt nicht Partnerschaften mit Microsoft oder mit Apple haben, dann haben sie halt ein Problem.
Weil, ja, wenn die, sonst passiert ihnen das, was halt irgendwie, keine Ahnung, Slack passiert ist mit Teams oder so, und dann sind sie halt weg.
Ja, insofern, ja, es ist auf jeden Fall interessante Zeiten. Bin mal gespannt.
Aber 4.0 ist auch so gut, also ich finde das hier auch dauernd, also das ist, dass das wahrscheinlich irgendwie.
Ja, aber was machst du denn, Jochen? Was machst du denn damit?
Ja, programmieren.
Ach so, ja gut, okay, das, ich weiß nicht, da geh ich in den Flow rein.
Ja, aber auch Opus, das ist schon.
Ja, Opus ist auch super, also ja, absolut. Oder so nicht.
Ja, du gibst halt einfach so Fragen, das stimmt dann auf einmal doch eher mehr als früher.
Noch mehr als früher. Und dann, man kann es halt so steuern, wenn man halt.
Bleibt das irgendwo integriert oder?
Ja, ja, wenn man, also auch Konsole halt, ne.
Und wenn man halt, dann kannst du halt auch pipen, mit Cut reinpipen, irgendwas, oder ein Slack dann halt, Template, mach einen PyTest drauf oder so.
Und das ist gut, gute Vorschläge.
Also die sind nicht immer ganz rein, aber man kann das ja auch modifizieren, kann sagen, so ja, ein bisschen mehr in, ne, bisschen mehr Fixtures, ein bisschen weniger dies, ein bisschen weniger das, wenn man das nicht schon im System schon drin stehen hat.
Und dann ist das ziemlich das, was man will.
Man kann ja auch so ein Beispiel geben, wie, hey, und so wie ich das hier gemacht habe, so das es ungefähr so könnte es aussehen.
Und dann, fertig.
Ich bin da immer neidisch, wenn da Leute das so erzählen, weil ich komme mit solchen Systemen einfach irgendwie nicht in den, ich komme nicht in den Flow.
Vielleicht muss man sich das mal zusammensetzen.
An Emax Johannes.
Ich glaube, doch PyCharm, bin doch ein PyCharm-Unterstützer.
Ja, aber hast du da den Copilot zum Beispiel an oder so, weil das ist auch schon ganz ok.
Also ich finde ehrlich gesagt, das ist nicht so gut, wie wenn man jetzt quasi direkt mit.
Wann hast du das letzte Mal probiert, Jochen?
Keins dieser Systeme hat mich je überzeugt.
Ok.
Ich habe es ein paar Mal probiert und das war jedes Mal so, ne.
Johannes hätte es besser gewusst.
Das, vielleicht ist das das Problem, vielleicht weiß ich es einfach besser.
Ja, ich würde es auch sagen.
Ja gut, kann man genau machen.
Da würde ich aber sagen, dass das genau das.
Wenn der Jochen sagt, dass das bei ihm hilft, dann kann es bei mir nicht sein, dass ich es besser weiß.
Also hier ist eine wundervolle Überleitung, das ist übrigens Tim Peters, der Core-Entwickler und Autor von Zen of Pison, das ihr bestimmt alle kennt, ne, Imports.
Dann meinte der, der Plan wäre, wenn jemand ein Feature entwickelt, das du nicht verstehst, dann knall ihn einfach ab.
Und das ist der Einstieg in das wunderschöne Buch von Flue und Pison.
Ja, da muss man direkt mal klar machen, wie die Sachen dann so laufen und genau.
Das ist auf jeden Fall einfacher, als etwas Neues zu lernen.
Ja, und dann im Schluss hat man nur noch Leute, die irgendwie kein Problem mehr haben, das zu verstehen, was man sagt.
Ja, und bevor die einzelnen überlebenden Entwickler, dann kann man ein kleines Stück von dem, was man schon kann, dann verwenden und kommt damit weiter.
Also sind wir jetzt bei Flue und Pison?
Sind wir jetzt bei Flue und Pison?
Sind die News, ok, wir können durchschalten.
Ja, ich würde tatsächlich jetzt so ein bisschen unser Ratsche versuchen, in eine Struktur zu überführen, die uns ein bisschen zurückführt auf dieses wundervolle.
Äh, Python, Delta.
Fluent, was heißt denn Fluent? Flüssig?
Also ich wollte nicht über das Buch sprechen eigentlich.
Fließend.
Eigentlich wollte ich gar nicht erwähnen, das Buch, das aus dem Buch klauen, aber gut.
Achso, du wolltest einfach so tun, als dass das deine, deine, ja, Entschuldigung.
Na egal.
Den ganzen Spaß verdauern.
Ok.
Ja, nee, wir können das auch sagen, das ist ja kein Problem, aber genau, was wir.
Ja, die Erklärung können wir schon abgeben, finde ich, ja.
Was es, was es heute im Grunde geht, ist halt wie, sie nennen das Python Data Model oder im Buch wird es auch so genannt, es wird auch in der Referenzdokumentation so genannt.
Es gibt andere Leute, die nennen das irgendwie anders, Python Object Model oder so.
Und im Grunde geht es darum, was ist denn das jetzt überhaupt wieder alles?
Genau.
Also ich tue jetzt mal einmal so, ne.
Ja, ja.
Also, ja.
Tu mal so, als ob du das nicht wüsstest, nämlich.
Ja, genau, das sage ich doch.
Ja.
Wie immer.
Also zum Beispiel ist halt die, die, die, das ist ein super Beispiel ist halt, um da vielleicht einen Einstieg zu finden, warum sagt man in Python eigentlich irgendwie len von irgendwas, einer Collection oder so und nicht Collection Punkt len, Klammer auf, Klammer zu, wie man das jetzt vielleicht in Ruby machen würde oder so.
Ich weiß ehrlich gesagt gar nicht, wie man es in Ruby macht, aber.
In Java, sag einfach.
In Java, in Java.
Die machen das komisch.
Genau, warum, warum macht man das eigentlich so?
Und ja, also der, das was halt Python an der Stelle halt anders macht, ist halt, dass es irgendwie ein bisschen objektorientierte Purity sozusagen irgendwie opfert, um halt eine Menge andere Vorteile zu kriegen.
Und ja, das macht es, also das ist überhaupt so eine charakteristische Geschichte von Python, dass man halt oft irgendwie ja halt nicht die reine Lehre irgendwie macht, sondern halt irgendwie etwas, was nicht ganz so rein ist, aber das halt praktisch viel besser funktioniert.
Ich verstehe jetzt meine Sache nicht, also warum ist erstens irgendwas mit Klasse und Attribut und Methode Call die reine Lehre und zweitens, was ist das Problem, wenn man irgendeine Funktion hat oder eine call it whatever you like oder Closure und kippst da ein Objekt rein und dann passieren Dinge damit?
Also sozusagen, wenn du jetzt reine Objektorientierung machen wollen würdest, dann würde man ja sagen, naja gut, du schickst halt irgendwie Nachrichten an ein Objekt oder du rufst halt Methoden auf oder was auch immer, wie man das nennt und das ist dann die Sache des Objekts.
Warum?
Das ist zum Beispiel in Java so.
Ja, aber warum ist das so?
Auch haben es Razer, weil Einfachheit ein Wegweiser zur Wahrheit ist oder zur Schönheit
oder so.
Okay, Point 1 für den Ja-Wahlentwickler.
Für dich.
Ja.
Okay, und warum ist es denn nicht auch einfach, einfach so was wie funktionale Programmierung
zu machen und da Zeug zueinander hin und her zu reichen?
Was fehlt einem denn da in diesem Vergleich?
Funktionale Programmierung ist ja auch etwas anderes.
Das gibt es auch, aber das ist etwas ganz anderes.
Also das ist ja, also kann man auch machen, aber dann ist es, also das wäre, kannst du
auch Pure haben, so was wie Haskell oder so, oder Erlang oder weiß ich nicht.
Ah, StandardML.
Ja.
Das ist Haskell, ja, diese modernen.
Ja, aber das ist halt ein anderes Konzept als jetzt Objektorientierung.
Naja, aber wir sprechen gerade von ästhetischer Einfachheit oder so.
Ja, ja, ist es auch, aber es ist halt anders.
Es hat dann nur Funktionen, sozusagen.
Okay, aber ich wollte kurz auf die Trade-offs hinaus, weil, warum ist das jetzt?
Naja, also der Grund, warum man jetzt denken konnte, dass es halt im Titen nicht so schön
ist, dass man sagt, das muss man halt auch noch so, jetzt sind wir an so Build-Ins wie
Len oder so, die so ein bisschen komisch sind.
Aber tatsächlich hat es halt praktisch sehr viele Vorteile, wie, naja, also einmal, du
musst dir nicht für jedes Objekt merken, wie das denn jetzt nun heißt mit dieser
Gebote, weil das kann ja jeder dann anders machen, das wäre ja irgendwie schlecht.
Das ist zum Beispiel ein Problem, was PHP hat oder JavaScript, da heißt es manchmal
Size und manchmal Length und manchmal Count.
Ja, und eine andere Geschichte ist halt, es ermöglicht dir halt irgendwie so ein paar
dreckige Optimierungen zu machen, die halt irgendwie die Dinge, die wirklich Zeit kosten,
irgendwie deutlich schneller zu machen.
Zum Beispiel, du kannst halt, da diese Sachen, so tatsächlich was Len halt macht, ist ja
schon dann quasi, wenn das ein Objekt ist einer Klasse, die du erstellt hast, dann
wird halt dann da Len aufgerufen.
Schon doch die Methode, die geheime.
Die Methode aufgerufen, aber die ist halt nicht dafür da, dass irgendwie andere die
aufrufen, sondern, oder dass man die von Hand aufruft, zu Fuß oder wie auch immer,
die ist halt dafür da, dass der Interpreter die aufruft, wenn man halt Len von irgendwas
sagt.
Und dann ruft der Interpreter die auf, aber der Interpreter kann halt auch andere Dinge
tun.
Der kann zum Beispiel jetzt, wenn das ein irgendwie so ein native, also ein Ding im
Interpreter selber ist, also oder irgendwie ein C geschriebenes Ding, wie ein Dict oder
eine Liste oder sowas ist, dann kann es halt direkt irgendwie in diesem PyObject irgendwie
drauf gucken, wie lang ist denn dieses Ding und gibt es dann halt zurück und muss halt
keine Methode aufrufen.
Also Methodenaufrufe sind halt etwas, was halt in Python super langsam ist.
Oder in allen interpretierten Programmiersprachen, die so ähnlich sind wie Python, das sind
halt Funktionsaufrufe, Methodenaufrufe immer total langsam.
Da ist wirklich so ein Faktor 1000 dazwischen, zwischen irgendwie reinem C und Funktionsaufruf
und Python oder so.
Und ja, für die ganzen Standardfälle, wo man das halt benutzt, kann der Interpreter
das halt alles wegoptimieren und dann macht er das halt einfach nicht, sondern da wird
gar nichts aufgerufen.
Also das sind halt zwei große Vorteile, die man halt kriegt, wenn man halt ein bisschen
Reinheit opfert, sozusagen.
Und genau, das ist halt irgendwie diese Balance zwischen irgendwie Reinheit und funktioniert
super.
Und Magie.
Genau, ist halt so eine Spezial.
Ja, Magie mag der, mag jetzt zum Beispiel der Autor von Flute und Python an der Stelle
gar nicht so gerne.
Also man nennt die Dinger ja irgendwie Magic Methods auch, also dieser Magic Methods.
Das finde ich eine sehr schöne Diskussion über diese Namen, über die Magic Methods
und über die nicht Magic Methods.
Ja, fand ich auch so.
Das kommt halt so aus der Ruby Community, das wusste ich gar nicht.
Ich dachte eigentlich, das gibt halt ein paar Python-Entwickler, die nennen das halt Magic
Methods, die dann sagen halt Dunder Methods oder sowas.
Ja, aber in der Ruby-Welt ist das wohl üblich.
Und ja, aber der …
Das ist der offizielle Name, oder, in Ruby?
Die heißen Magic Methods.
Genau.
Ja, oder auch in IPython oder so heißen die ja auch irgendwie Magic und dann gibt es
diverse …
Aber das ist ja auch wirklich Magic.
Das ist wirklich Magic, okay.
Aber eigentlich sind halt eben die Python-Dinger gar nicht Magic, sondern das ist halt eigentlich
völlig klar, das dokumentiert, was das ist und was das tut.
Und insofern, der Autor sagt selber, okay, ich finde das nicht gut.
Die sollten lieber Muggel Methoden heißen oder so, weil sie halt so unmagisch sind.
Aber ja.
Ja, er nennt es ja dann auch oft Special Methods einfach.
Special Methods ist auch ein guter Name.
Ich glaube, das, was da magisch ist, ist, dass man die implementiert und dann werden sie
irgendwoher aufgerufen.
Und wenn du das nicht weißt, dann ist das schon magisch.
Ja, ich glaube auch.
Du gibst Lenn von irgendwas ein und das wird aber was ganz anderes.
Und das für Anfänger ist es nicht so wichtig, dass wenn du irgendwie so eine Methode dazu
fügst, die Dinge macht, wo du nicht weißt, warum, weil das unter der Haube passiert.
Aber das ist natürlich.
Aber das Special war ja auch nicht.
Also magisch schon gut.
Das macht ja Magie.
Ah, es passiert irgendwas, dann machst du einen String auf irgendein Objekt und dann
kommt da irgendwas raus, weil du eine Repre-Methode beschrieben hast.
Ah, Magie.
Wobei das natürlich eine sehr dünne Schicht Magie ist.
Wie der Jochen schon gesagt hat, da gibt es eine Liste, so viel Magie gibt es und die
sieht auch so und so aus.
Und im Wesentlichen ist das ja nur eine syntaktische Umformung.
Syntaktische Magie.
Damit, syntaktische Magie, genau.
Ja, aber das ist quasi echte Magie.
Ich meine, echte Magie, da fummelt jemand vor den Augen mit deinem Fingernstipsen rum
und auf einmal sieht er hinter seinem Ohr eine große, goldene, begrenzte Münze.
Ja, das sind Illusions.
Das ist keine Magie.
Das ist so ein bisschen, aber so eine taktische Magie.
Ja, aber echte Magie ist doch das, was man aus Harry Potter kennt.
Dann schwingst du da einen Zauberstab und dann passiert irgendwas.
Die richtigen Worte, der Richter ist da.
Ja, aber der Richter kann ja auch eine richtige Reihenfolge sagen.
Er macht irgendwas, was thermodynamisch nicht möglich ist.
Ja, genau, aber da sind wir jetzt eigentlich alle relativ einig.
Das gibt es halt auch nur in Harry Potter oder in ...
Ich weiß nicht, also ich finde tatsächlich ...
Und in Ruby.
Die Analogie auch gar nicht so schlecht für Programmieren insgesamt.
Also ich meine, das ist halt, also ich meine, was ist, also man sagt irgendwie ...
Du sagst die richtigen Wörter in der richtigen Reihenfolge und dann passieren Dinge.
Genau, ja, ich finde, das ist gar nicht so weit hergeholt, als man das vergleicht.
Deshalb sind wir alle Wizards.
Ich habe auch so einen Wizard-Pullover.
Es gibt auch tatsächlich Leute, die Nichtprogrammierer als Muggel bezeichnen.
Also ich weiß, so weit würde ich jetzt nicht gehen vielleicht, aber ...
Echt? Ich bezeichne die mal als NPCs.
Ja, okay.
Äh, ja.
Nein.
Tatsächlich das erste Beispiel in einem nicht näher benannten Buch,
was ich kürzlich gelesen habe, das hat mich tatsächlich etwas überrascht.
Da war tatsächlich ein bisschen Magie drin.
Und zwar, da wird ein Card-Deck implementiert.
Ja.
Und er implementiert nur zwei von diesen Methoden.
Ja, für Kartentricks dann.
Und er implementiert nur zwei Methoden, nämlich dann den Len und dann den Get-Item.
Ja.
Und das reicht aus für Slicing und Ranges und Worst und Iteration.
Ja, ja, voll cool.
Das hat mich etwas überrascht, dass der Python-Interpreter sich aus einem Get-Item,
aus einem Len, kann er sich alles zusammenbasteln.
Ich meine, es ist nicht, wenn man so ein bisschen drüber nachdenkt,
es ist einfach nur smart, dass das geht.
Und das ist auch klar, dass das geht.
Wenn ich weiß, wie viele es sind und ich ein einzelnes holen kann,
dann kann ich auch mehrere holen.
Okay, gut.
Ja.
Und ich kann auch Reverse machen drauf.
Okay, auch das ist nicht arg überraschend.
Und ich kann auch Iteration machen drauf.
Okay, auch das ist nicht arg überraschend mehr.
Ja.
Aber dass das implementiert ist, das fand ich sehr cool.
Ja, man delegiert im Grunde die ganze schlaue
oder die ganze schwierige Funktionalität von,
wie das halt so funktioniert, an die interne Liste in der Datenlage.
Genau, wie das schnell auch funktionieren kann,
indem man einfach so ein Len-Get-Item definiert.
Ja, aber ...
Nee, Jochen ist nicht delegiert.
Sondern der ruft Len ein Get-Item an.
Ja, aber das macht er direkt.
Eine repräsentation von Len wird ja aufgerufen.
Also das heißt, die Magie, die wirklich dann in C-Python passiert,
die ja damit schnell ist und so, da muss ich ...
Okay, also er implementiert ...
Gut, in dem Beispiel wird nicht implementiert,
wie du tatsächlich Objekte speicherst,
sondern benutzt eine Liste.
Genau, es wird halt sozusagen, das wird weitergereicht,
die Position wird weitergereicht an die Liste.
Genau, und die kann halt auch umslicen.
Also die Implementierung dieser beiden Attribute ist tatsächlich ...
Also ...
Ist einfach durchdelegiert.
Aber dass du dann daraus eine Slicing-Syntax kriegst mit Ranges ...
Ja, ja, ja, das ist ...
Das ist ja, das macht ja der Interpreter für dich.
Ja.
Also der macht sich diese Ranges und ruft dann die einzelnen Get-Items auf.
Ja.
Also hat mich auch gewundert.
Ich hätte jetzt auch nicht gedacht, dass man dann schon iterieren kann.
Das war ...
Genau, das war mir gar nicht klar, dass das reicht,
Get-Items zu implementieren.
Also ich muss meine naive Karteninterpretation
von meinem Kartenspiel, von meinem Pokerspiel auch noch mal anpassen,
wenn ich das so sehe, weil tatsächlich ich da auch immer
dann ein Objekt gemacht habe, an dem Karten dran waren,
was natürlich dann eine Liste war, was aber nicht hieß,
dass man einfach das Ding mischt,
sondern man muss halt diese Mischmethode aufrufen.
Ich glaube, das ist einfach totaler Quatsch.
Ja, da gibt es aber auch verschiedene Ansätze.
Da kannst du auch auf verschiedene Arten und Weisen drangehen.
Du kannst drangehen und sagen, ich mache jetzt eine neue Klasse,
die eine Liste einpackt und dann halt so ein paar magische Methoden,
ich sage jetzt ja magische Methoden, exportiert.
Oder du kannst sagen, ich behandle jetzt eine Liste wie ein X, Y und Z.
Und dann implementierst du erst mal selber gar nichts,
sondern benutzt halt die Werkzeuge, die es gibt,
auf eine bestimmte Art und Weise.
Es sind ja schon zwei unterschiedliche, aber gleichwertige Herangehensweise.
Aber dieser letzte Ansatz ist irgendwie smart,
weil man halt tatsächlich nicht das Rad neu machen muss.
Und ich glaube, das ist eigentlich sehr personal.
Der ist ein bisschen impliziter, ja.
Aber trotzdem sehr personal, sehr sensimplizit ist.
Und in der Kombination, indem man das halt irgendwie
schön modellisiert, kann man tolle Sachen machen.
Also man muss da so ein bisschen ein Boilerplate schreiben vielleicht,
aber wie man es dann hinterher wirklich benutzt,
wenn man diese Objekte in der Hand hat, wirkt einfach wie pure Python.
Weil man halt dann direkt auf dem Deck, was man in der Hand hat,
in DCs machen kann, Ranges machen kann und so.
Ja gut, hier geht es ja vor allen Dingen darum,
diese Methoden zu erklären.
Insofern, ob man das jetzt so implementieren würde, weiß ich nicht.
Also keine Ahnung, kommt drauf an, was man damit machen möchte.
Aber ja, ich finde es auch, es sieht gut aus.
Kann jetzt keiner sehen, weil es ein Podcast ist leider.
Kannst du das teilen? Ist das public?
Ne.
Oh. Na gut.
Also ich glaube, es gibt irgendwo bestimmt auf irgendwelchen Kanälen oder so was.
Ja.
Das nächste Beispiel, was er bringt, fand ich auch interessant.
Aber das ist natürlich so ein bisschen dieses Vector-Beispiel.
Das ist natürlich mehr so ein bisschen, ja.
Du musst das noch mal verleuchtern bitte, bei allen unserer Hörer*innen,
was denn das Vector-Beispiel ist.
Ja, er macht sich eine Klasse, eine zweidimensionale Vector-Klasse.
Also mit Richtung XY.
Genau, also ein Koordinatenmodell, ein zweidimensionales Koordinatenmodell.
Er sagt auch gleich im Vorhinein,
könntest du auch die Build-In-Klasse Complex verwenden.
Die kann alles, was wir gleich hier machen und noch viel mehr.
Aber zum Zeigen ist es ja ganz schön.
Und da implementiert er drei Special Methods,
nämlich Add, Abs und Mul.
Und kriegt daraus dann die Möglichkeit, zwei Vektoren zu addieren.
Abs wird hier als die Metrik implementiert,
das heißt, es ist die Länge eines Vektors.
Und Mul ist eine Skalarmultiplikation,
das heißt, kannst du einen Vektor mit einem Integer
oder mit einem Float multiplizieren, kannst du die Länge verändern.
Auch das mit wenigen Methoden schon relativ viel erreicht
und auch relativ viel Syntax erreicht.
Das fehlt aber noch mit Vektor multiplizieren.
Ja, das ist nicht so einfach, dummerweise.
Das ist mathematisch nicht so einfach.
Genau, da steht, glaube ich, im Buch irgendwas drin.
Ja, also wie man das dann macht mit Magic Method,
das ist dann Kapitel 16 oder so viel weiter hinten.
Das ist nicht so einfach.
Und er sagt auch, er verschiebt auch,
das tatsächlich in diesen ersten Kapiteln
verschiebt er relativ viel auch später.
Ja, hier, das kommt in Kapitel 17 noch mal
oder Kapitel 38 oder Kapitel 12.
Tatsächlich auch Skalar mit Vektor multiplizieren,
also eine Zahl mal Vektor verschiebt er auch auch später,
weil da brauchst du nochmal eine andere Special Method,
weil eben Mul nur Vektor mit Skalar kann.
Und das ist dann so ein kleines bisschen unbefriedigend.
Was ich aber eigentlich, worauf ich eigentlich raus wollte, ist,
er hat halt dann die Möglichkeit, seine Klasse mit Plus,
hat er zwei Vektoren, zwei Instanzen von seiner Klasse,
kann er mit Plus addieren.
Und das fand ich nicht so beeindruckend,
weil das gab es in C++ auch schon.
Das musste ich auch schon mal lernen.
Und da heißen die Methoden halt anders,
da heißen sie Operator Plus und Operator Minus
und Operator noch irgendwas.
Und dann kriegst du es aber auch,
kannst auch Vektoren addieren und so weiter.
Deshalb, da war ich jetzt nicht so beeindruckt davon.
Ja.
Ich habe das mit dem Multiplizieren nicht verstanden,
was du meintest mit Skalar mal Vektor und Vektor mal Skalar,
wo ist denn der Unterschied, dass das nicht komutativ ist?
Das ist die Reihenfolge.
Du kannst halt nicht ...
Eigentlich mathematisch gesehen ist diese Operation komutativ,
aber in Python, an dieser Stelle ist sie noch nicht komutativ,
weil wenn du die Mul-Methode implementierst,
auf einem, auf deiner Klasse,
dann musst, wenn du x mal y machst,
dann wird x Punkt Mul aufgerufen.
Weil ansonsten wird dann tatsächlich, ja, genau,
ansonsten von dem Skalar die Mul-Methode aufgerufen,
da gibt es den Vektor nicht.
Genau, und die kann natürlich nicht mit Vektoren umgehen.
Und damit es in die andere Richtung geht,
brauchst du eine zweite Special Method,
da heißt R-Mul, also Reverse Multiplication.
Und die hat er aber auch später verschoben,
weil die später noch mal kommt.
Ach, man kann auch R-Mul, interessant, das wusste ich auch nicht.
Genau, damit eben diese Komutativität.
Aber es wird zuerst Mul aufgerufen,
das heißt, da geht es dann auch noch um Präzedenz,
und deshalb verschiebt er das, glaube ich, auch später.
Wie kriegt man denn die Präzedenz hin?
Also ich möchte das gerne spoilern, bitte.
Die kriegst du hin, also,
ist in dem Fall jetzt hier tatsächlich unproblematisch,
aber du musst dann natürlich Typechecks machen,
dass du sagst, okay, was ist denn, wenn ich ein R-Mul mach
mit dieser oder jener Sorte von Objekt?
Weil da kann ja dann prinzipiell alles rein.
Alles, ja.
Matchcase mit Typechecks.
Ja, so mit einem Matchcase oder mit einem ...
Alles, was du nicht implementiert hast,
wird einfach im Normalkreis abgehandelt,
und ansonsten schreibst du für alle Caches,
die einmal auftauchen, was rein.
Find ich gut.
Im Endeffekt macht der Interpreter das ja auch so, ja.
Also wenn eine von diesen Methoden halt einen Fehler wirft
oder kein Ergebnis zurückgibt,
dann wird halt so lange weitere Methoden durchprobiert,
bis es eins gibt, und wenn es keinen gibt,
dann sagt er halt, das ist nicht definiert für diese Typen.
Das haben wir ja auch alle schon mal gesehen, oder?
Dass man versedelich einen String zu einer Zahl addiert hat
und dann gesagt bekommen hat, das kannst du nicht.
Es sei denn, man war in JavaScript.
Ja, ja, das ist halt so ein fundamentaler Unterschied
zwischen JavaScript und Python.
Ja, genau.
Ich finde das ja auch sehr ...
Ich weiß nicht, haben wir überhaupt schon definiert?
Mir fällt das gerade so heiß ein,
jetzt reden wir schon die ganze Zeit drüber,
aber ich weiß nicht, haben wir überhaupt gesagt,
wie diese Dunder Methods denn aussehen?
Also wir haben immer irgendwie zwei Underscores,
damit fangen sie mal an, und hören immer mit zwei Underscores auf.
Genau, Dunder, für alle Leute, die es nicht kennen, das Unterstrich.
Dunder ist halt quasi die Abkürzung für Double Underscore Before
and Double Underscore After.
Warum haben wir Underscores damit?
Man denkt, die gibt es gar nicht, damit man die nicht sieht,
damit die nicht auffallen.
Nö, Konvention.
Keine Ahnung.
Wie du so unterscheiden kannst von allen anderen.
Das ist eine Konvention im Python-Interpreter,
wenn du eine Methode hast, die zwei Unterstriche vorne
und zwei Unterstriche hinten hat,
dann verspricht der Interpreter gar nichts darüber.
Das kann sich jederzeit ändern,
und es kann jederzeit passieren, dass die nicht mehr funktioniert.
Ist einfach nur eine visuelle Abtrennung,
dass du siehst, dass das was Spezielles ist.
Aber wenn ich das richtig verstehe,
ruft man solche Methoden niemals selber einfach so an?
Nein, niemals stimmt nicht so ganz.
Also ab und zu schon.
Eine ganz populäre ist, achso, das wolltest du auch gerade sagen,
ist halt ...
Ich tu ja, DunderInit.
Dann ruft man den Init explizit auf von außen.
Ständig.
Nur mit Super.
Nee, ständig.
Ja.
Wenn du halt Klasse, Klammer auf, Klammer zu,
dann hast du schon aufgerufen.
Das ist ja die implizite.
Ich meine, dass du explizit jetzt dran schreibst Init.
Ja, okay, das passiert tatsächlich nicht so häufig.
Ja, bei Super aufrufen schon.
Ja gut, aber das ist ja eine super Analyse.
Absolut im anderen Init.
Und das offensichtlich.
Einen Sturmfile kenne ich jetzt eigentlich keinen.
Also sei denn, man will irgendwas debuggen oder so,
dann machen wir alles anders.
Es ist halt auch nicht notwendig.
Das ist ja der Trick da dran.
Du brauchst die nicht direkt aufrufen,
weil es gibt da Syntax-Sachen.
Wenn ich jetzt ein App definiere, dann mache ich einfach ein String,
dann kriege ich das Ergebnis.
Und wenn ich ein Apps definiere,
dann möchte ich halt irgendwie mit den Dingen rechnen
und gucken, was passiert.
Oder beim Bool vergleiche ich mit irgendwas oder so.
Oder ich mache ein If vor.
Das sind halt so Dinge, die eine gute Interventierung sind,
um mit normaler Python-Syntax und den Objekten zu interagieren.
Also zum Beispiel Equals oder so.
Oder Lesser than.
Oder ein komparatives Verhalten zwischen einzelnen Objekten
von Klassen oder von Instanzen.
Ja, du kannst halt sozusagen mit dem Interpreter so interagieren,
wie die anderen Teile in Python halt auch.
Und das ist halt eine Besonderheit von Python.
Das geht in vielen anderen Sprachen nicht.
Genau, das macht es halt toll.
Das ist halt genau das Schöne an diesen Magic Methods ist,
dass wenn man das ordentlich interventiert,
man hinterher, wenn man das nicht so gut kennt,
wenn man das ordentlich interventiert,
man hinterher in seinem Code Sachen machen kann,
die sehr natürlich aussehen.
Und die auch in der logischen Sprache dann natürlich Sinn machen,
wenn man Dinge miteinander vergleichen möchte,
die man dann vielleicht auch vergleichen kann,
weil man den ordentlichen Namen gegeben hat.
Und das aber einfach mit den instanzierten Objekten geht.
Und man halt nicht irgendwie komische Dundern-Methoden
oder irgendwelche kryptischen Namen an Objekten aufrufen muss,
wie das in anderen Sprachen der Fall ist.
Und das ist toll, weil dieser Syntax-Sugar Magie macht.
Und deswegen finde ich den Namen Magic Methods auch sehr schön.
Ja, das ist auch eine tolle Idee.
Ich finde den Namen Magic Methods auch sehr schön.
Ja, du kriegst also Zugriff auf die Innereien des Python-Integrators.
Und du kannst dich da genauso rein integrieren wie alle,
als ob du dazugehörst. Und das ist schon was sehr Schönes.
Aber du hast eben noch was anderes gesagt, Dominik,
was auch hier vorkommt, was ich auch in meinen Notizen habe.
Du hast gesagt, du möchtest hier die String-Methode implementieren.
Und dann kriegst du eine schöne String-Repräsentation raus.
Welche Reprä-Methode?
Ink.
Oh, dann muss ich noch mal zurückscrollen und mir das anhören.
Aber das ist tatsächlich was, ich tendiere auch dazu,
immer die String-Methode zu implementieren,
weil man das halt so gewöhnt ist.
Bei Java machst du Two-String, bei irgendwelchen anderen
machst du irgendeine Two-String-Transformation oder was auch immer.
Und in Python gibt es da ja zwei davon.
Es gibt Repre und String.
Genau.
Und der Unterschied ist schwer zu erklären,
weil er nicht so was Formales ist.
Ich versuch's trotzdem mal.
Die Repräsentation ist das, was in der Kommandozeile auftaucht,
oder einem String, wenn du ihn da reingeschrieben hast.
Und String ist das, was rauskommt, wenn du die String-Conversion versuchst.
Ja, aber warum macht man da überhaupt einen Unterschied?
Warum braucht es da zwei?
Könntest du da genau einen Einheimischen machen?
Das identifiziert das Objekt?
Okay, erklär du, Johannes.
Nee, also das geht schon so ein bisschen runter auf die Krux des Problems,
weil diese zwei Methoden doch relativ ähnlich sind.
Aber interessanterweise, wenn du den String nicht implementiert hast,
fällt der zurück auf Rep, also auf die Repräsentation.
Und die Repräsentation ist in dem Sinne ein bisschen formaler,
weil das heißt, du sollst eine Repräsentation wählen,
die du idealerweise direkt in den Interpreter rein kopieren kannst.
Und das schränkt dich natürlich relativ ein.
Das heißt, da hast du üblicherweise dann so was wie eben einen Konstruktor
da drin stehen oder eine String-Repräsentation des Konstruktors.
Die String-Methode soll einfach nur eine menschenlesbare Beschreibung
dieses Objektes sein.
Und die kann dann natürlich auch was anderes sein.
Also zum Beispiel für diese Vektor-Klasse,
da hat er als Representation halt den Namen der Klasse, Vektor 2,
Klammer auf, dann die beiden Koordinaten und dann Klammer zu.
Und das ist gut, weil das kannst du direkt rein kopieren,
das identifiziert genau diese Sache.
Als String-Methode, hat er jetzt hier kein Beispiel im Buch drin,
würde ich aber tatsächlich was anderes wählen.
Ich würde entweder je nach Kontext vielleicht eckige Klammern wählen
oder in einem mathematischen Kontext vielleicht sogar runde Klammern.
Genau, spitze Klammern, Entschuldigung.
Oder vielleicht sogar runde, je nachdem, welchen Kontext es hat.
Und da hat man natürlich einfach mehr Freiheit,
weil das einfach eine menschenlesbare Darstellung dieses Objektes sein soll.
Und ich tendiere eher dazu, die String-Methode zu implementieren
und die Argumente, die hier der Luciano uns gibt,
die lassen mich jetzt doch auch tendieren dazu eher Rapper zu sein.
Also das ist sozusagen die Regel, die man da mitnehmen kann,
ist halt, wenn man sich entscheiden muss,
dann lieber eher nur die Rapper-Methode implementieren,
nicht unbedingt das andere.
Und das war mir auch nicht so in der Feinheit klar,
was jetzt da der genaue Unterschied oder der Sinn dahinter ist.
Und das weiß ich jetzt voll gut, weiß ich schon wieder mehr.
Ja, das ist voll gut, oder?
Ja, ja, ja.
Ich war etwas überrascht, als ich das Buch angefangen habe,
weil das erste Kapitel schon ordentlich rangeht.
Ein Fängerbuch, hat Jochen gesagt.
Nein, das ist auf jeden Fall ein fortgeschrittenes Buch.
Und der macht auch keine Pausen, der geht direkt weiter hier.
Zwei Klassen mit Operatoren, also das ist diese Deck-Klasse
und die Vector-Klasse, und dann macht er noch Bool-Implementierung
und dann geht es gleich mit der Collection-API weiter.
Auch das, sehr interessant, sehr interessanter Abschnitt
über die Collection-API, wo natürlich jetzt mehr an Details drin ist,
die ich weder präsent hatte, noch jetzt so präsent habe.
Ja, also jetzt muss man es trotzdem mal kurz einmal vorlesen, bitte.
Ja, dafür ist das Buch halt, also das Buch ist schon dicht,
okay, ich gebe es zu, aber dafür ist es halt auch nicht so lang.
Ja, das stimmt.
Die nächste Lüge, Jochen.
975 Seiten.
Aber es ist ein Taschenbuch-Format, also kann man locker
auch in die Tasche stecken, ist auch relativ klein.
961, also vielleicht 18 mal 20 Zentimeter.
Ja, also das ist auf jeden Fall doch die Größe,
die man sich locker unter das Kopfkissen legen kann.
Damit es sich von automatisch lernt, ja.
Kannst du dein Kopfkissen ersetzen, kannst du das mit dem Buch.
Ja, aber tatsächlich, also diese, da ist sogar ein UML-Diagramm,
das muss ich sagen, weil ich so fast ein bisschen geschreckt bin.
Oh, jetzt traufe ich es auch.
UML-Diagramm, oh Gott, oh Gott, oh Gott.
Aber ja, an der Stelle macht es tatsächlich Sinn.
Ja, genau.
Dominik und ich, wir blättern jetzt gerade für die Zuhörer.
Ja, genau, da gibt es halt ein UML-Diagramm von der Collection API.
Und was ist jetzt die Collection API?
Ich habe es immer noch nicht genau verstanden, bitte wiederhol das doch nochmal.
Ja, also die ist sozusagen.
Was ist überhaupt eine Collection?
Um was geht es da?
Meta-Tools oder?
Ne, da geht es darum, wie grundsätzlich quasi Objekte in Python irgendwie so funktionieren,
die eine Collection von irgendwas sind.
Und das sind halt die allermeisten, ja.
Das sieht jetzt hier nicht so aus, sieht nach irgendwas Speziellem aus,
aber das sind halt die allerallermeisten sind da so was.
Und da gibt es also Collection selber.
Man hört es zwar klicken, Jochen, aber.
Also damit es eine ist, müssen drei Sachen irgendwie implementiert sein.
Also es gibt halt drei Methoden, die sozusagen dann ein Ding zu einer Collection machen.
Und das ist halt.
Iter?
Iter, ja, du kannst halt irgendwie drüber iterieren.
Also einen Iterator bauen, einen Generator, der irgendwas yieldet.
Ne.
Nein.
Du kannst, es muss halt irgendwie.
Fast.
Mal ganz generell, so eine Collection ist einfach eine Sammlung von anderen Sachen.
Ja.
Eine Sammlung von anderen Dingen.
Und um das zu ermöglichen, gibt es jetzt hier diese verschiedenen Interfaces, die der Jochen jetzt gerade auszeigt.
Okay, also erst mal, es muss eine iterable sein, ja und dann?
Ja, es muss irgendwie.
Muss nicht, aber kann.
Doch, muss eigentlich.
Also eine Collection, okay, eine Collection muss das schon sein.
Aber es kann ja, es kann etwas geben, was iterable ist, aber keine Collection ist.
Ja, klar, genau.
Das gibt es natürlich.
Aber eine Collection muss iterable sein und das ist irgendwas, was yieldet.
Ja, sie muss halt iterable sein, also sie muss halt irgendwie eine Größe haben, sie muss halt size sein und sie muss halt irgendwie ein Container sein, in dem man halt fragen kann, ja, ist das denn in dir drin oder nicht?
Und das sind die drei Dinge, die man halt quasi implementiert haben muss, damit man irgendwie eine Collection ist.
Also ist this a part of your collection?
Wie viel wirst du denn?
Und gib mal mehr von dir, von allem, was in dir drin ist.
Das heißt, wenn ich über alles iteriere, dann habe ich alles drin, was drin war, alles Toys.
For everything in collection, iterable?
Ist das so, Jochen?
Ja, müssen iterate über alle?
Nee, ich denke nicht, ich denke nicht.
Also du kannst ja dann in der, wenn du das implementierst, da drin ja machen, was du willst.
Das kann jetzt auch von irgendwas anderem abhängig sein, was das zugegeben hat.
Es muss nur das Iter-Protokoll erfüllen.
Ja, genau, es muss nur das Protokoll erfüllen.
Es muss nur mal eins, ein nächstes rausgeben.
Also immer dasselbe, wie das mit der Pathologischen Edge Case ist.
Gib mir mal alle deine Dinge.
Ich will das erste, nee, du kriegst das erste.
Du kriegst doch das erste.
Nein, das und das erste, immer das erste.
Nee, nee, du rufst ja, das Iter-Protokoll ist ja, du rufst immer Next auf, auf dem Iterable-Protokoll.
Ach, das ist doch ein geiler Passwort.
Das heißt, du kriegst immer ein nächstes Element.
Aber das bedeutet nicht, dass du alle kriegst.
Und das bedeutet auch nicht, dass du alle kriegen kannst.
Es gibt ja diese Pathologischen Edge Cases, die man immer in Einführungsveranstaltungen macht,
dass man sagt, hier, wir machen jetzt jetzt mal was Iterable.
Und das berechnet einfach die nächste Primzahl.
Es gibt ja alle Primzahlen.
Aber das ist natürlich keine Sammlung, die je aufhört.
Was ist denn der Unterschied?
Über alle Primzahlen, die drin.
Unterschied, Joachim?
Mit dem Generator und dem Next und dem Yield und dem ...
Naja, also Iter ist halt die grundsätzliche Geschichte.
Das ist halt das, was du brauchst, wenn du ein Vor-Irgendwas in Irgendwas sagst.
Ja, ein Generator ist eine Spezifikation, das ist halt nicht so allgemein.
So ein Generator heißt halt dann, sozusagen da, ja, kriegst du halt eins nach dem anderen Ding.
Also wenn ich jetzt irgendwas iteriere, ist das was anderes als ein eins nach dem anderen?
Also sagen wir mal so, Generator ist nochmal eine speziellere Geschichte.
Das ist jetzt nicht das Gleiche, wie was du integrieren kannst.
Das ist was anderes.
Ein Generator implementiert, ja.
Ein Generator implementiert das Iterable-Protokoll.
Also ist schon Iterable, ein Generator.
Aber es ist eine sehr spezielle Art von was, Iterable.
Aha, okay.
Aber eine Liste ist auch irgendwie was Iterable ist, aber das ist kein Generator, gar nicht.
Nein?
Nein.
Das Comprehension schon.
Also wenn du eine List Comprehension schreibst, kriegst du eine Liste zurück.
Du kannst den Generator Expression hinschreiben, dann kriegst du einen Generator.
Aber das ist wieder was anderes.
Also, ja.
Aber interessant finde ich halt, dass das halt reicht.
Also diese drei Dinge, also wenn du die Dynamethods Iter, Len und Contains implementierst,
dann hast du halt ein Collection quasi.
Und dann gibt es halt noch die eine zusätzliche Geschichte,
die halt sozusagen dann daraus etwas, nochmal was Besonderes macht.
Das ist halt Reversible.
Wenn das irgendeine Reihenfolge hat, dann ist es halt eine Sequence.
Ja, aber das ist halt das, was das unterscheidet.
Also eine Sequence kann halt irgendwie beliebig sortiert werden.
So, das macht es halt so besonders.
Und das klassische Beispiel ist eine Liste.
Wenn man Sequence sagt, kann man immer an eine Liste denken.
Ja.
Und genau, ansonsten ist halt ein Tickt, ist halt auch ein Collection,
ist halt ein Mapping sozusagen.
Und ein Set ist keine Liste, aber ein Set ist schon eine Collection.
Genau, das ist der dritte Basistyp.
Aber keine Sequence.
Genau, also das sind dann die Basistypen, die sie da ableiten.
Sequence, Mapping und Set.
Ach, Set auch, okay.
Und die drei verhalten sich unterschiedlich.
Und daraus, das sind aber die Dinge, man dann einsetzt.
Also diese Bausteine, also ein pures Iterable, ich meine,
geht prinzipiell schon, oder ein pures Sized.
Ja.
Ah, ist nicht nett, dass ich das schon mal gesehen habe.
Aber natürlich Sequence und Mapping und Set,
das sind die Sachen, die man dann tatsächlich benutzt.
Weil da hast du dann die Bausteine zusammengesetzt zu dem,
was man tatsächlich einfach braucht.
Das, was dann sinnvoll ist.
Ja.
Und da kann man dann auch Beispiele sagen.
Also ein Beispiel von einem Iterable könnte ich jetzt nicht unbedingt sagen.
Also von einem puren.
Ja, ein Huhn.
Aber von einer Sequence ist easy.
Ein Huhn.
Ein Huhn ist ein Iterable.
Liegt ein Ei, liegt noch ein Ei, liegt noch ein Ei, liegt noch ein Ei.
Ja.
Das wüsste ich jetzt nicht, wie man es in Python implementiert, aber ja.
(Lachen)
Es gibt auch Hühner in Python.
Dann ist halt die Frage, was war zuerst da?
Das Ei oder das Huhn?
Ah, ja, weiß ich auch nicht.
Wenn du eine große Schlange hast, kannst du ja mal einen Huhn reintun.
Und dann schauen, ob es iteriert.
Ich habe letztens irgendwo so ein Schaubild gesehen,
wo ein Biologe meinte, so was, eine Quatschfrage.
Also wir wahlen hier einfach mal so diesen evolutionären Stamm auf.
Und dann haben wir überall Eier, aber nur da ganz unten ein Huhn.
Natürlich war das Ei zuerst da.
(Lachen)
Völlig triviale Frage.
Ja.
Okay.
Genau.
Und Mapping, ich meine, das kennt man auch.
Das ist ein Dictionary.
Und Set kennt man auch.
Das ist ein Set.
Und das sind dann die Sachen, die man tatsächlich benutzt.
Aber diese Protokolle, also das, was die tatsächlich an Funktionalität anbieten,
das ist hier zusammengesetzt aus diesen ABCs,
aus den Abstract Base Classes.
Benutzt die das eigentlich immer?
Der Trick ist, dass, wenn du diese ABCs implementierst,
dann, genau wie vorhin bei den Special Methods oder bei den Magic Methods,
dann kannst du dich in den Python-Interpreter so reinintegrieren,
wie wenn du ein Dict wärst oder eine Liste oder was auch immer.
Ja.
Also dann habe ich ein Interface implementiert.
Kann man das so sagen?
Ja, es heißt hier nicht Interface, sondern Protokoll.
Aha.
Das heißt, beim Typing Protokoll kann ich das dann benutzen?
Das ist nochmal eine andere Geschichte.
Aber ja, das ist eine andere Art, das zu machen.
Aber das macht quasi genau ...
Also Abstract Base Classes, ja, braucht man das?
Also du kannst ...
Das Problem bei den Abstract Base Classes,
das ist halt, es funktioniert halt anders.
Es ist halt sozusagen, das hatten wir in der Typing-Episode auch,
es ist halt sozusagen nominative Typisierung in dem Sinne,
dass du jetzt bei jedem Ding, das du erzeugst,
dadurch, dass du von so einer Abstract Base Class erbst,
sagst du halt genau, was es ist.
Und das ist das, weil man es davon erbt.
Genau, bei Protokoll nicht, weil es kann so sein.
Ich finde, das ist im Protokoll viel flexibler für so was
und auch viel besser geeignet.
Ja, aber es hat dann natürlich auch wieder Nachteile.
Naja, wenn du sagst, es muss eine Collection sein,
die da reingeht, dann ist doch scheißegal,
was für eine Collection das ist.
Weil das Protokoll der Collection erfüllt
und die dann des Mappings oder des Sets oder so was.
Und da ist irgendein Set, das da rein muss.
Aber du sagst, es muss diese Sachen da drin haben,
die im Protokoll definiert sind.
Also in den Methoden, die man für ein Set halt braucht.
Genau, aber das sagst du ja damit.
Ja, aber dann ist das doch okay.
Aber dann muss ich doch keine Abstract Base Class verwenden.
Das ist irgendwie komisch.
Doch, klar. Das ist ja genau die Formalisierung davon.
Du erbst von dieser Abstract Base Class,
dann hast du erst mal nichts umgesetzt,
dann implementierst du die ganzen Sachen.
Nein, Protokoll.
Dann wirst du zu einer Collection. Deine Klasse ist eine Collection.
Du kannst das auch überprüfen.
Wenn du nur im Typing sagst, das entspricht dem,
dann hast du das nicht überprüft.
Wenn du ein Protokoll-Ding machst,
dann würdest du sagen, ist Instance of Collection.
Sagt ihr halt, ne, eher nicht.
Was du dann machen kannst,
ist halt, dein statischer Typechecker kann immer noch Fehler finden.
Ja, genau.
Mein Linter sagt mir halt,
der will jetzt eine Collection haben und nichts anderes.
Ja, aber wenn da jemand anders ein Instance auf deinem,
was auch immer das Ding ist, irgendwie aufruft,
dann kriegt der nicht und sagt, ist das eine Collection?
Dann kommt er zurück, nö, ist nicht.
Ja, okay, weil das kein hartes Geerbt ist.
Weil es ist nicht wirklich eine Collection.
Aber es interpretiert nur das Protokoll als wäre es eine Collection.
Genau, also das ist quasi die Formalisierung davon.
Du gibst es technisch rein und sagst, das ist eine Collection.
Glaubst du der Sprache, die das Instance überhaupt hat,
oder glaubst du deinem Linter, der dir sagt,
das könnte passen oder nicht?
Naja, es hat halt alle so Vor- und Nachteile.
Den Linter glaub ich überhaupt gar nicht.
Ja, aber warum will ich denn jemals testen,
ob es Instance of Collections ist?
Ich will nur wissen, ob das lintert, weil es die Methoden implementiert.
Und ich will, ob es Instance of, keine Ahnung, meine Superliste ...
Ja, nee, es ist halt so eine ...
Da gibt es ja schon Use Cases dafür, dass du sagst, okay,
hier hat eine Funktion, die alles Mögliche ...
Oder es ist Instance ...
Ich hab eine Funktion, die alles Mögliche verarbeiten kann,
muss ja schon eventuell auf unterschiedliche Arten drücken.
Ich will nur wissen, ob ich in einer Collection gucke.
Und ich will niemals wissen, ob es eine Collection
von irgendwelchen abstrakten Dingen ist.
Deswegen ist es Bullshit, das mit abstrakten Base Classes.
Meine Meinung nach ist es super, wenn es ein Fotovolg gibt.
Damit du noch nie eine Bibliothek implementiert hast,
die so eine Funktionalität anbietet, ist es jetzt schade, aber so ist es.
Ich meine zum Beispiel, wo das halt häufig auftritt,
also wo ich das kenne mit denen, dass man halt irgendwie,
es gibt halt viele Methoden, zum Beispiel nehmen wir jetzt
irgendwelche Modelle oder so.
Und da kommen halt manchmal so wirklich komische Sachen rein.
Und ich hab auch schon viel Scikit-Learn-Code zum Beispiel gelesen.
Und so viele Methoden oder viele Funktionen, die fangen an mit,
also, sag mal, bist du eigentlich ein so was?
Oder bist du vielleicht so was?
Und dann machen sie halt unterschiedliche Dinge,
je nachdem, was das dann ist.
Und das ist halt teilweise, das ist wirklich lang am Anfang.
Und ich wüsste jetzt nicht, wie man das anders machen könnte,
außer so.
Also, ja.
Eine Sorte Funktion, die man auch häufig sieht in Bibliotheken,
ist, wo du entweder einzelne Elemente reingeben kannst
oder gleich eine ganze Sammlung.
Und dann musst du halt auch am Anfang dieser Funktion
in der Implementierung unterscheiden können,
ob du jetzt gerade ein einzelnes Element in der Hand hast
oder ganz viele einzelne Elemente.
Und da musst du schon irgendwie eine formalisierte Unterscheidung machen.
Da geht es ja zur Laufzeit nicht.
Also, es macht schon seinen Sinn, diese Sachen so zu deklarieren,
insbesondere, wenn du eben hier solche, sag ich mal,
grundlegenden Funktionen implementierst.
Man kann das auch zu weit treiben.
Wenn man das zu weit treibt, dann kriegt man Java.
Und man muss da eine Balance finden.
Aber es ist, um wieder darauf zurückzukommen,
es ist schon interessant, dass das eigentlich so
relativ simple Sachen sind.
Also hier dieses UML-Diagramm ist eine Viertelseite.
Und es stehen ja wirklich nicht viele Sachen da drin.
Es sind nicht viele Methoden, die man umsetzen muss.
Ja, und das ist halt irgendwie quasi,
also die meisten oder viele Leute werden sich niemals
aus diesem Universum von dem, was da definiert ist, rausbewegen.
Weil damit quasi fast alles erschlagen ist,
was man so normalerweise so tut.
Das ist schon faszinierend, dass das geht, ja.
Außer Skalare, okay, die stehen da jetzt auch nicht drinnen.
[lacht]
Ja.
Und dann ist das erste Kapitel ja schon fast vorbei.
Dann haben wir noch hier die Übersicht der Dunder Methods.
Da wird einmal noch mal komplett alle aufgeführt.
Schön, so völlig ohne Zusammenhang hier mit Metaprogramming
und Abstract Base Classes und Attribute Descriptors
und Attribute Management.
Also da ist es interessant, da reinzuschauen,
was es alles gibt.
Ich wüsste jetzt nicht bei allen, was die tun.
Was ist der Unterschied zwischen GetAttribute und GetAttribute?
Ja, es kommt in Kapitel ...
[lacht]
Ja.
Also das eine ist irgendwie noch mal ein Stückchen allgemeiner,
glaube ich, als das andere.
Ich glaube, GetAttribute ist halt das wirklich ganz allgemeine Ding
und GetAttribute guckt halt wirklich ...
Ganz tief runter.
Das eine ist näher dran, oder?
Ja, also GetAttribute kannst du auch,
aber damit kannst du auch Methoden übersteuern.
Genau, die Frage ist halt, wann, welches Stick das reinguckt,
wenn du guckst.
Aber so ganz genau weiß ich das jetzt auch alles nicht.
Oder InitSubclass.
Wüsstest du, was InitSubclass macht, Jochen, oder Prepare?
Ich weiß es aus einem ...
[unverständlich]
InitSubclass, das ist halt ...
Der Grund, warum Leute Metaclusten verwenden, ist eigentlich der,
dass sie halt irgendwie die Clust-Instanzierung ab und zu
mal so ein bisschen modifizieren wollen.
Also Metaclusten selber zum Benutzen ist super viertelig.
Man muss extrem aufpassen, was man da tut.
Und daher ist das halt so ein bisschen auch in Verruf geraten
und Leute raten einem davon immer, auf das zu machen.
Aber genau, man kann, wenn man jetzt InitSubclass verwendet,
dann kann man fast alle Anwendungsfälle, für die Leute
normalerweise so Metaclusten verwenden, halt damit hinkriegen
und hat all diese Probleme nicht, die man halt sonst so kriegt,
wenn man Metaclusten verwendet.
Und das ist eingeführt worden mit Python 3.6.
Und ich weiß das halt nicht deswegen, weil ich sowieso immer alles weiß,
sondern in dem speziellen Fall ...
[lacht]
In dem speziellen Fall schon.
In diesem Fall weiß ich es, weil den Pep dafür hat irgendwie ...
Wir hatten ja Martin hier auch mal zu Gast,
der irgendwie dann diesen xfile-ronken-Laser geschrieben hat.
Und den Pep zur Einführung von InitSubclass,
den hat er geschrieben und ist damals in Python 3.6 reingekommen.
Und deswegen hast du natürlich ganz besonders ...
Okay, dann habe ich jetzt das Falsche gefragt.
Dann sag mal, was SubclassCheck macht, Jochen, weißt du mal alles?
Ja, siehste, weiß ich nicht, keine Ahnung.
Ja, okay, gut. Also das kommt dann in einem späteren Kapitel.
Und da sind auch MRO-Entries.
Also ich meine, dass man da sein MRO bearbeiten kann,
das ist ja schon hart.
Kann man sich einfach sagen, ich bin jetzt ein bisschen tiefer implementiert
und ich bin jetzt einfach Type.
Ja, keine Ahnung, ich weiß es nicht.
[lacht]
Wir werden es im Laufe dieser Vortragsreihe,
eine Type vielleicht lernen.
Genau, aber was mich auch überrascht hat, ist das, wie viel ...
Oder machen wir jetzt das ganze Buch heute.
[lacht]
Also keine Zeit.
Einmal anschneiden, Türen schließen.
Was ich auch irgendwie nicht erwartet hätte,
also ist das halt so viel Zeug sich um arithmetische Geschichten
und Operator-Overloading handelt.
Mehr als die Hälfte.
Und das hätte ich jetzt nicht gedacht.
Wenn man mich jetzt nachts geweckt hätte und gefragt hätte,
welche Magic Messes gibt es und was machen die so,
dann wäre ich jetzt bei sowas wie Repre oder irgendwie, genau,
Bool oder weiß ich nicht, sowas gewesen.
Augmented Bitwise Arithmetic.
Ja, aber ...
Ja, es geht in beide Richtungen und dann geht es mit Integer
und dann gibt es mit Reversed und dann gibt es mit Augmented
und dann gibt es mit Bitwise und mit Reversed und Augmented.
Das gibt es alles in drei verschiedenen Varianten jeweils.
Sonst sind es ja nicht so viele, aber ...
Ja.
Ja, ja, ja.
Ja gut, Mathematik regiert die Welt.
Ja. [lacht]
Das, das, ja.
So ist es.
Ja.
Ja, dann, das ist doch interessant hier.
Und am Ende seines Kapitels hat er immer noch einen Soapbox-Abschnitt.
Den finde ich auch sehr schön.
Ja, ja, genau, wo er sich hinstellt und mal ein bisschen predigt.
Und das, das fand ich hier tatsächlich auch sehr schön.
The Art of the Meta-Object Protocol.
Großartiger Buchtitel und habe ich mir jetzt auch mal auf meine Liste ...
Das musst du noch mal genau erklären, bitte.
Ne, ich weiß es auch nicht, ich habe es auch noch nicht gelesen,
aber ich fand den Titel gut genug, dass ich es mir direkt
auf meine Leseliste gesetzt habe.
Was ich viel interessanter fand noch, war ganz am Ende was,
er sagt hier, der Autor, der dieses AMOP-Buch geschrieben hat,
The Art of the Meta-Object Protocol,
der hat aspect-oriented programming entwickelt oder getrieben.
Und ich habe es dann mal auf Wikipedia nachgelesen,
was aspect-oriented programming ist, aber nicht so richtig verstanden.
Also Aspekte sind auch irgendwas mit Magie, oder?
Da geht es entweder um Wasser oder Feuer oder ...
Ja, es ...
Irgendwas mit gegen die Muggel.
Ja, vielleicht. Ich weiß es nicht.
Ja, muss uns mal jemand erklären.
Ich würde gerne mehr wissen, wie es geht.
Aber da sind auf jeden Fall in dieser Soapbox schöne Pointer drin,
wo man dann dem geneigten Leser als Übungsaufgabe überlassen wird.
Vielleicht werden die Designer von Goo irgendwann das Meta-Objekt-Protokoll erweitern.
Aber das ist im Moment nicht das, was man auf dem Niveau mit dem man
im Python arbeiten kann.
Genau, das ist halt das, was er hier dann sagt.
In anderen Sprachen hast du die Möglichkeit nicht.
In Goo gibt es tatsächlich Magic-Sachen,
weil die halt im Interpreter drin sind, kommst du auch nicht dran,
kannst nichts machen.
Und Pech gehabt.
Und das ist ja in Python eben nicht so.
Deshalb hier Muggel-Methods.
Jeder kann da hingehen und die Finger drauflegen
und dann so tun, als ob er zu Python gehört.
[lacht]
Du wolltest damit einen exklusiven Kreis aufmachen, lieber Johannes.
Du musst nur die magischen Worte wissen
und dann in der richtigen Reihenfolge sagen
und dann deinen Zauberstab in der richtigen Bewegung schwingen.
Ja, du musst aber schon noch in jede Ecke vom Raum
schon eine Kerze reinstellen und so.
Das ist dann das Meta-Programming, was du da meinst.
[lacht]
Und Meta-Klasse.
Ja.
Da muss man immer ein bisschen aufpassen,
was man da mit sich heraufbeschwört.
Wenn man zu viel Meta macht, dann kann das auch.
Zu viel Magie.
Ja.
Marry meet, marry greet.
And marry meet again.
Also wegen des Heraufbeschworens.
Das erste Kapitel war nicht so lang.
Nö, du warst überrascht.
Es fängt ordentlich an und ist dann aber nach 19 Seiten schon vorbei.
Also das fand ich überraschend.
Der legt ordentlich los und macht dann aber gleich direkt eine Pause.
[lacht]
Ja, danach kommen dann jetzt Sequences und Bits und Sets.
Ja, das ist ja deutlich länger.
Da hat man schon mal drüber gesprochen.
Dann hat man schon mal drüber gesprochen,
wir können einfach ein bisschen weiter.
Pattern-Matching ist ja auch sowas, das haben wir auch noch nie wirklich ausführlich besprochen.
Das sollten wir vielleicht auch mal tun.
Das gibt es in Kapitel 2.
Das ist tatsächlich etwas über 60 Seiten lang.
Das ist dann gleich deutlich länger.
Aber ich meine, wenn man auf 980 Seiten kommen will,
muss man ab und zu mal eine füllen.
Kapitel machen.
[lacht]
Wie viele Kapitel gibt es denn?
Ich habe gar nicht nachgeguckt.
Ich habe einfach losgelesen, ohne zu lesen, wie viele Kapitel es gibt.
Du hast ja viele, 900 Seiten. Hast du ein bisschen Platz?
24 Kapitel gibt es.
Hätten es 25 sein sollen?
Oder wie ist eine andere von den magischen Zahlen,
damit man auch in die richtige Stelle kommt?
Nee, 24 ist doch gut.
Das ist eine Abundant Number, oder?
Das ist doch eine, wo die Summe der Teile größer ist als die Zahl selbst.
Okay.
Das ist doch immer gut.
Aha.
Ja, jetzt kommen die Mathe-Nerds raus.
[lacht]
Okay, kannte ich auch noch nicht.
Ja.
Da habe ich eine Buchempfehlung dazu, wenn dich das interessiert.
These Wonderful Numbers.
Da ist quasi zu jeder Zahl sind die Eigenschaften beschrieben.
[lacht]
Hm.
Das ist ein sehr nerdiges Buch für nerdige Mathematiker.
Einfach keine Angst haben, die Dunkelheit länger ins Auge zu schauen.
Je älter man wird, desto mehr versteht man davon auch.
Ach ja, als Mathematiker hat man da keine Angst davor.
Hat auch wieder was mit Magie zu tun.
Worte der Weisheit.
Genau, spezielle Art von Magie.
Genau.
Da wir die ganze Zeit von Magie reden, würde ich gerne meinen Pick tatsächlich nehmen.
Oh.
[lacht]
Ich nehme doch täglich noch einen European Talk, weil der liebe Rodrigo einen sehr schönen Talk gemacht hat über so Törtel.
Kennt ihr vielleicht.
Auch ganz magische Sachen macht das.
Das kann Dinge auf die Leinwand malen, die sich drehen, spiralen.
Und dann kann man das erweitern, auch zu Fraktalen.
Dann kann man animierte Fraktale für Live-Performances zum Beispiel schreiben.
Und zwar relativ einfach, indem man so einfache mathematische Prinzipien verwendet.
Und der war ein toller Talk zu, der hat auch einen schönen Blockbuster dazu geschrieben.
Deswegen würde ich den gerne mal in die Schulung zwingen.
Okay, okay.
Okay, gut, cool, spannend.
Mhm.
Ich habe heute zwei Picks dabei.
Aha.
Der erste Pick ist ein Buch ähnlichen Ausmaßes wie Fluent Python.
Ich halte mal hier die Kamera für die anderen beiden.
Oh, okay.
Als es kam, ist es ein tatsächlich ähnliches Format.
Es heißt "Django 5 by Example" von Antonio Mele.
Und ich glaube, dass das ähnlich ist wie Fluent Python, nur halt für Django.
Sehr cool.
Ganz frisch mit Django 5.
Ich habe es leider noch nicht durchgelesen.
Es ist, wie gesagt, auch dieses Buch hat 750 Seiten, ein bisschen weniger, aber trotzdem ähnliches Format.
Was ist das mit diesen Autoren von Programmierhandbüchern?
Warum müssen die immer so viel schreiben?
Ach, ich weiß auch nicht.
Ist doch viel Zeit.
Es gibt viel zu sagen.
Ja, gut.
Ich glaube, der Trick da drin ist, dass es "by example" ist und sehr viele handfeste Projekte enthält,
wo er sagt, wir machen jetzt mal einen Blog und jetzt machen wir noch mehr Blog und jetzt machen wir noch mehr Blog
und jetzt machen wir noch Social Website und Social Authentication und Content Sharing und Online Shop
und Tracking User Actions und Managing Payments and Orders and Extending Your Shop
und Internationalization und Caching und E-Learning und Content Management und API.
Das geht so ein bisschen in die Richtung, wo auch Fluent Python hingeht, dass es halt über die Basics hinausgeht.
Und ich glaube, dass das eine Lücke in meinem Bücherschrank füllt, von der ich bisher nicht wusste, dass ich sie hatte.
Und das freut mich sehr.
Also hast du jetzt endlich Zeit, deinen Django-Webshop zu implementieren, von dem du schon die ganze Zeit träumst?
Mein Blog, ich werde jetzt endlich mal meinen Blog modernisieren.
Ja, genau. Generators, das war gestern, jetzt ist es wieder.
Ja, nee, das ist doch langweilig. Ich muss dynamisch sein und mit User Tracking und mit Payments and Orders.
Ja, das würde ja auch mal Zeit.
Ja, ja, klar.
Roi, roi, roi. Wieder Magie.
Der zweite Pick, den ich mitgebracht habe, ist eine Bibliothek, die heißt Dramatik oder vielleicht heißt sie auch Dramatic Queue.
Und das kam auf in einer Diskussion über, was kann man denn statt Celery verwenden?
Da gibt es jetzt zwar in Django was, die Background Tasks, hatten wir ja vorhin auch schon kurz.
Ja, hast du den selben Mastodon Social Thread gelesen?
Ja, auf dem Bayer. Und ich habe mir aber die Links rausgeklickt. Und einer, der mir ins Auge gestochen ist, war eben Dramatic, was auch so ein Queueing System ist,
was aber ein bisschen eine pythonischere Syntax hat als Celery jetzt zum Beispiel.
Und das sah auf den ersten Blick sehr gut aus und ich freue mich da drauf, das irgendwann mal einsetzen zu können.
Hm, ja, stimmt. Habe ich mir auch angeguckt. Das klingt tatsächlich nett.
Ich hatte noch keine Zeit und habe mir gedacht, wenn ich jetzt eh noch bis April warten darf, bis Django Background Task rauskommt, dann spare ich mir einfach.
Du kannst es auch jetzt schon verwenden. Also ich meine, es ist noch nicht wirklich dafür gedacht, dass man es jetzt verwendet,
aber Django Task ist ja sozusagen, du kannst es einfach installieren und dann verwenden. Geht.
Ja, ja, warum eigentlich nicht?
Kann vielleicht noch zu wenig, aber ja. Also ist auf jeden Fall eine gute Idee, wenn man das noch nicht gemacht hat, einfach mal das auszuprobieren,
weil dann muss man nichts mehr umstellen, wenn es dann irgendwann tatsächlich rauskommt.
Ja, also es gibt so ein paar Module. Wie heißt das, Django Background Task tatsächlich?
Django Tasks heißt das Paket. Das ist irgendwie komisch.
Ja, so ist sein Name.
Und Django Tasks ist tatsächlich gut im Vergleich dazu. Und Django Background Task gibt es auch und das wird man schwer wieder loswerden.
Ja, ich verlinke das dann, aber es ist genau.
Es gibt mehrere Module, die ähnlich benannt sind, die alle versuchen, was ähnliches zu tun oder mal so oder so naiv implementiert sind und dann relativ anstrengend wieder zu enden.
Wie auch immer, also Django Tasks ist, glaube ich, das, was wir nehmen wollen.
Genau, ja, was ich jetzt, ich habe, ich weiß nicht, ist auch etwas Spezielleres, was jetzt gar nicht so viel mit Pipelines zu tun hat.
Du warst einfach nur auf Shoppingtour.
Ja, aber ich finde das ganz interessant, weil ich habe ganz lange jetzt so Dinge verwendet, wie, also ich habe auch schon mal, also ich mache mal so.
Du hast doch erst Geburtstag, Jochen.
Aber ich brauche es ja für was anderes.
Ich habe auch tatsächlich irgendwie mal vor, mal, mal wieder, also ich werde es nicht schaffen, irgendwie, ich wollte mal Videos machen, mehr, wieder.
Und dann, da brauche ich natürlich auch entsprechendes Equipment für.
Da soll ich jetzt zunächst mal meine Euroracks-Sammlung picken, wenn ich das kriege.
Ja, mach das, finde es gut.
Also wie kriegt man eigentlich quasi Bilder von der Kamera irgendwie auf den Rechner?
Und ich habe auch schon sowas wie Lightroom verwendet oder so, früher mal.
Und dann irgendwann dachte ich mir, ach, das brauche ich alles nicht mehr.
Und dann habe ich irgendwie teilweise auch eine Zeit lang sogar Apple Fotos verwendet und fand das ganz okay, weil ich muss ja nicht viel machen und es hat geklappt.
Und jetzt geht das aber nicht mehr, weil die RAW-Files, die aus der Kamera ausfallen, die mag Apple Fotos nicht mehr.
Ich habe eine neue Kamera gekauft.
Ja, und da gibt es aber dann vom Hersteller, von Nikon, gibt es halt ein Nikon NX Studio und die Software kann dann halt tatsächlich das RAW-Format lesen.
Und das, was cool ist, das wusste ich gar nicht, dass das geht, das versteht das so gut, dass es halt irgendwie auch die, also quasi Profile für alle möglichen Dinge aus der Kamera drin hat.
Das heißt, wenn du das halt jetzt in der Kamera schon so eingestellt hast, dann kriegst du das halt automatisch mit rein oder sowas bei anderen, bei Lightroom oder so eben nicht kriegst.
Und du kannst auch dann dir deine eigenen Profile zusammenstellen und wieder auf die Kamera speichern und dann kannst du halt Bilder machen, die genauso sind, wie dein Look halt aussehen soll und so.
Das heißt, du kannst den vorher vorprogrammieren?
Ja, ja, also das ist wirklich, man kann damit halt Dinge machen, die sonst nicht so richtig gehen. Das fand ich ganz nett. Und also viele Leute schwärmen da auch von, dass das halt irgendwie mit den Farben richtig umgeht und solche Sachen, was halt immer so ein Problem ist bei Fotos.
Und das ist alles richtig und das ist wirklich faszinierend, das kann mehr als man so erwartet. Auf der anderen Seite ist es halt unfassbar schlecht programmiert.
Unglaublich, also einmal ist es ultra langsam und dann ist, also man kann es halt nur so ein paar Minuten lang verwenden und dann verbraucht man irgendwie.
Das klingt halt so noch ein neues Hobby, du hast ja gerade schon Computerspiele in Rust programmiert, das wird's wetter.
Ja, ja, vielleicht zu viel Zeit, ich weiß nicht genau. Aber also das leckt halt unglaublich, was Speicher angeht und das verbraucht halt irgendwie innerhalb von, so nach einer halben Stunde sind die 32 Gigabyte weg und dann muss man es neu starten.
Was natürlich irgendwie echt totaler Quatsch ist, aber.
Hast du nicht genug Speicher oder musst du neu starten?
Nee, das ist halt alles.
Wieso hast du nur so wenig Speicher, Jochen?
Ich bin nicht nur GPU pur, ich bin auch RAM pur.
Ja, nur 32 Gigabyte.
Ja, das ist schon ziemlich lächerlich, muss ich auch sagen, stimmt.
Aber ja genau, also da kann man nicht genug, kann man irgendwie mit dem RAM kaufen nicht hinterher kommen, wenn man halt Software hat, die einfach irgendwie das alles wegkriegt.
Einfach so ohne Grund.
Jedenfalls genau, also aber wenn man das sich lange nicht angeguckt hat, weil man immer dachte, ah das ist alles furchtbar, vielleicht nochmal hingucken, ist ganz interessant, was da so passiert. Also ich meine, ist auch so ein bisschen ärgerlich, aber auf der anderen Seite auch faszinierend, was da alles so geht.
Genau, tja.
Ja, vielleicht muss ich doch irgendwann.
Das war jetzt aber schon ein sehr spezieller Pick, Jochen.
Ja, war sehr speziell.
Nochmal, was wir bei Foxhot oder sowas machen, wenn wir hier die ganze Zeit nur so Mediensachen tun wie mit den Bildern.
Wir sind ja in so einem Mediumdings hier auch.
Ja.
So Musik, ja die Musik, die ich mache, die finde ich meist sowieso abartig.
Ja, ich glaube, dann sind wir für diese Episode tatsächlich ausnahmsweise mal früh fertig.
Ich habe übrigens tatsächlich zwischendurch Kritik bekommen auf YouTube, heißen von Leuten, die den Podcast hören, die meinen, es wäre viel zu lang, es wäre total nervig, man könnte es gar nicht mal zwischendurch hören, sondern müsste eigentlich immer so viel Zeit von dem, man kommt da gar nicht durch, man hört sich nie zu Ende.
Ja, da muss man ein bisschen.
Also alles, was Sie an weiterer Kritik, Anregung fragen und so weiter, hallo@pythonpodcast.de.
Bleibt uns gewogen, hört uns weiter. Danke, Johannes, dass du wieder da warst.
Das nächste Mal gerne wieder vor Ort, du weißt, das war eine.
Ich komme jedes Mal gerne vorbei, wenn ich da bin.
Ja, wir freuen uns wieder drauf.
Ja, danke Jochen und wir hören uns bald wieder.
Bis dann.
Bis dann, tschüss.