Transkript: Das Python Data Model

Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python Podcast Episode 58.

Oh, 58, boah.

Ja, gar nicht so schlecht, oder?

Über das reden wir heute?

Bei Floh und Python.

Hi Jochen.

Jo, Halli, hallo Dominik, herzlich willkommen.

Und hi Johannes.

Johannes, hi.

Schön, dass du da bist.

Ja, schön, dass ihr wieder da seid.

Die hatten nicht ja schon ein paar Mal hier, habe ich gehört.

Ich war schon.

Ich glaube, ein oder zweimal oder so ungefähr dabei.

Ja, glaube ich auch.

Anderthalb oder so.

Wir wollen heute bei einem Buch sprechen, Floh und Python, von Luciano Ramalho.

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 das tollste Buch ausgedruckt, wo du dann.

Lieblings-Python-Buch und dann dachte ich, ah ja, da kann man ja vielleicht mal so ein bisschen durchgehen, was er so die.

Ich lese mal kurz aus dem Buch vor, weil du sagtest ja Anfänger.

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, it may give to the Every Python Scripture, Leverage Special Messers, and Metaprogramming Tricks und so weiter.

Also da 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 da auch drin, aber das machen wir ja jetzt gar nicht.

Noch nicht.

Das machen wir dann.

Okay, dann steigen wir leicht auch noch mit

Datenstrukturen und 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, ich weiß nicht, ob wir schon 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 Erfolge dazu gemacht.

Steht noch auf unserer Möchten wir gerne machen Liste.

Aber vielleicht jetzt noch zu News.

Gibt es denn was Neues in Python, in der Python-Community oder

Python Base?

Seitdem wir das letzte Mal aufgenommen haben, haben wir es nicht so wahnsinnig.

Wie passiert das jetzt auch?

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 ihm geschnackt, wie das halt so ist.

Ich weiß aber nicht, ob das News-Charakter hat.

Also außer mich persönlich natürlich.

Was ich sehr genossen habe, war tatsächlich Lukas Langer und der Python-Rapple 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.

Es war so ein bisschen eine Mischung aus iPython mit Bunt und man konnte richtig coole Sachen machen und Bindings und Fancy Stuff.

Ist so ein bisschen ein Spaß-Talk gewesen.

Also er hat dabei Musik gemacht, dann Euro Rek angeschlossen und seiner MIDI-Synthesizer damit bedient.

Also genau war mein Ding.

Fanden die Talks draußen, schaut doch mal rein.

Ist mit Sicherheit sehr nett.

Und was ich auch ganz gut fand, war, wir haben alle relativ viel darüber diskutiert, was Armin Runacher so erzählt hat, zu was scheiße läuft in Python und zwar das ganze Packaging-Ding und so.

Das sind wir wahrscheinlich alle derselben Meinung, dass das da irgendwann mal so ein Tool geben könnte, das sowas macht wie vielleicht Cargo für Rust oder so.

Ja, nee, der Meinung bin ich aber nicht.

Also wäre, also ich bin der Meinung, dass es schön wäre, wenn wir sowas hatten, aber ich glaube, ich fürchte, dass wir sowas nicht kriegen können.

Okay, aber das ist ja was anderes.

Weil da

gibt es auch schon 23 Tools, die sowas machen.

Ja, ja, genau.

Genau, genau, das ist der Punkt.

Also Armi meinte halt auch, dann gibt es halt noch ein 24-st, aber das ist so, das ist der alte X-KCD-Comic, ne?

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 Piptools und Pienf und Conda und 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 der 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 ein Notebook in die Hand nehmen wollten oder irgendwie irgendwas anderes, das war immer Schmerzen damit verbunden.

Ja.

Und da ja Rust gerade so.

Nein, eigentlich ist es ganz einfach.

Also du musst folgende Sachen installieren.

Es ist wirklich nur eine sehr kurze Liste.

Erstmal brauchst du Build-Essentials und dann brauchst du die ganzen Abhängigkeiten und libjpg und libjpg 98 und libjpg 2K und dann musste Pyenf installieren und dann bist du schon fast so weit wieder.

Und dann Apel, eine Banane und wie auch im Tag den ganzen Dschungel.

Und ja, ja.

Also ich habe am StellPython am Sprint und für Pyran so ein paar Sachen installiert, weil ich es kompilieren wollte, es hat tatsächlich drei Stunden gedauert, bis du kompiliert hast auf meinem Tun langsam.

Klasse.

Ja.

Aber so ist das manchmal.

Ja.

Ja, also ich bin mal gespannt.

Also ich bin da, 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 Paps zu etablieren, die quasi das standardisieren und die sind gescheitert alle bisher.

Auch das letzte Mal, als jetzt, der, wie heißt er jetzt noch, einer ganz bekannter, einer der bekanntesten Python-Core-Entwickler, der halt auch da irgendwie so ein großes Team bei Microsoft Leitet war, der große Kanadier, wie heißt er noch?

Ich habe den Namen vergessen, keine Ahnung.

Auf jeden Fall, der hat da versucht, einen Pad zu gemacht, das ist halt hinterher gescheitert, weil ja, also mit dem Fazit, es geht nicht.

Armi meinte, 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 lasse ich mich überzeugen, aber das, ja, gut.

Wenn wir dann sehen.

Was auch interessant ist, ja, es gibt einmal diese UV-Geschichte, da gibt es dann auch noch diese Firma von Charlie Marsh, die hat ja das irgendwie übernommen, das zum Ende, das UV, ne?

Ja, genau.

Ja, also UV und Rai, das war von einem.

Die integrieren sich tatsächlich relativ, die reden auch voneinander und übereinander und so und die integrieren einander relativ viel.

Und Rai plus das UV, statt Piptools, glaube ich, oder so über dann darüber, das sieht alles gar nicht so schlecht aus.

Und die Firmen schafft Astral oder so.

Und die machen ja auch Rough und das, was eigentlich auch relativ gut funktioniert, finde ich.

Ja, ja, die machen so eben ganz viel und Rust.

Gibt es auch eine Firma hier, also es gibt ja da irgendwie auch eine schnellere Alternative zu Conda, Mamba von Prefix Death oder weiß ich nicht, Wolf Vollprecht oder so.

Den könnten wir vielleicht auch mal, den können wir immer zu diesem Thema fragen.

Ja, falls du gerade zufällig 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 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.

Es nervt.

Und vielleicht, also Standards, also ich mag ja zum Beispiel diesen Go nicht, weil zu viel Standard und so, ne?

Es ist immer zu viel Opinion und so.

Und dann, okay, dann nutzt man dann doch Black.

Aber vielleicht gibt es so ein paar.

Moment habe ich nicht verstanden, was nutzt.

Also ich mag das 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, Tabs instead of Spaces, weil ich will das so.

Wenn ich das anders möchte.

Und das nervt mich immer so ein bisschen, weil das das schon in Python ist, das ist halt dynamisch, ich kann es halt 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.

Äh, ja.

Ja.

Okay, ja gut, kann man machen, wie man will.

Ja, also ich meine, aber wenn man jetzt bei Black dann irgendwie eine Konfigurationsdatei jedes Mal beschieben muss, ist halt auch irgendwie ad absurdum, ne?

Ja, genau, weil Black gibt es das halt nicht, genau.

Dann muss halt was anderes nehmen.

Aber es gibt ja auch noch andere.

Das ist so eine Sache, die denke ich mir schon lange, dass eigentlich diese ganze Code-Formatting-Debatte, die ist doch Quatsch, oder?

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 sie dir passt.

Ja, genau.

Und 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.

So ein bisschen so, da müsste mal jemand was machen.

Da kommt dann immer der Einwand, dann mach doch mal was dagegen, sag ich, nee.

Naja, das Problem ist halt, wie kriegst du denn aus dem Ast wieder was, wenn du jetzt tatsächlich was manuell anders hast.

Du möchtest ja eine VR-Brille aufziehen und dann hast du vor dir den Einbalken, den Eingrafen und hast die Notes, musst du alle durchmarschieren.

Kannst du dich auf deine Laufbahn stellen und hinlaufen.

Nee, also da gibt es bestimmt Leute, die das so wollen, aber da, 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, ja, 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, ja, dann will ich da nicht überall Braces haben.

Dann muss doch mein Editor 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 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, Entschuldigung.

Ja, das muss doch dein Editor können.

Das muss doch eine Einstellungssache bei dir sein.

Aber wir kommen aber gleiche Python-Code raus.

Ja, aber 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 dahin transformiert werden?

Das kannst du nur so ein bisschen.

Also in der Standardform geht leicht, aber der umgekehrt geht halt nicht.

Oder?

Über ein Sprachmodell.

Ich glaube, das geht in alle Richtungen.

Aber das wäre halt das, was da zu beweisen wäre.

Und ich glaube, dass 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 wie muss man.

Das ist unbewiesen, ja.

Das ist hier so ein, wie gesagt, so ein Jemand sollte das mal tun.

Projekt.

In meiner vierstelligen Liste der Nebenprojekte ist es nicht auf Platz 10.

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 eine Lösung haben, die tatsächlich von allen so mitgetragen wird.

Das wäre schon irgendwie nice to have.

Also so ein Kolorabotive-Spiel, äh, Kolor, boah, Zungenbrecher.

Ihr wisst, was ich meine.

Ja, Kolorabor,

aber du meinst du meinst jetzt für Code-Format?

Äh, nein.

Achso, okay.

Ich meine für Packaging.

Packaging.

Und also Installation und Python generell und Binaries verteilen und Setup und Venfs und Dependencies und sowas alles.

Naja, ich habe mir da halt diese Diskussion halt so ein bisschen angeguckt und die hinter mich so ein bisschen hoffnungslos zurückgelassen, weil also auch die Leute, die sich ja mit Crafty haben, die sind ja, 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

mit beschäftigt.

Ich möchte mich nicht damit beschäftigen, was für Polen Python beim Package installieren, beim Ventfahrt, 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 macht hat, da halt nicht drin hat.

Ja, aber da müssen wir auftämig.

Das sind also so junge.

Ja, aber das ist das Problem.

Ja, aber ein Großteil von dem Zeug, das verwendet wird, ist halt älter als 20 Jahre und macht Dinge, die total komisch sind.

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.

So immer 2013, 2015.

15.

Mai 2015, also neun Jahre.

Nicht so schlecht.

Habe 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, gut, das stimmt natürlich.

Wobei Python 3 ist jetzt auch noch nicht, ist doch auch erst seit ein paar Jahren.

Ja.

Sag ich aber Zeit für Python 4.

Okay.

Die nächste Version ist Python 8, oder?

Da gab es doch mal so ein April-Chat.

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 lustiger Talk.

Wer ist nochmal der Release-Manager von 13 und 14, wisst ihr?

Thomas Waters kommt.

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 da vorne, weil wir drei behalten 3,25, weil Semantic Version irgendwie Blut wäre und ja.

Müssen Sie sich aber auch noch irgendwelche lustigen Tiernamen ausdenken, die da dazu passen.

Und bitte alphabetisch aufsteigend.

Ja, genau, so ungefähr.

Das war dann die Debatte.

Ja, also ich meine, es gab viel Spaß und die Talks sind mit Sicherheit auch irgendwann bald da.

Die kann man sich alle angucken.

Es gab ja verschiedene Tracks, der Data-Track 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 es 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 Feintun, dass man 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.

Sowas.

Ja.

Wasche News haben wir noch?

Jochen.

Ah ja, jetzt wo es um Europe Python ging, was mir eingefallen ist, stimmt.

Wir hatten ja letztes Mal auch über die DjangoCon Europe 2024 geredet.

Und die Vorträge sind jetzt online.

Wir können uns ja 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 Treffen der Python-User Group, äh, Django Cologne User Group, wo es dann halt auch einen Vortrag gab über Background Tasks, was ganz interessant war, genau.

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 das wäre richtig gut.

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 Europäisten konnte man halt abends, wenn man ganz 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 einmal halbfach angucken zum Einschlafen oder zum Runterkommen.

Das war ja schon.

Das heißt, man kann alle Sachen parallel gucken gleichzeitig und ja, oder am Denger frühstücken, wenn man mag.

Was echt schön ist.

Sehr zu empfehlen, sehr zu empfehlen.

Ja, ansonsten so in Ermangelung von Dingen, die jetzt mit Palten so viel zu tun haben, was mich, äh, was mich hier gerade so noch so ein bisschen umtreibt, ist halt, ja, ja, es war bald Urlaub und ich habe ein bisschen neue Hardware irgendwie mir zugelegt.

Ja, Jochen, das ist keine Werbeveranstaltung hier.

Nee, aber also was ganz cool ist, es gibt jetzt so ein, tatsächlich, also dieser Haushalt enthält Computer, kann Spuren von Computern enthalten.

Und das schnellste Computer in diesem Haushalt ist jetzt ein iPad.

Und ja, also da sind ja diese M4-Dinger drin, sondern sie sind sackschnell.

Also es ist unglaublich.

Lass du das jetzt deine Machine Learning-Modelle tun?

Aber das ist doch kein General-Purpose Computer, 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 dann der schnellste, den ich hätte.

Bau doch einfach die CPU aus.

Kannst du dich Wanders einlooten?

Ja, nee.

Genau, also ja, das ist so ein bisschen doof, aber das Ding ist tatsächlich, also es gibt das, M4 gibt es auch noch in keinem anderen Gerät irgendwie von Apple, also nur in einem iPad.

Ja, es ist schon so ein bisschen traurig.

Also es gab auch eine Tastatur diesmal mit einer Escape-Taste, sodass halt irgendwie mit einer Escape-Taste kannst du eigentlich auf iOS überhaupt gar nichts anfangen, sodass halt viele Leute gedacht haben, so es kommt irgendwann macOS für iPad, was voll cool wäre, aber nein, kam nicht.

Und ja, jetzt habe ich ein iPad und kann es nicht benutzen.

Ein bisschen doof.

Aber ja, ansonsten wirklich sehr schnell.

Du kannst doch schnell YouTube gucken.

Ja, genau.

Und gut, genau.

Ich habe noch so eine Platine mitgebracht, die kann man sich ankleben und mit so einem Magneten und da kann man so einen Text hin und her laufen lassen.

Und da gibt es so ein Python-Modul, da kann man dann den Text auswählen.

Und das ist dein schnellster Computer.

Psst.

Ja, genau.

Und ja, ansonsten gab es noch so ein bisschen irgendwie LLM-Krams.

Ja, da gibt es doch immer was, oder?

Caspack hat tolle 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, dann ist Zusammenarbeit mit Nvidia entstanden.

Das ist ein 12B-Modell.

Das ist also etwas größer als diese 7B-Modelle und es ist wohl genau so trainiert, dass du es auf einer normalen Grafikkarte laufen lassen kannst.

Also auf einer 40, 90.

Ja, die haben ja alle normalen.

12, 12 Gigabyte.

Völlig ganz normal.

Hauptsprecher, ja.

Genau.

Und es 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, also war das Microsoft Research, ich weiß es nicht, ich hatte einen Paper veröffentlicht zu einem Modell, das die gleiche Performance irgendwie über viele unterschiedliche oder sogar deutlich bessere Performance über viele unterschiedliche Benchmarks hingekriegt hat als GPT-3.5, aber auf einer einzelnen GPU läuft.

Also auf so einer Consumer-GPU.

Und das war auch zum ersten Mal, dass es jemand geschafft hat, quasi GPT-3.5 auf irgendwie so Consumer-Hardware zu schlagen.

Und das auch selber ein.

Also, das wird jetzt, geht jetzt, du kannst da wirklich auf deinem Rechner zu Hause irgendwie Sachen laufen lassen, lokal auf deiner Spielegrafikkarte, die halt irgendwie das Chat-GPT vom Anfang halt deutlich schlagen.

Und das ist interessant.

Also, ja, es geht halt an.

Ja, da tun sich doch viele Dinge.

Das ist schön, dass da so auch so völlig, sag ich mal, normale Sachen, ja, dass sich jetzt hier GPT-4 und 4.0 und so, dass die sich weiterentwickeln und Cloud Sonnet und so weiter.

Achso, und das Mister Nemo-Modell hat einen 128K Kontaktwindow, das ist 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, das 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.

Dass es nicht nur so eben in diesen Hochburgen und in den Dienstanbietern festhängt, sondern die Szene ist auch sehr lokal.

Und wenn man sich da mal so dieses, wenn man sich Hugging Face anguckt, ja, an wie viele Pflege von Lama es gibt und dann gibt es manche, wo die, wo das Sicherheitstraining weg ist und man einzelne spricht nur Piratensprache und man ist nur diesen, das und jenes klar.

Ja, 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-VO.

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 beschäftigt, aber.

Er hat noch sogar einen Bordseed.

Ja, genau, die haben jetzt, der hat jetzt nicht.

Da kriegt Microsoft wieder doch die Datenfüllung.

Haben sie wieder aufgegeben, sind nicht mehr.

Sowohl Microsoft als auch Apple haben ihren Bordseed aufgegeben.

Es waren eh nur Beobachtende, aber haben sie beide, haben sich beide zurückgezogen.

Ach so, okay, ich dachte eigentlich, dass jetzt sozusagen das Gerücht war, dass das Fallschüler irgendwie ins Board von OpenAI geht, aber.

Ja, haben sie aber wieder zurückgezogen.

Ah, okay.

Dann, naja, dann war ich halt schon nicht mehr so aktuell.

Aber ich meine.

Es bewegt sich so schnell, dass das Ganze nicht.

Falls man hinguckt, das stimmt alles ganz anders.

Aber, naja, gut, also ich in gewisser Weise verstehe ich 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 Riesenhebel.

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, ist auf jeden Fall interessante Zeiten.

Bin mal gespannt.

Aber 4O ist auch so gut, also ich finde das hier auch dauernd, also dass das wahrscheinlich irgendwie.

Was warst denn, Jochen?

Was machst du denn damit?

Wir programmieren.

Achso, ja gut, okay, das geht nicht in den Flow rein.

Ja, aber auch Opus, das ist schon.

Ja, Opus ist auch super.

Also ja, absolut.

Das ist ja

auch 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, ne?

Wenn man halt.

Pipen das irgendwo integriert oder Interface.

Also auch Konsole halt, ne?

Und wenn man halt, dann kannst du halt auch Pipen mit Cut reinpipen, irgendwas.

Oder sag dann halt Template, mach einen Pi-Test 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 man sagen, so ja, ein bisschen mehr in, ne, ein bisschen mehr Fixes, ein bisschen weniger dies, ein bisschen weniger das, wenn man das nicht von dem Systemprompt eh schon drin stehen hat.

Und dann ist das ziemlich das, was man will.

Man kann ja so ein Beispiel geben wie, ey, und so wie ich das hier gemacht habe, so dass es ungefähr so solltest, könnte es aussehen.

Und dann fertig.

Ich bin da mal neidisch, wenn da Leute das so erzählen, weil ich komme mit solchen Systemen einfach irgendwie nicht in den Flor.

Ich komme nicht in den Flow.

Vielleicht muss man sich

da mal zusammensetzen.

E-Makes, Johannes.

Entschuldigung.

Ich habe doch PyCharm, bin noch ein PyCharm-Unterstützer.

Ja, aber hast du da den Copilot zum Beispiel an oder so?

Weil das ist auch schon ganz okay.

Also ich finde ehrlich gesagt, das ist nicht so gut, wie wenn man jetzt quasi direkt mit.

Warte, wann hast du das letzte Mal probiert, Johan?

Keines dieser Systeme hat mich jeder überzeugt.

Okay.

Ich habe es ein paar Mal probiert und das war jedes Mal so.

Johannes hätte es besser gewusst.

Vielleicht ist das Problem, vielleicht weiß ich es einfach besser.

Ja, ich würde es auch sagen.

Na gut, kann man machen.

Da würde ich aber sagen, dass das genau das ist.

Ne, 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, weil Tim Peters, der Co-Entwickler und Autor von Zen of Python, das ja bestimmt alle kennt, ne?

Importis, dann meinte ich, 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 Python.

Muss man direkt mal klar machen, wie die Sachen dann so laufen und genau.

Das ist auf jeden Fall einfacher, etwas Neues zu lernen.

Ja, und dann am 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 tun kann, dann verwenden und kommt damit weiter.

Also sind wir jetzt bei Flutter.

Sind wir jetzt bei Fluid?

Ja, ich würde tatsächlich jetzt so ein bisschen unser Quatsch versuchen, in eine Struktur zu überführen, die uns ein bisschen zurückführt auf dieses wundervoll.

Also ich

fluent, was heißt denn fluend flüssig?

Also ich wollte nicht über das Buch sprechen eigentlich.

Eigentlich wollte ich gar nicht erwähnen, dass das Buch, das wir jetzt aus dem Buch klauen, aber gut.

Achso, du du, ach du, du wolltest einfach so tun, als ist das deine Verdauung.

Entschuldigung.

Achso, den glaube ich Spaß verdauben.

Okay.

Ja, nee, wir können das auch sagen, das ist ja kein Problem.

Aber genau, was wir.

Was es heute im Grunde geht, ist halt wie, sie nennen das Python Data Model oder ein Buch wird es auch so genannt.

Es wird auch eine Referenzdokumente und 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?

Ich tue jetzt mal einmal so, ne?

Also.

Tu mal so, als ob du es nicht wüsstest damit.

Ja, genau,

das reicht doch.

Wie immer.

Also zum Beispiel ist halt die super Beispiel, ist halt, um da vielleicht einen Einstieg zu finden, warum sagt man in Python eigentlich irgendwie Len von irgendwas in einer Collection oder so und nicht Collection.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 ich einfach.

In Java, in Java, die machen das komisch.

Genau, 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 halt praktisch viel besser funktioniert.

Ich verstehe jetzt mal gesagt nicht.

Also warum ist erstens irgendwas mit Klasse und Attribut und Methode callen die reine Lehre?

Und zweitens, was ist das Problem, wenn man irgendeine Funktion hat oder eine call it whatever you like oder the closure und kippst da ein Objekt rein und dann passieren Dinge damit.

Naja, 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 du halt Methoden auf oder was auch immer, wie man das nennt.

Und das ist dann die Sache des Objekts.

Ja, so ist es halt gedacht.

Das ist zum Beispiel in Java so.

Ja, aber warum ist das?

Java heißt Kingdom of Nouns und es gibt quasi keine Funktionen in Java, sondern es gibt nur Objekte und denen kannst du Nachrichten schicken und die machen dann irgendwas.

Und das ist der einzige Mechanismus, den es im Wesentlichen gibt.

Und selbst wenn du sowas hast wie eine Main-Funktion, dann hast du da irgendwo eine Klasse und dann ist es halt eine Static-Methode auf dieser Klasse drauf.

Und anstatt dass du sagst, wenn unser Programm läuft, dann rufen wir die Main-Funktion auf, sagst du, wir schicken eine Main-Nachricht an unsere Main-Klasse.

Aber warum sollte man auf HD eine gute Idee sein könnte?

Warte, was ist das?

Also ich muss mal kurz über die Trade-Offs reden, um das mal so zu erzählen.

Warum sollte man denken, dass das eine gute Idee sein könnte, sowas zu tun?

Naja, es reduziert natürlich schon die Anzahl von Dingen, die es so gibt.

Und halt nur Objekte und Methodenaufrufe und mehr nicht.

Und das ist warum gut?

Also.

Einfach eine Sache lernen.

Oh, komm's Razor, weil einfach halt ein Wegweiser zur Wahrheit ist oder zur Schönheit oder so.

Okay.

Point einzige für den Java-Entwingler.

Okay, und warum ist es denn nicht auch einfach, einfach sowas wie funktionale Programmierung zu machen und da Zeug zu hintereinander hin und her zu reichen?

Was fehlt einem denn da in diesem Vergleich?

Funktionale Programmierung ist ja auch was anderes.

Das gibt es auch, aber das ist was ganz anderes.

Also das ist ja.

Also kann man auch machen.

Aber dann ist es, also das wäre kannst du auch pure haben, sowas wie Haskell oder so dann.

Oder Erlangen oder weiß ich nicht.

Ah, Standard ML.

Ja, Haskell, hier, diese modernen.

Ja.

Aber das ist halt ein anderes Konzept als jetzt Objektorientierung.

Naja, aber wir sprachen gerade.

Von ästhetischer Einfachheit oder so.

Ja, ja, ist es auch.

Aber es ist halt anders.

Da gibt es halt 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 Halten nicht so schön ist, halt, dass man sagt, jetzt muss man halt auch noch so, jetzt machen wir so Build-Ins wie LEN oder so, die so ein bisschen komisch sind.

Aber tatsächlich hat es halt praktisch sehr viele Vorteile, wie, ähm, naja, also einmal, du musst dir nicht für jedes Objekt merken, wie das denn jetzt nun heißt mit dieser Methode, 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 Account.

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.

Wie zum Beispiel, du kannst halt, da diese Sachen, also 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 Methode.

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, sondern 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 natives, also ein Ding im Interpreter selber ist, also da irgendwie ein C geschriebenes Ding, wie ein Dikt oder eine Liste oder sowas ist, dann kann es halt direkt irgendwie in diesem Pi-Objekt irgendwie drauf gucken, wie lang ist denn dieser 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, es sind halt Funktionsaufrufe, Methodenaufrufe immer total langsam.

Es ist halt, da ist wirklich so ein Faktor 1000 dazwischen, zwischen irgendwie 3MC 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 aufrufen.

Ja, 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, ist halt so eine.

Magie.

Genau, ist halt so eine Spezial.

Ja, Magie mag der, mag jetzt zum Beispiel der Autor von Flut und Python an der Stelle gar nicht so gerne.

Also man nennt die Dinger ja irgendwie Magic Methods auch, also dieser Magic Methods,

finde ich eine sehr schöne Diskussion über diese Namen, über die Magic Methods und über die Nicht-Magic Methods.

Ja, 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 auch irgendwie Magic und dann gibt es diverse.

Ja, aber.

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 dokumentiert, was das ist und was das tut.

Und insofern, der Autor sagt selber, ich finde das nicht gut.

Die sollten lieber Muggel-Methoden heißen, 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 irgendwo her aufgerufen.

Wenn du das nicht weißt, dann ist das schon magisch.

Dass du für Anfänger ist nicht ersichtlich, dass wenn du irgendwie so eine Methode dazufügst, die Dinge macht, wo du nicht weißt, warum.

Weil das unter der Haube passiert.

Aber das Spacefield war ja auch nicht.

Also magisch schon gut.

Das macht ja Magie.

Aber es passiert irgendwas, dann machst du einen String auf irgendein Objekt und dann kommt da irgendwas raus, weil du eine Rapper-Methode überschrieben soll.

Ah, Magie.

Ja, 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 doch quasi echte Magie, ich meine.

Echte Magie, da fummelt jemand vor den Augen mit deinem Fingerschnipsen rum und auf einmal zieht er hinter seinem Ohr eine große goldene, glänzende Münze.

Ja, das sind Illusions, das ist keine Magie.

Das ist so ein bisschen aber syntaktische Magie.

Ja, aber echte Magie ist doch das, was man aus Harry Potter kennt.

Dann schwingst du deinen Zauberstab und dann passiert irgendwas die richtigen

Worte in der richtigen Reihenfolge sagen, genau.

Das macht irgendwas, was thermodynamisch nicht möglich ist.

Ja, genau, aber sind wir eigentlich alle relativ einig.

Das gibt es halt auch nur in Harry Potter oder in.

Ich weiß nicht.

Also ich finde tatsächlich die Analogie auch gar nicht so schlecht für Programmieren insgesamt.

Also ich meine, das ist halt, also ich meine, was ist es, also man sagt irgendwie, du sagst die richtigen Werte in der richtigen Reihenfolge und dann passieren Dinge, genau.

Ja, ich finde, das ist gar nicht so weit hergeholt, dass man dann das.

Deshalb sind wir alle Wizards.

Ich habe auch keinen Wizard-Pullover.

Es gibt auch tatsächlich Leute, die Nicht-Programmierer als Moogle bezeichnen.

Also ich weiß, so weit würde ich jetzt nicht gehen vielleicht, aber.

Echt?

Ich bezeichne den mal als NPCs.

Okay.

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, alles für Kartentricks dann.

Und er implementiert nur zwei Methoden, nämlich dann The LEN und dann der Get-Item.

Ja.

Und das reicht aus für Slicing und Ranges und Rewst und Iterationen.

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, ist es einfach nur smart, dass das geht und es ist auch klar, dass es geht.

Wenn ich weiß, wie viele es sind und ich ein einzelnes holen kann, dann kann ich auch mehrere holen.

Okay, cool.

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.

Aber dass es, dass es 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 Namen.

Die schnell auch funktionieren kann, bei dem man einfach so eine Längen-Get-Item definiert.

Ja, aber Johann

ist nicht delegiert.

Sondern der ruft Lenon Get-Item an.

Ja, aber das macht ja die interne Repräsentation von Längen, wird ja aufgerufen.

Also das heißt, die Magie wirklich dann in C-Python passiert, die ja damit schnell ist und so, da muss er implementieren.

Gut, in dem Beispiel wird nicht implementiert, wie du tatsächlich Objekte speicherst, sondern er benutzt eine Liste.

Genau, es wird halt sozusagen, das wird weitergereicht, die Position wird weitergereicht an die Liste.

Genau.

Und die kann halt nicht mehr.

Also die Implementierung, die Implementierung dieser beiden Attribute ist tatsächlich einfach durchdelegiert.

Aber dass du dann daraus eine Slicing-Syntax kriegst mit Rang.

Das ist ja, das macht ja der Interpreter für dich.

Ja.

Das heißt, der macht sich diese Ranges und ruft dann die einzelnen Get-Items auf.

Ja.

Also hat mich auch gewundert, hätte jetzt auch nicht gedacht, dass man dann schon iterieren kann.

Das war mir gar nicht klar.

Das reicht, Get-Items zu implementieren.

Ich muss meine naive Karteninterpretation von meinem Kartenspiel, von meinem Pokerspiel auch nochmal anpassen, wenn ich das so sehe, weil tatsächlich ich da auch immer dann ein Objekt gemacht habe, an den Karten dran waren, was natürlich dann eine Liste war, was aber nicht hieß, dass man einfach das Ding mischt, sondern 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 dran gehen.

Du kannst dran gehen 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, ja, exportiert.

Oder du kannst sagen, ich behandle jetzt eine Liste wie ein XY und Z.

Und dann implementierst du erstmal 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 hast du irgendwie wirkt smart.

Also weil man halt tatsächlich nicht das Rad neu machen muss.

Und ich glaube, das ist eine ganz interessante Punkt.

Das ist ein bisschen Python, aber es ist trotzdem sehr Pythonic, das findest du es implizit ist.

Und in der Kombination, indem man das halt irgendwie schön moderisiert kriegt, kann man tolle Sachen machen.

Das wird, also man musste so ein bisschen Boilerplate schreiben vielleicht, aber wie man es halt hinterher wirklich benutzt, wenn man diese Objekte in der Hand hat, wirkt einfach wie Pure Python irgendwie, oder?

Wenn man halt dann direkt auf dem Deck, was man in der Hand hat, in DCs machen kann, Wendis machen kann und so.

Ja gut, hier geht es ja vor allen Dingen darum, diese Methoden zu erklären.

Aber 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.

Ja, ja, also ich finde es auch, ich finde es auch, also es sieht gut aus.

Kann jetzt keiner sehen, weil es ein Podcast leider ist.

Aber ja.

Kannst du das teilen?

Ist das Public?

Nee.

Na gut.

Also ich glaube, es gibt irgendwo bestimmt auf irgendwelchen Kanälen oder sowas.

Ja.

Das nächste Beispiel, was er bringt, fand ich auch interessant, aber das ist natürlich so ein bisschen dieses Vektorbeispiel.

Das ist natürlich mehr so ein bisschen, ja.

Du musst das einfach weiter erläutern, bitte, bei allen unserer HörerInnen, was denn das Vektorbeispiel ist.

Ja, er macht sich eine Klasse, eine zweidimensionale Vektorklasse.

Sagt er gleich.

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, Apps und Mull.

Und kriegt daraus dann die Möglichkeit, zwei Vektoren zu addieren.

Apps wird hier als die Metrik implementiert, das heißt, es ist die Länge eines Vektors.

Und Mull ist eine Skalarmultiplikation, das heißt, du kannst dann einen Vektor mit einem Integer oder mit einem Float multiplizieren, dann 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 nicht Vektor mit Vektor multiplizieren.

Ja, das ist nicht so einfach.

Das ist nicht so einfach dummerweise, weil.

Das ist mathematisch nicht so einfach.

Das, genau, da steht, glaube ich, im Buch irgendwas drin.

Ja, also wie man es das dann macht mit Magic Method, das ist dann in Kapitel 16 oder so viel weiter hinten.

Das ist nicht so einfach.

Und er sagt auch, er verschiebt auch, dass das tatsächlich in diesen ersten Kapiteln verschiebt er relativ viel auf später, wo er dann so schön, ja, hier, das kommt in Kapitel 17 nochmal oder in Kapitel 38 oder in Kapitel 12.

Tatsächlich auch Skalar mit Vektor multiplizieren, also eine Zahl mal Vektor, verschiebt er auch auf später, weil da brauchst du nochmal einen anderen, eine andere Special Method, weil eben Mull 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.

Und 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.

Da kannst du 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?

Das ist nicht kommutativ.

Das ist die Reihenfolge.

Ja.

Du kannst halt nicht.

Eigentlich mathematisch gesehen ist diese Operation kommutativ, aber in Python an dieser Stelle ist sie noch nicht kommutativ, weil wenn du die Mull-Methode implementierst auf einem auf deiner Klasse, dann musst, wenn du also x mal

Y machst, dann wird das Punkt Mull aufgerufen.

Weil ansonsten wird dann tatsächlich, ja, genau, ansonsten von dem Skalar die Mull-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 Mull, also Reverse Multiplication.

Und die hat er aber auch später verschoben, weil die später nochmal kommt.

Ah, man kann auch R-Mull.

Interessant, das wusste ich auch nicht.

Genau, damit dann eben diese Kommutativität.

Aber es wird zuerst Mull aufgerufen.

Das heißt, da geht es dann auch noch um Präzedenz und deshalb verschiebt er das, glaube ich, auf 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 Type-Checks machen, dass du sagst, okay, was ist denn, wenn ich ein R-Mol mache mit dieser oder jener Sorte von Objekt?

Weil da kann ja dann prinzipiell alles reinkommen.

Matchcase.

Mit Typecase.

Ja, so mit einem Matchcase oder mit einem.

Was du nicht implementiert hast, wird einfach ein Normalkreis abgehandelt und ansonsten schreibst du für alle Cases, die einmal auftauchen, was rein.

Finde ich gut.

Ja, 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, ja, das ist nicht definiert für diese Typen.

Das haben wir ja auch alles schon mal gesehen, oder?

Dass man versehentlich einen String zu einer Zahl addiert hat und dann gesagt bekommen hat.

Das kannst du nicht.

Es sei denn, man war ein JavaScript.

Ja, ja, das halt so ist halt so ein fundamentaler Unterschied zwischen JavaScript und Python.

Ja, ja.

Ja, also ich finde das ja auch sehr.

Ich weiß nicht, haben wir überhaupt schon definiert?

Mir fällt das gerade zu heiß ein.

Jeden reden wir schon die ganze Zeit drüber, aber ich weiß nicht, haben wir überhaupt gesagt, was, wie diese Danda-Methods denn aussehen?

Also die sind immer, haben immer irgendwie zwei Underscores, damit fangen sie mal an und hören immer mit zwei Underscores auf.

Genau, Dunder, für alle Leute es nicht kennen, das Unterstrich.

Unterstrich.

Dunder ist halt quasi die Abkürzung für Double underscore before und double underscore after.

Warum machen Underscores?

Damit man denkt, die gibt es gar nicht, damit man die nicht sieht, damit die nicht auffallen.

Nö, Konvention.

Kann du dir 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.

Niemals stimmt nicht so ganz.

Also ab und zu schon.

Also eine ganz populäre ist, achso, das wolltest du auch gerade sagen, weil ist halt.

Nicht du ja.

Dann der Init.

Ja.

Ruft man den Init explizit auf, von außen.

Naja, nicht.

Nur mit Super.

Ständig.

Nee, ständig.

Ja.

Wenn du halt Klasse, Klammer auf, komm mal zu, dann hast du

schon aufgerufen.

Nein, nein, aber das hast du ja.

Naja, aber das ist ja die implizite.

Ich meine, jetzt, dass du explizit jetzt dran schreibst, Init.

Ja, okay.

Das passiert tatsächlich nicht so häufig, ja.

Ja, bei Super aufrufen schon.

Ja, gut, aber du super machst ja mit Apps im anderen Init.

Und das offensichtlich, aber außer dem Fall kenne ich jetzt eigentlich keinen.

Also sei denn, man will irgendwas debuggen oder sowas, dann haben wir alles anders, aber ja.

Es ist halt auch nicht notwendig.

Das ist ja der Trick daran.

Aber es die nicht direkt

auf mir sein.

Wenn ich jetzt eine App definiere, dann mache ich einfach einen String, dann kriege ich das Ergebnis.

Und wenn ich einen 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.

Aber ich würde dir niemals selber das vormachen.

Und das ist ja aber vielleicht das Interessante an den Dunder-Messets, dass sie halt quasi die Reimplementierung sind, um mit normaler Python-Syntax und den Objekten zu interagieren.

Also zum Beispiel Equals oder so oder Lesser-Sen 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 auch.

Und das ist halt eine Besonderheit von Python, das geht in vielen anderen Sprachen.

Genau, das macht's halt toll.

Das ist halt genau das Schöne an diesen Magic Methods ist, dass wenn man das ordentlich implementiert, 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 denen ordentliche Namen gegeben hat und das aber einfach mit den instanzierten Objekten geht und man halt nicht irgendwie komische Dund-Dan-Methoden oder irgendwelche kryptischen Namen an Objekten aufrufen muss, wie das in anderen Sprachen der Fall ist.

Und das ist toll, weil diese Syntax sogar Magie macht.

Und deswegen finde ich den Namen Mindigmess jetzt auch sehr schön.

Ja, du kriegst also Zugriff auf die Innereien des Python-Interpreters 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 Strill-Methode implementieren und dann kriegst du eine schöne String-Repräsentation.

Ich habe die Repr-Methode gesagt.

Ja.

Achso.

Oh, dann muss ich nochmal zurückscrollen und mir das anhören.

Aber das ist tatsächlich was, ich tendiere auch dazu, immer die Strill-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 Rapper und Str.

Genau.

Und der Unterschied ist schwer zu erklären.

Weil der nicht so, das ist nicht so was Formales.

Ich versuch's trotzdem.

Aber die Repräsentation ist das, was in der Kommandozeile auftaucht oder einem String, wenn du ihn da reingeschrieben hast.

Und das ist das, was rauskommt, wenn du die String-Conversion versuchst.

Ja, aber das geht nicht.

Ja, aber warum macht man dann da überhaupt einen Unterschied?

Konntest du da genau mit einer machen dann?

Das eine 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 Stirn nicht implementiert hast, fällt dir zurück auf Rapper, also auf die Representation.

Und die Representation 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 reinkopieren kannst.

Und das schränkt dich natürlich relativ ein, ja.

Das heißt, da hast du üblicherweise dann sowas wie eben einen Konstruktor da drin stehen.

Oder String-Repräsentation des Konstruktors.

Die Stirn-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 so einen Vektorklasse, 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 reinkopieren, das identifiziert genau diese Sache.

Als Stirnmethode 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.

Oh.

Genau, spitze Klammern, Entschuldigung.

Oder vielleicht sogar runde, je nachdem, welchen Kontext es hat.

Und da hat man natürlich einfach mehr Freiheit, weil es einfach eine menschenlesbare Darstellung dieses Objektes sein soll.

Und ich tendiere eher dazu, die Strillmethode zu implementieren.

Und die Argumente, die hier der Luciano uns gibt, die lassen mich jetzt doch auch tendieren, dazu eher rapper.

Also, das ist sozusagen die Regel, die man da mitnehmen kann, ist halt, wenn man die, wenn man sozusagen sich entscheiden muss, dann lieber eher nur die Rapper-Methode implementieren, nicht unbedingt.

Ja.

Und das war mir auch nicht so in der Feinheit klar, was jetzt da der genaue Unterschied oder Sinn dahinter ist.

Und das weiß ich jetzt.

Voll gut.

Weiß ich schon wieder mehr.

Ja, das ist voll gut, oder?

Ja.

Ja, ja, ja.

Ich war etwas überrascht, als ich das Buch angefangen habe, weil das erste Kapitel schon ordentlich rangeht.

Anfängerbuch, hat Jochen gesagt.

Nein, das ist auf jeden Fall ein fortgeschrittenen Buch und der macht auch keine Pausen, ja, der geht direkt weiter hier.

Zwei Klassen mit Operatoren, also das ist diese Deck-Klasse und die Vektorklasse 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 was prozesen.

Einmal 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 975 sind.

Aber es ist ein Doppelbuchformat, also kann man locker auch in die Tasche stecken, ist auch relativ klein.

961.

Also so vielleicht

15 x 20 Zentimeter.

Ja, also das ist auf jeden Fall doch die Größe, die man sich locker unters Kopfkissen legen kann.

Damit sich man automatisch lernt, ja.

Kannst du dein Kopfkissen ersetzen, kannst du das mit dem Buch.

Ja, aber tatsächlich, also diese, diese, da ist sogar ein UML-Diagramm, das muss ich sagen, da war ich so fast ein bisschen abgestreckt, dass es kaufe ich es auch.

Das UML-Diagramm, oh Gott, oh Gott, oh Gott.

Aber ja, an der Stelle macht es tatsächlich Sinn.

Dominik und ich, wir blättern jetzt gerade für die für die Zuhörer.

Ja, ich genau, da gibt es halt ein UML-Diagramm von der Collection API.

Was ist jetzt die Collection API?

Ich habe es immer noch nicht genau verstanden.

Bitte wiederhol das doch nochmal.

Ja, also die ist.

Was ist überhaupt eine Collection?

Um was geht es da?

Intertools?

Nee, nein.

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.

Das sieht jetzt hier nicht so aus, sieht doch irgendwas Spezielles aus, aber das sind halt die allerallermeisten sind sowas.

Und da gibt es also Collection selber.

Also damit es eine ist, quasi 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.

Itter?

Itter, ja.

Du kannst halt irgendwie drüber iterieren.

Also ein Iterator bauen.

Ein Generator, also irgendwas yieldet.

Nee.

Nein.

Du kannst halt, es muss halt irgendwie.

Fast.

Mal ganz generell, so eine Collection ist einfach eine Sammlung von anderen Sachen.

Eine Sammlung von anderen Dingen.

Und um das zu ermöglichen, gibt es jetzt hier diese verschiedenen Interfaces, die der Jochen jetzt gerade macht.

Erstmal ein Iterable sein, ja.

Und dann?

Ja.

Muss nicht, aber kann.

Noch 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 ist.

Sie muss halt iterable sein, also sie muss halt irgendwie eine Größe haben, sie muss halt sized sein und sie muss halt irgendwie ein Container sein, den 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 es ist a part of your collection.

Wie viel bist 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.

Ist das so, ja?

Muss alles ein Iterator über alle in der Rechnung sein?

Nee, 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 ab nicht sein, was das so ist.

Du musst nur das ITER-Protokoll erfüllen.

Ja, genau.

Ein Nextes rausgibt.

Also immer dasselbe.

Also diese pathologischen Edge-Cases.

Gib mir mal alle in deinem Ding.

Ich will das erste, nee, du kriegst das erste, du kriegst doch das erste.

Nein, darfst du immer nur das erste, immer noch das erste Mal.

Nee, nee, nee, nee, du rufst ja das Iterable-Protokoll ist ja, du rufst immer Next auf auf dem Iterable.

Ach, das doch keine Eltern.

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 da diese pathologischen Edge Cases, die man immer in Einführungsveranstaltungen macht, dass man sagt, hier, wir machen jetzt mal was Iterable und das berechnet einfach die nächste Primzahl.

Es gibt dir alle Primzahlen.

Aber das ist natürlich keine Sammlung, die je aufhört.

Was ist alle Primzahlen iterieren?

Unterschied, Joachim?

Mit dem Generator und dem Next und dem Yield

und dem.

Naja, also weil Iter ist halt die grundsätzliche Geschichte.

Das ist halt das, was du brauchst, wenn du vor irgendwas in irgendwas sagst.

Ja, ein Generator ist eine Spezifile, ist halt nicht so allgemein.

Ein Generator heißt halt dann sozusagen da, ja, kriegst du halt eins nach dem anderen dringend.

Hatte Moment, also wenn ich jetzt über irgendwas iteriere, ist was anderes als ein Eins nach dem anderen.

Also sag mal so, Generator ist nochmal eine ganz, das ist nochmal eine speziellere Geschichte.

Das hat halt irgendwie, das ist jetzt nicht das gleiche wie irgendwie was, über was du iterieren kannst.

Das ist was anderes.

Ein Generator implementiert, ja.

Ein Generator implementiert das

Iterable-Pokoll, ja, genau.

Also ist schon iterable, ein Generator, aber es ist ja eine sehr spezielle Art von was, Iterable.

Aha.

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 Liste Comprehension schreibst, kriegst du eine Liste zurück.

Du kannst eine 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.

Diese drei Dinge, also wenn du halt die, wenn du die Dana-Methods Iter, LEN und Contains implementierst, dann hast du halt eine 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 Sequenz.

Ja, aber das ist halt das, was das unterscheidet.

Also eine Sequence kann halt irgendwie beliebig sortiert werden.

Das macht es halt besonders.

Und das klassische Beispiel ist eine Liste.

Liste ist eine Sequence.

Wenn man Sequence sagt, kann man immer an Liste denken.

Ja.

Und genau, ansonsten ist halt ein Dikt ist halt auch eine Collection.

Ist halt ein Mapping, sozusagen.

Ein Set ist keine Liste, aber ein Set ist schon eine Collection.

Genau, schon ist der dritte Basistyp.

Aber keine Sequence.

Also das sind dann die Basistypen, die sie da ableiten.

Sequence, Mapping und Set.

Und die drei verhalten sich unterschiedlich und daraus, das sind aber die, die man dann einsetzt.

Also diese Bausteine, also ein pures Iterable, ich meine, geht prinzipiell schon oder ein pures Size.

Wüste ich 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.

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.

Aber von einer Sequence ist easy.

Ein Huhn.

Ein Huhn ist ein Iterable.

Nickt ein Ei, liegt noch ein Ei, liegt noch ein Ei, liegt noch ein Ei.

Ja, es wüsste jetzt nicht, wie man es in Python, aber ja.

Es gibt auch Hühner in Python.

Dann ist halt die Frage, was war zuerst da?

Das Ei oder das Huhn?

Ah, ja, ich weiß 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 irgendwo so ein Schaubild gesehen, wo ein Biologe meinte, sowas ist eine Quatschfrage.

Also irgendwie, wir malen hier einfach mal so diesen evolutionären Stammburgen auf und da haben wir überall Eier, aber nur da ganz unten ein Huhn.

Natürlich war das Ei zuerst da.

Das ist eine 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.

Benutze ich tatsächlich auch.

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-Interpräder so rein integrieren, wie wenn du ein Dikt 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 vom Typing-Protokoll kann ich das dann benutzen.

Das ist nochmal eine andere Geschichte, aber ja, das funktioniert dann, das ist eine andere Art,

das zu machen.

Aber das macht quasi genau.

Deswegen, also Abstract-Base-Klasse, ja, braucht man das?

Also du kannst, also das Problem bei den Abstract-Base-Class oder der, das ist halt, es funktioniert halt anders.

Es ist halt sozusagen, das hat man in der Typing-Episode auch, es ist halt sozusagen nominative Typisierung sozusagen in dem Sinne, dass du jetzt bei jedem Ding, das du erzeugst, dadurch, dass du von so einer Abstract Base Classe erbst, sagst du halt genau, was es ist.

Und das ist das, weil was davon erbt, ja.

Genau, und bei Protokoll nicht sein, weil deswegen Protokoll eigentlich viel flexibler für sowas und auch viel besser geeignet.

Ja, 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 das Sets oder sowas, und das ist irgendein Set, das da rein muss, aber du sagst halt, es muss halt diese Sachen da drin haben, die im Protokoll definiert sind, also in den Methoden, die man für ein Set halt braucht.

Genau, aber was sagst du ja damit?

Ja, aber dann ist das doch okay, aber dann muss ich doch keine Abstrakt-Base-Klasse verwenden.

Das ist irgendwie komisch.

Doch, klar.

Das ist ja genau die Formalisierung davon.

Du helpst von dieser Abstract-Base Class, dann hast du erstmal nichts umgesetzt, dann implementierst du die ganzen Sachen.

Nein, Protokoll.

Dann wirst du zu einer Collection.

Deine Klasse ist eine Collection.

Nein, aber dann kannst du es auch überprüfen.

Wenn du nur Typing sagst, das entspricht dem, dann hast du das nicht überhaupt.

Wenn du ein Protokoll-Dings machst, dann würdest du sagen, is Collection, also is Instance of Collection, sagt der halt, nö, eher nicht.

Was du dann machen kannst, ist halt, dein statischer Type-Checker kann immer noch Fehler finden.

Genau.

Ja.

Mein Linter sagt mir halt, ja, nee, aber der will jetzt eine Collection haben und nichts anderes.

Ja, aber wenn da jemand anders eine 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 GRB ist.

Weil es ist nicht wirklich eine Collection in dem Sinne.

Aber es interpretiert nur das Protokoll, als wäre es eine Collection.

Genau, also quasi die Formalisierung davon.

Du gibst es technisch rein und sagst, das ist

keine Collection.

Nicht nur komprimiert damit und das übereinander.

Oder glaubst du deinem Linter, der dir sagst, das könnte passen oder nicht?

Naja, es hat halt alle so Vor- und Nacht.

Glaube ich überhaupt gar nicht.

Ja, aber warum will ich denn niemals testen, ob es Instance of Collections ist?

Ich will nur wissen, ob dann das Lintet, weil es die Methoden implementiert und ich will, ob es Instance auf, keine Ahnung, meine Superliste.

Es ist halt

so, da gibt es ja schon Use Cases dafür, dass du sagst, okay.

Ich will wissen, ist Instance Platten.

Funktion, die alles mögliche.

Oder es ist Instance.

Funktion, die alles Mögliche verarbeiten kann, muss ja schon eventuell auf unterschiedliche

Arten drücken.

Nein, aber ich will wissen, ist Instance Buch, weil wenn ich nach der Bücher Collection gucke und ich will niemals wissen, ob es eine Collection von irgendwelchen abstrakten Dingen ist.

Deswegen ist das Bullshit, das mit abstrakten Base-Klasse.

Meiner Meinung nach so eine super Metal-Karte.

Dass du noch nie eine Bibliothek implementiert hast, die so eine Funktionalität anbietet, ist jetzt schade, aber so ist es.

Ich meine zum Beispiel, wo das halt häufig auftritt, also wo ich ja ich das kenne mit denen, dass man halt irgendwie, es gibt halt viele Methoden, zum Beispiel nehmen wir jetzt bei Data Science-Geschichten, irgendwie sowas wie irgendwie Data Pipelines oder irgendwelche Modelle oder so.

Und da kommen halt manchmal so wirklich komische Sachen rein.

Und ich habe auch schon viel Cyclit-Learn-Code zum Beispiel gelesen und so.

Viele Methoden oder viele Funktionen, die fangen an mit, also, sag mal, bist du eigentlich ein sowas?

Oder bist du vielleicht sowas?

Und dann machen sie halt unterschiedliche Dinge, je nachdem, was das dann ist.

Und das ist halt teilweise wirklich lang am Anfang.

Und ja, ich wüsste jetzt nicht, wie man das anders machen könnte, außer so.

Also, 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 hilft dir auch der Linter nix, weil der geht 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, 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 es 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.

Ja, außer Skalare, okay, die stehen da jetzt auch nicht drin normalerweise.

Ja.

Ja, und dann ist das erste Kapitel ja schon fast vorbei.

Dann haben wir nachher die Übersicht der Dunder Methods, da wird einmal nochmal komplett alle aufgeführt, auch schön, so völlig ohne Zusammenhang her mit Metaprogramming und Abstract Base Classes und Attribute Descriptors und Attribute Management.

Also da ist es interessanter reinzuschauen, was es alles gibt, aber ich wüsste jetzt nicht bei allen, was die tun.

Was ist der Unterschied zwischen GetAttribut und GetAttribute?

Ja, es kommt in Kapitel.

Also das eine ist irgendwie nochmal ein Stückchen allgemeiner, glaube ich, als das andere.

Ich glaube, GetAtter ist halt das wirklich ganz allgemeine Ding und GetAttribute ist halt, guckt halt wirklich.

Ganz tief runter.

Das eine ist näher drin, oder?

Das eine ist.

Also GetAttere kannst du auch, da kannst du auch Methoden überschreiben.

Genau, die Frage ist halt, wann welches Dick das reinguckt, wenn du guckst.

Aber so ganz genau, was ich das jetzt auch alles nicht.

Init Subclass.

Wüsstest du, was in a Subclass macht, Jochen?

Oder Prepare?

Ich weiß es aus einem, wir haben ja auch schon die nächste Episode.

In a Subclass, das ist halt der Grund, warum Leute Metaklassen verwenden, ist eigentlich der, dass sie halt irgendwie die Klasseninstanzierung ab und zu mal so ein bisschen modifizieren wollen.

Und fast alle Use Cases lassen sich, also Betaklassen selber zum Benutzen ist super füttelig.

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 ab, das zu machen.

Aber genau, man kann, wenn man jetzt in eine Subclass verwendet, dann kann man fast alle Anwendungsfälle, für den Leute normalerweise so Metaklassen verwenden, halt damit hinkriegen und hat all diese Probleme nicht, die man halt sonst so kriegt, wenn man Metaklassen verwendet.

Und das ist, das ist eingeführt worden mit Python 3.6 und ich weiß das halt nicht deswegen, weil ich sowieso immer alles weiß, aber sondern in dem speziellen Fall.

In dem Speziellen falsch.

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 in diesen X-File Ronkelaser geschrieben hat.

Und den PEP zur Einführung von Innet Subclass, den hat er geschrieben und das ist damals ein 3-6 reingekommen.

Und deswegen ist es natürlich ganz besonders.

Okay, dann habe

ich jetzt das falsche gefragt.

Dann sag mal, was Subclass-Check macht ja auch.

Weißt du mal alles?

Ja, siehst du, 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 anders sagen.

Das ist ein bisschen tiefer implementiert und ich bin jetzt einfach Type.

Ja, keine Ahnung, ich weiß es nicht.

Wir werden es im Laufe dieser Vortragsreihe

vielleicht lernen.

Genau, aber was mich also auch überrascht hat, ist das wie.

Oder machen wir das ganze Buch heute?

Genau, ja.

Das muss jetzt ein bisschen dauern.

Ihr müsst jetzt euch einmal ansteigen, Türen schließen.

Was ich auch irgendwie nicht erwartet hätte, also ist, dass halt so viel Zeug sich um arithmetische Geschichten und Operator-Overloading.

Also mehr als die Hälfte.

Und das wäre mir jetzt auch, hätte ich jetzt nicht gedacht.

Wenn man mich jetzt so nachts geweckt hätte und gefragt hätte, so, was machen die Magic, welche Magic Messes gibt es und so, was machen die so, dann wäre ich jetzt bei sowas wie Reper oder irgendwie genau Bool oder weiß ich nicht, sowas gewesen.

Augmented und Vice Arithmetic.

Ja, aber.

Ja, es ist auch, es geht in beide Richtungen und dann gibt 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.

Also das gibt es alles in drei verschiedenen Varianten jeweils.

Sonst sind es ja nicht so viele, aber es.

Ja.

Ja, gut, Mathematik regiert die Welt.

Ja.

Das ist es.

Ja, dann ist doch interessant hier.

Und am Ende seines Kapitels hat er immer noch einen Soap-Box-Abschnitt.

Einen Seifenkette.

Den finde ich

auch sehr schön.

Ja, ja, genau, wo er sich hinstellt und mal ein bisschen predigt.

Und das fand ich tatsächlich auch so schön.

The Art of the Meta-Object Protocol.

Großartiger Buchtitel und habe ich mir jetzt auch mal auf meine Liste gesetzt.

Das musst du nochmal genau erklären, bitte.

Ja, 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, wo er sagt, hier der Autor, der dieses AMOP-Buch geschrieben hat, Autometer Object Protocol, der hat Asp-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 Wasser oder Feuer oder.

Irgendwas mit gegen die Muggel.

Ja, vielleicht.

Ich weiß es nicht.

Ja, muss uns mal erklären, dass man gerne mehr wissen, wie es geht.

Aber da sind auf jeden Fall in dieser Soapbox eine schöne Pointer drin, wo man dann dem geneigten Laser als Übungsaufgabe überlassen werden.

Vielleicht werden die Designer von Go irgendwann das Meta-Objekt-Protokoll erweitern.

Aber das ist im Moment nicht das, was man auf dem Niveau, mit dem man in Python arbeiten kann.

Sag ja.

Genau, das ist halt das, was er hier dann sagt.

In anderen Sprachen hast du diese Möglichkeit nicht.

In Go gibt es tatsächlich Magic-Sachen, weil die halt im Interpreter drin sind, kommst du auch nicht dran, kannst du nichts machen.

Und Pech gehabt.

Und das ist ja in Python eben nicht so.

Deshalb hier Muggle Methods.

Kannst du, kann jeder da hingehen und die Finger drauflegen und dann so tun, als ob er zu Python gehört.

Ja.

Du wolltest damit einen exklusiven Kreis aufmachen, lieber Johannes.

Du musst nur die magischen Worte wissen und 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 Metaprogramming, was du da meinst.

Metaklasse.

Muss man ein bisschen auffassen, was man damit sich heraufbeschwört, wenn man zu viel Meta macht.

Das kann auch.

Zu viel Magie.

Ja.

Wie sagt man?

Mary Meet, Mary Greet.

And Mary Meet again.

Also, wegen des Heraufbestand.

Das erste Kapitel war nicht so lang.

Nö, ich bin nicht.

Ich war überrascht.

Es fängt ordentlich an und ist dann aber nach, also hier 19 Seiten schon vorbei.

Ja, fand ich überraschend.

Der legt ordentlich los und macht dann aber gleich direkt eine Pause.

Ja, ja, danach kommen dann jetzt irgendwie Sequences und die Spieler.

Ja, das ist ja wirklich längst und ja.

Da hatten wir

schon mal drüber gesprechen.

Pattern Managing Sache, genau.

Ja, Pattern Managing ist ja auch sowas, das haben wir auch noch nie wirklich ausführlich besprochen.

Das sollten wir vielleicht auch mal tun.

Jetzt gibt es dann Kapitel 2.

Das ist dann, das ist tatsächlich etwas über 60 Seiten lang.

Das ist dann gleich deutlich länger.

Tja.

Aber ich meine, wenn man auf 980 Seiten kommen will, muss man.

Ab und zu mal eine füllen.

Kapitel machen.

Wie viele Kapitel gibt es denn?

Gar nicht nachgeguckt.

Ich habe einfach losgelesen, ohne ja zu lesen, wie viele Kapitel es gibt.

Ja, du hast doch viele, 900 Seiten.

Hast du ein bisschen Platz?

24 Kapitel gibt es.

Ah ja.

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?

Ist doch eine, wo die Summe der Teile größer ist als die Zahl selbst.

Okay.

Ist doch immer gut.

Ja, jetzt kommen die Mathe-Nerds raus.

Okay, kannte ich auch noch nicht.

Ja.

Da habe ich eine Buchempfehlung dazu, wenn mich das interessiert.

These Wonderful Numbers.

Da ist quasi zu jeder Zahl sind die Eigenschaften beschrieben.

Es 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.

Ah ja, als Mathematiker hat man da keine Angst davor.

Hat auch wieder was mit Magie zu tun.

Worte der Weisheit.

Spezielle Art von Magie.

Genau.

Da wir die ganze Zeit von Magie reden, würde ich gerne meinen Pick tatsächlich nehmen.

Ja, oh.

Ich nehme doch tatsächlich noch einen Europäison-Talk, weil der liebe Rodrigo einen sehr schönen Talk gemacht hat über so Turtle, kennt ihr vielleicht, auch ganz magische Sachen macht.

Das kann Dinge auf die Leinwand malen, die sich drehen, spiralen.

Und dann kann man das erweitern, auch zu Fraktalen.

Und damit kann man animierte Fraktale für Live-Performances zum Beispiel schreiben.

Und zwar relativ einfach, indem man so einfache mathematische Prinzipien verwendet.

Und da war ein toller Talk zu und er hat auch einen schönen Blogpost dazu geschrieben.

Deswegen würde ich den gerne mal in die Show sinken.

Okay, okay.

Okay, gut, cool, spannend.

Ich habe heute zwei Picks dabei.

Der erste Pick ist ein Buch ähnlichen Ausmaßes wie Fluent Python.

Ich hatte nicht mehr in die Kamera für die anderen beiden.

Oh, okay.

Es ist tatsächlich

so, als es kam, es hat ein tatsächlich ähnliches Format.

Es heißt Django 5 by Example von Antonio Melee.

Und ich glaube, dass das ähnlich ist wie Fluent Python, nur halt

für Django.

Ach, ganz frisch mit Django 5.

Weil, also hier, ich habe es leider noch nicht durchgelesen.

Es ist, wie gesagt, auch dieses Buch hat 750 Seiten, ein bisschen weniger, aber trotzdem ein ähnliches Format.

Was ist das mit vielen Autoren von Programmierhandmüchern, warum müssen die immer so viel schreiben?

Und ich glaube, der Trick darin ist halt, dass es by Example ist und eben sehr viele einfach handfeste Projekte enthält, wo er sagt, hier, wir machen jetzt mal einen Blog und jetzt machen wir mal noch mehr Block und jetzt machen wir mal noch mehr Block und jetzt machen wir mal noch Social Website und Social Authentication und Content Sharing und Online-Shop und Tracking User Actions und Managing Payments and Orders und Extending Your Shop und Internationalisation und Caching und E-Learning

und Content Management und API und das ist, glaube ich, geht es so ein bisschen in die Richtung, wo auf Flurenpython 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 verendlich Zeit, deinen Dango-Webshop zu implementieren, von dem du schon die ganze Zeit träumst?

Mein Blog, ich werde jetzt endlich mal meinen Blog.

Ja, genau.

Modernisierungs Generators, das vergessen, 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, wieder Magie.

Der zweite Pick, den ich mitgebracht habe, ist eine Bibliothek, die heißt Dramatic.

Oder vielleicht heißt es auch Dramatic Q.

Und das kam auf in einer Diskussion über was kann man denn statt Celary verwenden.

Da gibt es jetzt zwar in Django was die Background Tasks, hatten wir ja vorhin auch schon kurz gemacht.

Denselben Mastodon-Social-Swert gelesen.

Ja, offenbar, ja.

Und ich habe mir aber die Links rausgeklickt.

Und einer, der mir ins Auge gestochen ist, war eben Dramatic, was auch so ein Queuing-System ist, was aber ein bisschen eine Pythonischere Syntax hat als Salary jetzt zum Beispiel.

Und das sah auf den ersten Blick sehr gut aus und ich freue mich darauf, das irgendwann mal einsetzen zu können.

Ja, stimmt, habe ich mir auch angeguckt.

Das fang tatsächlich nett.

Ich hatte nur keine Zeit, habe gedacht, wenn ich jetzt eh noch bis April warten darf, bis Dango 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, kannst du einfach installieren und dann verwenden.

Geht.

Ja.

Ja, warum eigentlich nicht?

Kann vielleicht noch zu wenig, aber ja.

Also, ja.

Also ist auf jeden Fall eine gute Idee, wenn man das noch nicht gemacht hat, einfach mal das auszuprobieren, weil dann muss man sich nichts mehr, muss man nichts mehr umstellen, wenn es dann irgendwann dazu gibt.

Ja, also es gibt so ein paar Module.

Wie heißt das Django Background Tasks tatsächlich?

Ich weiß nicht, dass du irgendwo.

Django Tasks heißt das bei mir.

Du hast glaube ich gerade Background Tasks gesagt, weil das ist ein völligstelliges Modul.

Und Dango Task ist tatsächlich gut im Vergleich dazu.

Und weil Dango Background Task gibt es auch und das wird man schwer wieder losgehen.

Ja, ich verlinke das dann, aber es ist genau, es ist.

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 entweder.

Ja, wie auch immer.

Also Dango Task ist, glaube ich, das, was wir

nehmen wollen.

Genau.

Ja, was, ähm, dann picke ich auch nochmal was.

Was ich jetzt, ich hab ein, ich weiß nicht, ist auch eher was Spezielleres, was jetzt gar nicht so viel mit Partner ist.

Die waren es einfach nur auf Shoppingtour.

Ja.

Aber ich finde es ganz interessant, weil ich habe ganz lange jetzt so Dinge verwendet wie, also ich habe auch schon mal, also ich mach mal so.

Du hast doch erst Geburtstagjochen, das ja.

Ja, ja.

Aber ich brauch's ja für was anderes.

Das ist, ähm, ich habe auch tatsächlich irgendwie mal vor mal nochmal wieder, also wenn ich es schaffe, irgendwie, ich wollte mal Videos machen, mehr wieder.

Und dann, da, da brauche ich dann natürlich auch entsprechendes Equipment für.

Da soll ich jetzt demnächst mal in meine Eurorex-Sammlung picken, wenn ich.

Ja, ja, mach das.

Ich finde das gut.

Ja, 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, wo 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 das hat geklappt.

Und jetzt geht das aber nicht mehr, weil die War-Files, die aus der Kamera rausfallen, die mag Apple Fotos nicht mehr.

Ja.

Und da gibt es aber dann vom Hersteller, von Nikon gibt es halt Nikon NX Studio und die kann das, äh, die Software kann dann halt tatsächlich das RAW-Format lesen und das Coole ist und das wusste ich gar nicht, dass das geht, das versteht das so gut, dass es halt irgendwie auch die Profile für alle möglichen Dinge aus der Kamera mit drin hat.

Das heißt, wenn du das halt jetzt in der Kamera schon so eingestellt hast, dann kriegst du das halt automatisch halt mit rein oder sowas bei anderen, bei Lightroom oder so eben nicht kriegst.

Und du kannst auch dann dir deine eigenen Profile zusammenstellen und die auf die Kamera speichern und dann kannst du halt Bilder machen, die genauso sind, wie du das halt wie dein Look halt aussehen soll und so.

Das heißt, du kannst ihn vorher vorprogrammieren

und so.

Ja, ja, also das ist wirklich, also man kann damit halt Dinge machen, die sonst nicht so richtig gehen.

Das fand ich ganz sett.

Und also viele Leute schwammen da auch von, dass es 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 es also man kann es halt nur so ein paar Minuten lang verwenden und dann verbraucht es.

Das klingt als halt zu noch ein neues Hobby.

Du hast ja gerade schon Computerspiele in Rust programmiert mit Wetto.

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, also nach einer halben Stunde sind die 22 Gigabyte weg und dann muss man es neu starten.

Was natürlich irgendwie echt totaler Quatsch ist.

Aber.

Hast du nicht genug Speicherdauer, musst du neu starten?

Nee, das passt halt all so.

Genau.

So, ja.

Ich bin nicht nur GPU-Pur, ich bin auch RAM-Pur, ja.

Wir haben nur 32 Gigabyte.

Ja, das ist schon ein ziemlich lächerlicher.

Ja, muss ich auch sagen, stimmt.

Ja.

Aber ja, genau, also da kann man nicht genug, kann man irgendwie mit dem RAM-Kaufen nicht hinterherkommen, wenn man halt Software hat, die einfach irgendwie das alles wegfrisst.

Einfach so, ohne Grund.

Jedenfalls, genau.

Also aber wenn man 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, was da alles so geht.

Ja.

Genau.

Tja.

Ja, vielleicht muss ich doch mal.

Das war jetzt aber schon ein sehr spezieller Pick, Jochen.

Ja, ja, war sehr speziell.

Nochmal, was wir bei Foxtort oder sowas machen, wenn wir hier die ganze Zeit nur so Mediensachen tun wie mit den Bildern.

Wir sind ja in so einem Medium-Dings hier auch, ne?

Ja.

So Musik, ja, die Musik, die ich mache, die finde ich meistens sowieso abartig, wie den Rest.

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 die Python von Leuten, die den Podcast hörten.

Ich meine, 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 vonnehmen.

Man kommt da gar nicht durch, man hört sie nie zu Ende.

Ja, da müssen wir mal ein bisschen.

Also alles, was wir an weiterer Kritik, Anregung, Fragen und so weiter, hallo at 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.

Das war eine.

Ich komme jedes Mal gerne vorbei, wenn ich da bin.

Ja, wir freuen uns wieder drauf.

Ja, danke, Jochen, und hört uns bald wieder.

Bis dahin.

Tschüss.

Ciao, ciao.