Transkript: Python 3.10

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

Ja, schön, dass ihr wieder eingestellt habt.

Wir waren etwas länger nicht da.

Das tut uns etwas leid.

War ziemlich viel zu tun.

Und ja, Ferien, Fieber und so weiter, weißt du nicht alles kennt.

Ja.

Der alte Wahnsinn.

Genau.

Ja, herzlich willkommen, Dominik, auch zurück.

Bist du sicher, dass das Folge 35 ist?

Ja, das ist ein bisschen.

Wir haben das irgendwie ein bisschen Track verloren.

Das ist übrigens Jochen, ihr kennt ihn auch.

Ja, genau, vielleicht sagen wir das nächste Mal einfach herzlich willkommen ohne Episode.

Das ist ja auch sowas.

Das hat Apple Podcasts, iTunes hat ja so Richtlinien, wie man das, und die haben irgendwann mal gesagt, sie hätten gern die Episoden Nummern nicht mehr im Titel.

Das hat man früher immer so gemacht, ich habe das auch so gemacht und dann habe ich das rausgenommen.

Ich weiß nicht, am Anfang sind die, glaube ich, noch mit dabei und irgendwann habe ich es halt.

Nee, letztens hatte ich jedenfalls 34, dann 33, jetzt haben wir 35 und wir haben eigentlich noch einige unveröffentlicht, das heißt das ist auch nicht ganz so einfach an unseren Files das zu sehen.

Aber ja, schön, dass ihr wieder da seid.

Wir machen heute eine Mix-Folge, also ein bisschen über Python wollen wir jetzt 10.30en und so und

dazu sagen.

Das ist genau.

Genau, und vielleicht noch über die alten Neuerungen, die es so gab.

Und dann wollten wir noch ein bisschen über Shared Memory von Python in Prozessen sprechen, vielleicht.

Ja, je nachdem, wie viel uns das einfällt.

Sonst so Dinge, so andere Dinge auch.

Dinge, wir müssen noch nicht so genau.

Mal schauen.

Ja, wir müssen das mal wieder strukturierte Form kriegen, aber haben wir bisher noch nicht hinbekommen.

Ja, genau.

Ja, bevor wir es mit Python 13 anfangen, was haltet ihr eigentlich von Werbung?

Wir fangen das eigentlich rund.

Ob wir es so mit Helge Schneider halten sollen, so Werbung ist scheiße.

Oder ist das für euch ein No-Go?

Es wäre cool, wenn ihr jetzt so ein bisschen Feedback gibt, ob das für euch in Ordnung wäre oder nicht.

Wir haben uns aus einigen technischen Perspektiven gefragt, ob das Sinn macht oder das mal auszuprobieren.

Wir sind aber eigentlich noch nicht so wirklich selber da.

Ja, wäre es natürlich praktisch, wenn es irgendwie die ganzen Kosten, die da so ein bisschen, also so wahnsinnig hohe Kosten sind es jetzt nicht, aber wenn die auch ein bisschen.

Ich kaufe wieder ein Schlossjochen.

Wann das wieder reinkrücken könnte oder so, keine Ahnung.

Muss man mal schauen.

Ja, das ist auch so ein Thema, genau.

Ja, ich warte nur drauf, dass ich wegen dem Podcast in ein Schloss ziehen kann.

Ich glaube, da wirst du noch ein bisschen warten müssen.

Das wird noch etwas dauern.

Ich habe Zeit.

Ja.

Lebensverlängern Maßnahmen.

Ja, genau.

Wollen wir so ein bisschen News machen?

Dann könnten wir mal wieder.

News, ja.

Ja, also genau.

Am Montag kam Python 13.0 heraus.

Ja.

Also letzten Monate am 4.10.

Voll gut, genau.

Und dazu gab es auch so einen Release-Stream irgendwie, fand ich auch nicht.

Was?

Oh, irgendwie richtig gesehen, nein.

Ah, ja.

Genau, kann man sich auf YouTube nochmal angucken.

Also ehrlich gesagt, ich weiß nicht, ob ich den sich wirklich komplett angucken will.

Das ist irgendwie so über drei Stunden.

Aber man kann ja mal reingucken, einfach um die Leute zu sehen, die das machen.

Das ist vielleicht ganz interessant.

Und die hatten auch lustige Hüter auf, das ist auch super.

Oh, cool.

Genau.

Ja, und das war auch ganz witzig.

Ja, es war eine komplizierte Geschichte, so ein Release.

Und ja.

Genau, ich habe jetzt auch schon so ein bisschen, ich weiß nicht, hast du das schon mal versucht, irgendwo zu installieren oder mit was?

Ja, ich benutze es schon relativ lange, jetzt fast zwei Monate, so den Rescandidat, der so dann draußen kam.

Ah, okay.

Hab ich auch schon an Daily benutzt und hab so ein bisschen gemerkt, was da ging, was nicht ging.

Direktor, also ich muss den ja meistens oder oft unter Windows benutzen, leider.

Aber ja, da gibt es halt ein großes Problem mit PyWin 32.

Das kann man aber relativ einfach fix mehr, wenn man weiß, wie es geht, aber das erzähle ich vielleicht einfach später.

Ja, okay.

Genau.

Ich habe es eigentlich, ich habe es vielleicht auch mal, ich habe auch mal eine Beta oder eine Release-Kandidate, weiß ich nicht, mal installiert, um mal so ein bisschen zu gucken.

Oder ich glaube, letztes Mal, wir hatten irgendwann mal, haben wir uns über das Structural Pattern Matching auch schon mal unterhalten, das ist schon eine ganze Weile her.

Ich glaube, das habe ich auch mal kurz ausprobiert oder so.

Aber ansonsten habe ich das noch nicht verwendet.

Und jetzt aber doch dann mal installiert auch.

Ich habe jetzt versucht, das Projekt, an dem ich gerade.

Ja, also das sind ja so die Hauptfeatures, ne?

Also das Flash-Patch-Matching und die Typing-Syntax so ein bisschen angepasst und so.

Na gut, also es ist die Frage, wie man sieht.

Also ich glaube, so das, was unten, also so ein bisschen, die sind aus ein bisschen kontrovers.

Aber klar, ich kann schon verstehen, warum man die als das, das sind die wichtigsten neuen Features klassifizieren würde.

Ich glaube, das positivste Feedback hat, die haben die verbesserten Fehlermeldungen bekommen.

Ja, die sind tatsächlich.

Das ist tatsächlich super, ne?

Die werden sogar mit 3.11 noch ein bisschen schöner.

Ja, ja, ja.

Und dass man tatsächlich nicht nur irgendeinen Quatsch bekommt, sondern tatsächlich die Stelle, an der es steht und warum vielleicht auch ein Hinweis, warum es falsch sein könnte und was da falsch ist, das wird direkt gut beschrieben.

Genau, genau.

Also bisher ist es halt, wenn man da irgendeine Klammer vergessen hat zuzumachen oder so, dann kriegt man halt einen Syntax-Error beim nächsten Statement irgendwie beim Gleichheitszeichen oder irgendwie sowas.

Und das ist halt dann irgendwie verwirrend, weil man kriegt halt den Fehler angezeigt, nicht an der Stelle, wo man den erwartet, wo er passiert ist, sondern naja, wo der Interpreter dann halt drüber fällt.

Aber genau, und jetzt ist es halt besser jetzt.

Und das ist halt auch alles konsequent.

Er unterkringelt jetzt richtig die Stelle, an der es ist mit Numbers und so für ein Steebikes.

Von dem Pack-Parser, der jetzt dann neu ist und mit dem kann man einfach mehr Sachen machen, dann ja.

Weiteres Feature, was halt dieser dem neuen Parser sozusagen zuständig ist, ist das jetzt in, das ist auch eher so eine Randhässlichkeit, aber das ist halt schon komisch, wenn man diese Limitierungen irgendwie, wenn man auf die gestoßen ist, dass in Kontextmanager, also wenn man sagt, with irgendwie Kontextmanager as irgendwas, äh, da konnte man vorher nicht das so klammern.

Also dass man das über mehrere Zeilen, das musste in einer Zeile sein.

Und man konnte auch, glaube ich, nicht mehrere, sondern musste das dann mehrfach verschachteln.

Was dann natürlich, also wenn auf dieses Problem gestoßen ist, man hat jetzt mehrere Kontextmanager und dann irgendwann kommt man in große Nöte, weil wenn man nicht, wenn man immer weiter verschachteln muss, wenn man jetzt mehrere davon hat, dann wird das halt, wird der Platz auf der rechten Seite eng.

Und wenn man die aber nicht umbrechen kann, weil diese Klammerndotation noch nicht funktioniert, dann hat man irgendwann so Probleme.

Denkt sich so, das geht ja jetzt gar nicht mehr so richtig.

Hässlich wird das wirklich.

Das wird dann sehr hässlich.

Und das geht jetzt.

Kontextmanager mit Parenthesen.

Mit Klammern, sodass man mehrere Zeilen verwenden kann und halt auch mehrere in einem Dings, sodass man das halt quasi, wenn man viele Kontextmanager benutzen möchte, das kann man jetzt einfach in eine Zeile schreiben, beziehungsweise halt untereinander mehr machen.

Da sind wahrscheinlich nicht so viele Leute drauf geschossen auf das Problem.

Aber ja, genau.

Ja, ich mache auch das schon Sinn.

Also wenn man das schachteln will, könnte ja erst auch anders lösen, indem man Dekoratoren verwendet oder so, aber.

Naja, aber ich meine, du dafür gibt es die Syntax, ja, dass man das halt verwendet.

Und ja, wenn man das dann nicht so richtig verwenden kann, ist es halt ein bisschen blöd.

Ich meine, das kommt halt nicht so auf.

Meistens hat man ja nur so ein, zwei Dinger, die man machen möchte.

Also ich, also in diese Verschachtelung oder dass es blöd wurde, ist mir dann, die einzigen Male, wo mir das mal passiert, ist, das irgendwie, ist halt, wenn man, wenn ich in Tests mehrere Sachen, also wenn ich da mehrere Sachen wegmocken will oder wegpatchen will.

Und teilweise kann man das halt, also kann man ja auch einen Dekorator machen, manchmal geht das auch nicht, weil das basiert halt auf anderen Sachen.

Und dann muss man das halt in einem Test selber machen.

Und dann, wenn man viele Sachen hat, die man wegmocken möchte, dann wird es halt komisch.

Und das ist aber die einzige Stelle, wo das praktisch jemals irgendwie begegnet ist.

Ansonsten.

Na gut.

Also was ich sehr gerne benutze, ist diese neue Typing-Syntax, wo man jetzt halt, ich weiß gar nicht, wie heißt das Zeichen überhaupt, dieser senkrechte.

Pipe Strich,

die Pipe.

Pipe-Operator, ja.

Genau.

Den kann man halt jetzt verwenden als Type-Ind zwischen einem Oder-Teichen einfach sagen.

Heißt das ein Dikt- oder eine List, der erwartet jetzt diese Funktion, dann gibt es sie raus, dann macht man einfach Pipe dazwischen.

Das ist irgendwie sehr intuitiv und man muss nicht immer alles vom Typing direkt importieren und einen Union draus machen.

Ja, sieht auf jeden Fall deutlich besser aus.

Stimmt.

Genau, ja, das ist schön.

Ich finde bei dieser Type-In-Syntax immer so, ich habe mich ehrlich gesagt auch noch nie so richtig, wirklich viel damit beschäftigt, muss ich sagen.

Würde ich auch nochmal irgendwann machen, aber ich habe es bisher nie so benutzt.

Aber ich finde das immer ein bisschen verwirrend von der ich weiß nie so genau, was sind jetzt die aktuelle Form von Syntax, die man da verwenden kann und bis welcher Pythonversion zurückgeht das denn und so.

Aber ja, also so sieht es auf jeden Fall schon mal viel besser aus.

Sieht sowieso schon mal viel besser aus, dass man nicht die ganzen Typen von irgendwie aus Typing importieren muss, sondern dass man halt direkt die echten Verwaltung.

Also es funktioniert halt leider noch nicht immer so komplett, je nachdem, wie komplex und wie vollständig man das irgendwie so machen will.

Aber ja, das ist schon mal auf jeden Fall ein Tritt in die richtige, in die richtige Richtung und sieht auch gut aus.

Was mich halt noch so ein bisschen nervt, ist also dann, wenn du zirkuläre Abhängigkeiten hast oder sowas.

Das passiert halt bei Typing relativ schnell.

Und das ist auch nicht so richtig gelöst.

Es gibt ja irgendwie so zwei Dinge, die man machen kann, dass man von Typing irgendwie das einmal importiert und dann nur dann, wenn Typing Type-Checking ist, dann die nutzt.

Das geht auch nicht immer.

Manchmal kann man es dann als String dann doch hinschreiben.

Man hat man einige Types, die als Klassen definiert sind, einige als Strings, das ist auch irgendwie hässlich.

Und naja.

Da wollen sie aber irgendwie dran arbeiten.

Habe ich gut, aber ich weiß noch nicht genau, wann das eingeführt wird.

Dass man das halt einfach dann machen kann, dass er halt erkennt, dass es ein Type ist und es halt dann tatsächlich lazy importiert oder so und das dann halt kein Problem ist beim Komponieren.

Okay.

Auch interessant, ja.

Ja.

Also das heißt, dass auch das wird noch besser.

Also, das heißt, wir bekommen insgesamt im Moment so ein bisschen hübschere, ästhetischere Sachen für so Errors und Syntax und so.

Ja.

Je nachdem, ob man Type Hints überhaupt mag.

Genau, deswegen, also ich meine, ich würde sagen, eben, das ist halt durchaus durchaus kontroverse Geschichten, weil es gibt halt auch viele Leute, die finden das gar nicht gut.

Ja, nicht per Sonic, ursprünglich, da gab es halt nie.

Und ja, ich kann so ein bisschen nachvollziehen auf der anderen Seite.

Also ich glaube, ja, man muss es halt an, man muss es halt dafür einsetzen, wo es halt Sinn macht.

Ja, genau.

Also es ist, was ich auch komisch finde, ist, wenn Leute das dann überall verwenden, weil es macht halt nicht überall Sinn.

Also ich habe auch das Gefühl, dass zum Beispiel, wenn ich, also gerade an den Sachen, an denen ich schreibe, wenn das halt so, das ist halt ein Projekt, was halt andere Bibliotheken verwendet, aber selber keine Bibliothek, an der Stelle macht es nicht so wahnsinnig viel Sinn, weil ich, also ist es schön, wenn ich in einer Idee sozusagen die Ergänzung, also sozusagen, eine Idee, der es verwenden kann, um mir zu helfen, aber wenn ich sowieso, wenn das die Libraries, die ich verwende, tun, und brauche ich das, also sozusagen für meinen eigenen Code, den ich qu

asi nie aufrufe, brauche ich das ja gar nicht so.

Oder der halt nur verwendet wird, um halt irgendwas zu tun.

Das ist halt irgendwie da.

An der Stelle brauche ich es, wüsste ich jetzt nicht, ob ich es wirklich brauche.

Also ich mache wahrscheinlich auch im Moment zu viel hin, also weil ich es gerade irgendwie ein bisschen noch reine als weniger.

Aber ich finde das halt schon sehr praktisch, wenn ich halt wirklich das Objekt quasi schon so getyptet habe, dass ich halt weiß, was für ein Objekt ich da in der Funktion in der Hand habe, weil das so getypt ist oder auch bei der Variablenzuweisung, dass halt schon relativ klar ist, was das halt mal sein wird.

Oder so.

Weil dann relativ, also auch manchmal kann man halt so eine Base-Klasse nehmen, dann weiß man halt, was hat man denn da in der Hand.

Und das ist irgendwie, also A, natürlich vor dem Editor, der das halt super dann linden kann und dann halt auch die Types dann feststellt, auch.

Wenn das halt irgendwie nicht stimmt, das kann er halt relativ gut feststellen, irgendwie.

Die meisten modernen können das ja.

Ja.

Und das ist irgendwie schon echt hilfreich.

Also gerade wenn ich jetzt irgendwie mit anderen Leuten irgendwie gleichzeitig irgendwie an Features entwickle und jeder irgendwie so einen kleinen Type out und was meinst du der denn da, wenn die Leute nicht immer so gut nehmen oder so manchmal, dann sieht man das halt auf jeden Fall am Type auch schon, was das dann halt sein könnte.

Und das, also für mich macht es das so deutlich verständlicher.

Also ja, man kann es wahrscheinlich auch too much machen an zwei Stellen, aber ja, also ich finde halt das Linting, das ist schon, ist mir so oft aufgefallen, dass irgendwo, wenn man dann mal die Type-ins dann reingebaut hat in so einen Code, der irgendwas war komisch von Coworker oder sowas, dann merkt man so, oh ja, klar, wird direkt gelintet, da ist der Typ irgendwann kaputt gegangen und er gibt halt dann doch nicht das zurück, was er erwartet hat und vielleicht ist irgendwo doch ein Nun rausgefallen oder sonst irgendwas.

Und solche Sachen, die sieht man halt durch die Type-Pins einfach deutlich schneller und deutlich häufiger.

Ich meine, klar, wenn man sowieso einen so super Coder und Programmierer ist wie du, lieber Jochner, ich würde sagen, dass das echt, also mir hilft recht, also ja, vielleicht nicht überall, aber.

Ja, ich glaube, ich muss einfach mehr damit mal rumspielen.

Ja, was interessant ist, es gibt halt auch so immer ja, also gerade diesen ganzen Typing, das Ding, also alles auf so Interfaces aufzubauen, ja, dass du halt so irgendwie so Datenklassen baust, wo halt relativ klar ist, was für Attribute das mit welchen Datentypen sind.

Ja, ja, ich meine, das habe ich auch schon.

Also Pydentic finde ich auch total super.

Pydentic macht das natürlich auch.

Also genau, was ich total, also gerade mit FastAPI zusammen, was ich total super finde, ist, dass man da halt einfach dann Objekte auch in serialisierter Form halt einfach hin und her schicken kann.

Das ist total super mit FastAPI, weil FastApi kannst du einfach dann quasi von einem anderen Modell erben und lässt dann beispielsweise für deinen Datenbankmodell ein paar Spalten weg oder sowas und kannst es halt einfach dann als Modell einmal definieren und kannst das als Response-Modell ausgeben und das ist alles dann mit drin.

Das ist schon sehr nice.

Genau, und das funktioniert einfach alles so magisch.

Das ist schon sehr nett.

Fast Api kennst du das SQL-Modell?

Ja, ja, ja,

das ist auch von Sebastian Ramirez.

Und da macht er quasi einen Rapper noch um Pydentic und SQL-Ilchemy rum und baut das alles zusammen in eine Klasse rein, dass man halt nicht mehr so viel Duplicated Code hat und gleichzeitig irgendwie SQL-Ilchemy-Modelle und Pydenti-Scheme nachschreiben muss.

Ja, ja, das ist eine Frage, die ich mir, ich habe irgendwann, ich weiß nicht, wann ich, weißt du auch schon über ein Jahr her, als ich zum ersten Mal angefangen habe, so ein bisschen mit FastAPI rumzuspielen, dann darf ich so, okay, SQL-Alchemy, schon ein schöner ORM, aber das, was halt doof ist, ist halt, dass man die Modelle immer doppelt definieren muss, einmal als SQL-Alchemy-Modell und dann halt nochmal als Pydentic-Modell, damit man es raus- und ausrendern kann, sozusagen.

Und mit dem neuen TKM und sagst du einfach Table gleich True.

Und das ist wirklich echt angenehm.

Ja, und da dachte ich schon, das ist aber blöd, dass man das selber machen muss und ja, das ist jetzt weg und das würde ich auch gerne mal ausprobieren.

Ich habe es bisher noch nicht hingekriegt, aber ich glaube, das mache ich demnächst mal.

Ja, das ist sehr geil.

Weil ich glaube, ich fange jetzt, ich nehme mir nochmal dieses Deployment-Dings, was ich mal auch das, wann habe ich das gebastelt?

Das war auch ungefähr letztes Jahr um die Zeit ein bisschen später nochmal vor und dann mache ich das nochmal mit FastAPI, Vue.js und vielleicht mal mit SQL Model.

Ja, ja.

Ja, also was mir noch so ein bisschen fehlt, ist das letzte so ein paar von den SQL Alchemy-Features, sowas wie Unique-Constrained oder so, habe ich aber vielleicht auch noch nicht rausgefunden, wie es gut geht.

Ich glaube, man kann das so mit Secret Alchemy extra Quarks machen oder so, aber ja,

keine Ahnung.

Das funktioniert noch nicht so ganz einwandfrei, aber da fehlt auch noch so ein bisschen Dokumentation.

Das ist ja noch gerade relativ frisch.

Ja, ja, ja, das gibt es ja gerade erst neu.

Genau.

Und ja, also Migrations dazu kann man natürlich auch schön machen.

Ja.

Einfach mit, wie machen wir das?

Mit Almbi, glaube ich.

Die heißen da, äh, wie heißt das?

Nicht Migrations, sondern Revisions, Revisionen oder so.

Und das Coole ist, wenn man dann quasi sein Management macht mit Typer, auch von Sebastian, dann hat man quasi auch seine Management-Commands direkt da mit drin, was das irgendwie alles ist.

Ja, das verwende ich ja auch schon lang.

Das werde ich jetzt auch seit über anderthalb Jahren schon.

Ja, das verwende ich sogar auch mit Django, aber.

Ja, verwende ich auch in Django, genau.

Ich finde, verwende das dann meistens mit Poetry zusammen.

Genau.

Und dann gibt es halt, da kann man Skripts definieren und dann sind die halt, ich meine, ich weiß noch nicht, ob das so hübsch ist, so ein Commands-PY habe ich die dann, das ist eine Funktion, die.

Also ich finde das auch so.

Also vor allen Dingen, du kannst das halt hinterher dann sogar in einem Notebook importieren, ja, und kannst halt dann bestimmte Sachen einzeln ausführen in deinem Notebook.

Das heißt, du kannst die Management-Command sowohl auf der Kommandoteile als auch in deinem Notebook einfach laden und benutzen.

Und das ist halt dann schon auch sehr cool, weil dann kannst du einfach mal on the flying User erstellen und das User-Create-Command hast du dann halt in den Commands zum Beispiel drin.

Das gibt es ja zum Beispiel bei Dunkel natürlich mit inbound, aber das ist bei Fastup hier ein bisschen anders.

Das ist schon cool.

Ja, aber da hätte ich auch noch gleich mehr Fragen zu, weil da hatte ich ein Problem, das würde ich gerne mit dir besprechen.

Da ging es halt genau über diese Shared Memory-Sache.

Aber vielleicht machen wir nochmal mit Python 13 weiter.

Genau, ich weiß nicht, wollen wir das schon inhaltlich nochmal structural.

Ich habe gar nichts, ich meine, wir haben das ja schon mal besprochen, ich weiß gar nicht, ob man da jetzt nochmal was dazu sagen muss.

Also man kann halt jetzt halt jetzt ein Match-Statement und dann kann man da halt irgendwie so Sachen auspacken und dann gucken, ob das darauf matcht und dann führt man halt dann also so ein bisschen wie ein Case-Statement auf Koks.

Speed.

Ich weiß nicht.

Genau, und man kann da auch noch so Guards setzen davor.

Das heißt, das fällt dann halt da so durch und dann kann man halt da noch ein If hinterschreiben und dann, je nachdem, ob die Bedingung erfüllt ist oder nicht, dann matcht es da halt rein oder halt.

Jetzt muss ich kurz sagen, was ist ein Guard?

Genau, also wenn man jetzt sagen kann, wenn man sagt, wenn man jetzt die Bedingungen hat, sozusagen, und man möchte aber zusätzlich noch irgendwie, und dann sagt man noch, wenn irgendeine andere Bedingung erfüllt ist, dann kann man hinterher hinten dran an den Ausdruck einfach schreiben, if irgendwas x gleich y oder so und dann läuft es da rein und dann, wenn das nicht so ist, dann läuft es halt weiter in den Default-File zum Beispiel.

Oder halt.

Okay, das ist der Gart.

Genau.

Das ist halt auch nett, weil, ja, also ist es, ich habe noch nicht wirklich tolle Anwendungsfälle dafür, ehrlich gesagt.

Das ist halt so ein

bisschen zum Filtern von so Dingen, ne?

Das war irgendwie mit If ist halt irgendwie sehr verschachtelt, da muss man tausendmal so redundanten Code schreiben und mit diesem Match Case, da kann man relativ schön gucken, was denn da übergeben wurde.

So ein Command-Parser zum Beispiel kann man sehr schön mit Match Case, glaube ich, abbilden

oder so.

Ja, vielleicht, wenn man irgendwelche Dinge parst.

Das könnte man wahrscheinlich deutlich einfacher hinkriegen.

Oder was ich mir auch vorstellen kann, ist das, wenn man halt so.

Du hast zum Beispiel so einen generischen Endpunkt für irgendwas, da kommt irgendwas rein.

Ja, aber das weiß ich nicht, ob das so eine gute Idee ist, das zu haben.

Ja, du kannst zum Beispiel sagen, nur dann, wenn es ein bestimmtes Format hat, dann mache ich aber was mit, ansonsten schmeißt du einfach weg.

Ja, genau, also das Einzige, wo ich praktische Dinge gesehen habe, also aber ich bin, ich meine, das kommt natürlich, also man muss jetzt müsste wahrscheinlich mal so in die Elixierwelt gucken oder so, da wird das ja irgendwie, ist das halt häufig eine Geschichte, die man da verwendet.

Vielleicht gibt es da irgendwie ganz tolle Anwendungsfälle für.

Da geht es häufig von Elixier, ich sehe immer das Buch in der EX-Kinse.

Ja, ja, ich bin immer noch nicht so wirklich weitergekommen.

Ja, ich dachte, manchmal muss man es halt nicht nur rumliegen haben, sondern auch mal reingucken.

In einem Kopfkissen hilft am besten.

Ja, genau.

Oder halt irgendwie eine andere Sprache, die das halt kann, aber.

Ich lege mir auch mal ganz viel Gold in das Kopfkissen, das laufen kann, ja.

Ja.

Aber irgendwie, ähm, genau, weil sich jetzt bei den Python, also der einzige Fall, wo ich das Gefühl habe, da ist etwas, das ist so ähnlich, und ist halt, wenn man jetzt in JavaScript im Frontend, da gibt es halt zum Beispiel React, so Redux oder so, so Eventsysteme hat.

Und da hat man halt häufig auch so Dinger, die diese Struktur haben, dass man halt ein Case-Statement hat und dann wird das halt, je nachdem, was da passiert ist, man hat halt irgendwie ein Event, was da reinfällt und dann splittet man das halt auf und ruft dann entsprechend Funktionen auf oder updatet irgendwelchen State oder macht halt irgendwas.

Und ein Kern von diesen Stores ist halt häufig ein großes Case-Statement irgendwie.

Und das könnte man dann halt, in Python könnte man das dann auch so machen und halt eleganter mit dem Structural-Pattern-Matching.

Das wäre jetzt so eine Anwendung, die mir einfallen würde, aber ansonsten pfff.

Ja, du musst ja natürlich jetzt alle If-Statements durch Match-Case ersetzen, erstmal um zu testen.

Das Problem ist halt auch, also wirklich so einfach nur so verwenden ist halt auch, weil man hat ja oft das Problem, dass man einen Code hat, der auch noch auf älteren Python-Versionen laufen soll.

Und dann man kann das ja nicht einfach so, also man kann das in irgendeinem Projekt verwenden, das komplett neu ist oder so, weil das man Kontrolle hat, aber wenn das irgendwo, wenn jetzt zum Beispiel eine Library schreibt, dann kann man das nicht gut verwenden, weil dann müsste man ja sagen, geht erst ab 1.10 und.

Boah, das ist

dann halt Pech.

Ja, gut, aber auch ein Ding, was ich daran so ein bisschen blöd finde, ist, wenn man das momentan irgendwo reinschreibt und lässt dann Black drüber laufen, dann geht das nicht.

Black mag das nicht.

Nicht bei 3.10, Black.

Nein.

Nein, mit Black geht das noch nicht.

Das heißt, Autoformat funktioniert nicht mehr, wenn man.

Das kann ja gar nicht sein.

Wenn man diese Drehwege.

Ja, das muss doch schon gefegt sein, da muss da schon ein Pull-Request irgendwo zugeben.

Ja, ja, das kommt bestimmt dann irgendwann, aber momentan geht es halt auch nicht.

Okay, muss ich mir mal anschauen.

Auch, auch, ah, das habe ich jetzt, war das Python Bytes-Podcast, ich weiß nicht genau, ob ich das gehört habe.

Es gibt einen, äh, fand ich auch schön, weil man hatte ja immer so das Problem, wenn man Sachen kurz Basen umstellt auf Black, dass das dann halt so riesige Pull, also so riesige Dips erzeugt.

Und das ist halt irgendwie Kacke, weil man dann halt nicht mehr sehen kann, wann irgendwas passiert ist, weil man landet immer bei diesem riesen Änderungsding.

Da gibt es ein Projekt, das nennt sich, glaube ich, Darker.

Darka.

Und das macht es quasi Black, aber immer nur für die Änderungen, die man.

Also wenn man Code ändert, dann macht es sozusagen das gleiche wie Black, aber nur auf dem Div.

So dass es halt immer so dunkler wird mit der Zeit.

Aber das heißt, es ändert nur Sachen, die man eh angefasst hat, und das ist eigentlich auch eine nette Idee, eigentlich eine völlig offensichtliche Idee.

Aber ja.

Ja, okay.

Ja, finde ich ganz faszinierend.

Genau.

Ja, Structural Pattern Matching, was haben wir denn noch?

Ja, also die Industils sind deprecated.

Ja.

Oh, das ist mir auch.

Und genau, Industils sind deprecated.

Da ist auch ein Ding drin, das mir auf den Fuß gefallen ist.

Also ich versucht habe, die Sachen dann, die ich so mache, mal zu gucken, ob das unter 13 auch läuft.

Und da gibt es eine Abhängigkeit, die hat Wagtail.

Ja, aber.

Ach, das schöne Wagtail, ja, das liebe ich auch so sehr.

Das hängt ab von L18N, da heißt das irgendwie, das Paket und das ist halt irgendwie so ein.

Ich dachte, das wäre ein I.

Ja, nee, das macht so leicht was an.

Ich weiß es genau macht, weiß ich gar nicht.

Aber das ist halt auch so ein Ding, das ist halt irgendwie, also zwei Stars auf GitHub irgendwie von irgendjemandem.

Und davon hängt Wagtail hängt davon ab.

Und da das Ding verwendet im Setup-PY-Skript, irgendwo ein B-Dist Win-Inst oder sowas.

Und das ist in Python 3.8 deprecated worden und in 3.10 ist es rausgeflogen.

Okay.

Und deswegen baut es nicht mehr.

Das heißt, man kann unter 3.10, Python 1.10, Wagtail nicht mehr installieren.

Was halt so ein bisschen Kacke ist.

Und ja, das ist halt ja, ich habe da mal einen Pull-Request gemacht, mal gucken, aber das ist halt ja schon ein bisschen, vielleicht ist diese Abhängigkeit nicht so toll.

Ja, also da, wo wir gerade so blöden Abhängigkeiten sind mit Python 13 kaputt gehen, möchte ich jetzt nochmal auf das Python 32-Problem gehen, weil Python 32 ist unter Windows relativ wichtig, weil das halt relativ oft gebaut wird für bestimmte Sachen, um die zum Laufen zu lassen.

Das heißt, ohne Python 32 gibt viel von Python Wheels bauen nicht.

Und das heißt, du kannst fast nicht benutzen, was halt sehr blöd ist.

Und die Abhängigkeit, die viele Projekte haben, ist sowas wie Python 32301.

Das gibt es aber jetzt im Moment nicht für 3.10 und auch nicht für 3.8.

Keiner weiß warum, die Wheels werden irgendwie nicht richtig bei Python ausgeliefert.

Ich glaube, der Maintainer ist auch so ein bisschen, ich sag mal vorsichtig, sperrig, was das angeht.

Ja, und das ist halt blöd, weil du kannst halt das dann keine Projekte mehr installieren oder Poetry geht nicht mehr oder so.

Und das ist halt extrem ätzend für Leute, die über Windows entwickeln.

Und was man aber machen kann, also ich habe einen kleinen Workaround gefunden, man installiert einfach Python 32301.1.

Also auch irgendwie komische Varianten.

Die Versionen gehen von 2 irgendwas rauf, weil 200 auf 301.

Dann kommt dann 301.1.

Warum?

Na gut, vielleicht ist so irgendwann zu manche Versioning reingeflogen, ich weiß es nicht.

Es ist auf jeden Fall seltsam.

Und naja, man kann dieses 301 manuell installieren und dann, ähm, es ist ein bisschen hacky, einfach in das Side-Packages-Verzeichnis gehen und im Manifest die Version von 301.1 auf 301 ändern.

Und dann denkt tatsächlich unter dem Foldernamen umbenennen auf von 301.1 auf 301 und dann denkt tatsächlich, ja, Pip, dass das vernünftig installiert ist und fragt nicht mehr.

Und es funktioniert alles.

Und so kommt man halt drumherum.

Aber das ist halt schon sehr, sehr hässlich.

Und es gibt auch da wohl ein paar Pull-Requests, aber anders gehen bestimmte Sachen da leider nicht zu fixen.

So, das ist ein bisschen blöd.

Okay, ja.

Ja, ja, also da sind.

Wenn es so ein wichtiges Paket gibt, was dann so Maintaining auf einmal nicht mehr stattfindet und so, das ist schon anstrengend.

Ja, das ist schon fies.

Also mir ist auch wieder, jetzt bei dem Upgrade, also einmal im Jahr fällt einem das dann auf.

Mindestens, wenn es halt eine neue Python-Version gibt.

Aber bei den Minor Versions, Updates von Python fällt es mir auch häufiger auf, dass es halt alles noch echt ziemlich wild ist, weil, also auch Poetry hat da so Schwierigkeiten.

Das Lustige ist halt, wenn man Rectail per Pip installiert, dann funktioniert es immer nicht.

Mir ist es halt auf die Füße gefallen, weil ich es per Poetry installiert habe.

Und Poetry macht halt was anderes als Pip.

Ja, es taggt auch noch die Side-Denancies

und so.

Und ja, aber und das macht halt, und es guckt sich halt dann teilweise die Setup-UI an und so.

Ja.

Und das ist halt nicht so gut unter Umständen.

Wenn Pip, wenn dann ein Real ist, dann installiert es halt stumpf das Real, das funktioniert dann.

Wenn man halt nicht auf Windows ist.

Und ja, Poetry macht das halt nicht und dann geht es halt schief, weil dann irgendein Import nicht mehr funktioniert oder so.

Und Poetry macht sowieso komische Sachen teilweise.

Im Moment, ich bin auch so ein bisschen, also die Werden 1.2, habe ich gesehen, ist gar nicht so schlecht.

Die haben einfach umbestellt, dass Installation.

Das heißt, ich muss auch in den Docker-File so bei von GetPoetry auf Inside-Pooletry umstellen und so.

Und dann funktioniert es aber auch noch nicht so richtig überall.

Und dann das Update auf 1.2.

Also es gibt ja so ein Safe-Update mit der neuesten Version, da kann man jetzt halt Safe-Update machen, muss nicht mehr irgendwie jedes Mal neu das vom GitHub versuchen.

Das funktioniert

schon mal ganz gut auch, ja.

Ja, aber das funktioniert halt dann noch nicht so richtig.

Und dann, dass die Piv-Version, die schützen wir und nicht ausprobiert, einfach ab und so.

Und naja.

Ja, ja, also ich muss sagen, also das, also Poetry ärgert mich in letzter Zeit auch irgendwie.

Ich verstehe gar nicht warum.

Zwischendurch lief es wirklich gut.

Einwandfrei, irgendwer hat er irgendwas, kaputt gecodet.

Ja, ich weiß es nicht so genau, aber es ist, also ich meine, ich bin ja bereit anzuerkennen, dass das halt auch nicht so ein ganz einfaches Problem ist.

Aber irgendwie läuft es nicht rund und jetzt auch nach dem Update, also natürlich, so die üblichen Kandidaten, das funktioniert alles wieder nicht.

Also, also ich glaube auch Poetry hatte mit 3.10 auch Probleme irgendwie.

Da ist auch irgendwas, hat er nicht so richtig funktioniert.

Aber halt Numpai und so, das funktioniert natürlich auch nicht.

Und ich meine, gut kann man verstehen, es dauert ein bisschen, bis da die Wheels und die Binaries da sind, aber ja, also richtig rund ist das alles irgendwie nicht.

Ich warte am meisten bei wichtigeren Sachen auf 3-1, 2-3-2 oder sowas.

Ja, aber ich meine.

Vielleicht sollte man tatsächlich hingehen und das einfach vorher schon mal ausprobieren und dann gucken, wo es kracht und dann da halt versuchen, so ein bisschen zu helfen.

Ich meine, das ist wahrscheinlich irgendwie hilfreicher, als wenn man nur Mac hat, aber.

Ja, eigentlich schon.

Ja, ich habe mit dem Pivon.

Ich muss das eigentlich mal irgendwo hinschreiben, aber naja.

Ja, jetzt kommt Werbung.

Was haltet ihr eigentlich von Werbung?

Hier.

3.11 haben wir noch was zu.

3-11?

Weil das ist ja so.

3-11 kommt jetzt ein bisschen.

Ja, 3-11 ist Main Brown sozusagen bei Python.

Ich glaube, was da ganz interessant ist, ich weiß es gar nicht, also eben ja, da gibt es auch Verbesserungen, wenn man jetzt Fehler hat.

Weitere, genau, aber es gibt auch noch, es soll jetzt mit 31, was da habe ich jetzt letztens irgendwie, gab es da auch ein Podcast-Interview mit Guido zu, was denn jetzt so alles ansteht zur Performance-Optimierung und Unterwerbung.

Oh, da gab es noch ein schönes Artikel, einen Blogpost von Marc Shannon zu, ein Interview.

Ja, Marc Shannon, genau, der hat beschäftigt sich mit ja jetzt auch schon wahnsinnig lange, aber den habe ich nicht gesehen, den müsste ich mir immer, muss man mal schicken, weil dann gegangen.

Jedenfalls, genau, Kilometer auf, genau, in die Richtung geht das halt und da wird jetzt viel dran gearbeitet und da gibt es jetzt erstmal so Basisgeschichten für in 311.

Bis das sich wirklich auswirkt, wird das alles noch ein bisschen dauern.

Aber was halt dann in 311, glaube ich, also wird es auf jeden Fall die Infrastruktur dafür geben, dass halt Funktionen sich zum Beispiel, also eines der Probleme bei Python ist halt Funktionen langsam aus diversen Gründen.

Also einer der Gründe ist halt, dass sie halt sehr, dass man ja nicht einfach, wenn man jetzt sagt, eine Funktion, die nur zwei Zahlen addiert oder so, kann man halt nicht sagen, ja, man addiert den Kram und gibt das zurück, sondern so, da muss halt viel Kram geprüft werden.

Also es kann halt alles Mögliche sein.

Es kann ja halt nicht nur sein, dass das was anderes ist.

Es kann sein, dass das Überladen wurde und weiß der Teufel.

Und jetzt der Plan, sozusagen, wie man damit, wie man das besser hinkriegt, ist zu sagen, man kann das spezialisieren.

Also wenn der Interpreter könnte zum Beispiel bemerken, okay, jetzt diese Funktion ist tausendmal aufgerufen worden und zwar immer nur mit Integer, jetzt ersetze ich die Funktion, die da aufgerufen wurde, halt durch eine schnelle Funktion, sozusagen, also anderer Beikode, der halt nur Integer macht.

Ja, so sonst nichts.

Und das geht dann halt viel schneller.

Und das Problem dabei, was das halt schwierig macht, ist, dass wenn jetzt das schief geht, wenn er jetzt plötzlich dort und doch ein Float reinkommt oder so, dann muss es irgendwie wieder, trotzdem, muss es trotzdem funktionieren.

Und wenn das häufiger passiert, weil das dann besonders ätzend ist, performance-technisch, muss dann halt auch diese Optimierung wieder rückgängig gemacht werden, wenn halt sozusagen der normale Bytecode besser gewesen wäre.

Oder ja genau, dass die Vorversion gecached sein.

Das macht es alles ziemlich kompliziert.

Und dann eine Geschichte, die mir nicht so klar war, das fand ich auch interessant, ist, dass halt die Frame-Objekte gibt in Python.

Also wenn man eine Funktion aufruft, dann wird es dann erstmal so ein Frame-Objekt erstellt.

Oh je.

Ja, das muss man auch erklären.

Ich würde sagen, ja, letztlich so ein Stack-Frame, das war dann schon sehr maschinennah.

Ein Stack-Frame.

Ja.

Also letztlich in Python ist das Frame-Objekt sowas, da steht halt drin, welche Globals es gibt, welche Locals es gibt, was das Code-Objekt ist, so Zeugs.

Also quasi der aktuelle Namespace quasi, das dickt, in dem quasi drinsteht, was alle gerade aktuell ist.

Also sozusagen alles, was man braucht, halt, um so diese Funktion auszuführen.

Letztlich.

Und es ist ja auch gut, das zu haben, wenn man jetzt zum Beispiel einen Code debuggt oder so, dann ist es halt total praktisch, wenn man das halt direkt alles nachgucken kann und wenn man es auch ändern kann und so.

Auf der anderen Seite, wenn man jetzt, wenn Code wirklich ausgeführt ist, dann braucht man das nicht unbedingt.

Und die Dinger werden halt auch dynamisch adoziert, halt sowieso alles dynamisch, und dann hat man halt den ganzen Heap folge, wenn man jetzt viele unterschiedliche Funktionen aufruft, hat man jetzt den ganzen Heap vollgesprenkelt mit diesen Dingern.

Und das macht halt alles irgendwie langsam.

Und jetzt, also eine Optimierung, ich weiß nicht, ob das kann auch sein, dass das eine von denen war, die Marc Shender vorgeschlagen hat, ist halt zu sagen, man adoziert irgendwie erstmal eine ganze Reihe von den Dingern, packt die irgendwo hin und dann nimmt man die halt und nicht nur nicht so komplette Objekte, sondern für das halt, wenn das ausgeführt werden soll, dann sind das halt einfach nur Structs und die liegen da an einer bestimmten Stelle und die müssen, das wird, und das ist halt ein Speichert dann lokal und keine Ahnung, also seine Performance ist besser und nur wenn man es die buggt, verwendet man halt halt diese vollen Fra

me-Objekte, die halt man dann sonst normalerweise immer hat.

Und was ist denn Struct?

Ja, das ist jetzt so eine C-Spezialität.

Datenstruktur quasi mit mehreren, die halt ja aus mehreren Sachen besteht, nicht nur irgendwie einso man halt diese grundlegenden Datentypen, sowas wie Integer, Float, ja, so Character und ein Struct kann dann zum Beispiel, weiß ich nicht, ein Character-Array haben und einen Float und ein Int oder so.

Und dann der, genau.

Also ein komplexer Datentyp in C quasi.

Sowas wie ein Base-Modell.

Ja.

Es ist halt kein Objekt, aber auch die Art, wie man dann Objekte in C implementiert, aber ja.

Ja, da braucht man halt noch Pointer auf die Funktionen, die das Ding hat und so.

Aber ja, genau, also das ist jetzt dann.

Aber genau, was ich auch noch interessant fand, so an Meta-Geschichten zu dieser Performance-Optimierungsgeschichte, ist halt, dass Gedo da so ein bisschen drüber erzählt hat, was ich muss den, genau, den Link auf die Episode muss ich auch nochmal in die Show Notes packen.

Was bisher immer so schief gelaufen ist.

So PiPi hat ja nicht so richtig, muss man leider sagen, wahrscheinlich nicht so richtig funktioniert.

Und der Grund ist halt, dass ja aus seiner Perspektive das ist, sie haben halt ein Problem gelöst, aber das schwierige Problem halt nicht.

Und das ist halt, wie kriegt man das so hin, dass es schneller wird, plus dass die ganzen C-Extensions halt noch funktionieren.

Das ist ja auch mal genau das Problem.

Also Pipei ist halt natürlich, es macht so ein bisschen Just-in-Time.

Wobei kann man auch nicht so richtig sagen.

Also Just-in-Time-Compilation ist halt auch so ein schwieriger Begriff.

Aber es macht halt irgendwie dein Python, die Ausführung von deinen Python-Code deutlich, deutlich schneller.

Nur das Problem ist halt, die ganzen C-Geschichten funktionieren dann halt nicht mehr.

Und das ist natürlich ein großes Problem, weil das ist halt das, wo du normalerweise deine Performance-Gewinne herbekommst.

Also wenn ich halt Sachen in NumPy mache, dann statt mit Python-Listen oder so, dann ist das natürlich viel, viel schneller.

Und ja, das geht dann halt so nicht mehr, wenn man halt PyPy verwendet.

Daher macht das alles keinen großen Sinn.

Und diese Geschichten sind halt nie, es ist halt vielleicht auch einfach nicht lösbar und daher ist das einfach nicht funktioniert.

Und sie haben halt große Schwierigkeiten, irgendwie up-to-date zu bleiben, weil sich natürlich auch immer alles ändert.

Irgendwie mit neuen Python-Versionen und dann ändert sich halt auch die C-API und so und es ist alles nicht so einfach.

Jedenfalls, dieser Weg hat halt nicht so richtig funktioniert irgendwie.

Und dann gab es ja noch ein paar andere Wege, es gab noch Pisten und es gab noch irgendwie Sachen.

Momentan gibt es auch noch.

Ich glaube, da gab es nicht nur, das gibt es auch wieder.

Gab es bei Microsoft noch Leute, die das versucht haben, auf der .NET-Runtime irgendwie laufen zu lassen.

Die machen auch irgendwie lustige Sachen.

Aber was ist denn Pisten?

Ja, auch ein Projekt, was halt so eine Art, lass mich lügen, ich weiß es jetzt gar nicht genau, was sie an Optimierung gemacht haben.

Es gab auch vorher schon schon so ein paar Sachen, wie hieß denn das noch?

Psycho, das gibt es aber schon ganz lange nicht mehr, glaube ich.

Naja, also es gab auf jeden Fall schon so ein paar Versuche, da die Sachen schneller zu machen, aber das alles, wenn das halt darauf hinauslief, dass es halt irgendwie anders funktioniert als C-Python, Bytecode, dann ist es halt nicht gut, so richtig, weil ja, das ist halt dann doch, weil das Problem ist, dass viele, viele Sachen, die halt da dranhängen, gehen dann halt nicht mehr.

Unter anderem die ganzen C-Extensions.

Was man dazu führt, also es gibt ja noch Alternativen vielleicht dazu.

Also ich habe jetzt schon ein paar Mal so Rust-Python ist mir irgendwie.

Ja, Rust, das ist auch interessant, ja, auf jeden Fall.

Also das wäre wahrscheinlich auch für die Zukunft halt, ist das eine Geschichte, die also einmal Extensions in Rust schreiben und nicht in C, das ist eine interessante Geschichte.

Und natürlich, was auch unter Umständen interessant wäre, halt vielleicht einen Interpreter zu schreiben, der halt nicht in C ist, sondern in Rust, aber das ist natürlich noch ein weiter Weg.

Aber das hätte halt den Riesenvorteil, wenn man das mal irgendwann hinkriegt.

Deswegen muss man alles zwar neu schreiben, aber ja.

Man muss halt so ziemlich alles neu schreiben, was halt ein bisschen schwierig ist.

Aber wenn es, wenn man das denn kriegt, dann könnte man das halt auch, da man Rust halt irgendwie nach WebAssembly irgendwie kompilieren kann.

Ja, klar.

Könnte man das halt in den Browser bringen.

Dann hätte man halt, das wäre natürlich schon nett.

Dann könnte man einfach im Browser dann Python ausführen.

Ja, aber das ist alles noch sehr weit weg.

Der muss halt einfach nochmal neu schreiben, dass halt noch ein bisschen wie Strecke runterziehen.

Wenn man Leute entwickelt, finden, die auch gut Rust können und so, das ist auch nicht so einfach, gibt es ja auch noch nicht so ewig.

Und das dann eine Kombination, dann muss er das dann in Rust sich dann auch wieder entwickeln, die ganzen Fehlerchen dann weg rum.

Ja, ja.

Aber das könnte tatsächlich doch gar nicht so interessant sein, oder?

Also es könnte doch deutlich schneller sein als noch in C.

Sicherer auch als in C.

Ja, ja, klar.

Also es ist auf jeden Fall sehr interessant.

Ich bin gespannt.

Aber genau, um mal wieder den Bogen wieder zurückzukriegen, also das Guido hat ja jetzt angefangen, wieder, also der war ja im Ruhestand, ist er wieder zurückgekommen und hat jetzt da so ein Team bei Microsoft und das ist auch komisch, dass er nie gedacht hat, also ja, aber so ist es halt.

Schon irgendwie, ja, ist jetzt wieder cool.

Und genau, der widmet sich da jetzt hauptsächlich irgendwie Python-Performance und das natürlich auch schon mal, aber es wird halt noch ein bisschen dauern, auch bis er sich das dann wirklich auswirkt.

Aber wir können wahrscheinlich damit rechnen, dass halt in den nächsten Jahren Python halt nochmal ein gutes Stückchen schneller wird.

Und das ist auch schon mal eine schöne Sache.

Ja, ja.

Ja.

Genau, ich weiß nicht genau, hatten wir sonst noch irgendwas zu Python?

13 oder 31 haben wir jetzt gebracht.

Also ja, drei Besser Facepacks haben wir auch schon gesagt.

Ja.

Das sieht wirklich schick aus jetzt.

Das heißt, man kann die wirklich mal lesen.

Das macht einen Sinn.

Das ist schon gut, ja.

Also ja, ich glaube, News gibt es halt noch ein bisschen in Django vielleicht.

Ja, Django, da gibt es jetzt auch eine Alpha-Release von Django 4, das habe ich auch mal ausprobiert.

Geguckt, was dann alles so kaputt geht.

Und was geht kaputt?

Ragtail zum Beispiel.

Ach so,

so eine Überraschung.

Ja, und noch so ein paar andere Sachen.

Also, ich meine, meine Lieblingskandidaten für irgendwie was Sachen geht schief, sind ja auch mal so die ganzen Commands-Zeugs, weil das halt auch nur noch so marginal maintained ist.

Irgendwie Threaded Commands, Fluent Commands, Control-Commands, Control-Commands, glaube ich sogar halbwegs gut maintained.

Da gab es auch im Mai oder so wieder eine Version, war aber Fluent-Commands und Shredded-Commands vor allen Dingen eher nicht so.

Und genau, Threaded Commands ist halt auch kaputt gegangen.

Da habe ich dann halt irgendwie auch, glaube ich, einen Pull-Request gemacht, was ich habe.

Und dann Wagtail ist auch kaputt gegangen.

Da habe ich dann auch einen Pull-Request irgendwie gemacht.

Der ist auch, dann habe ich mich nicht mehr drum gekümmert, weil ich keine Zeit hatte.

Und dann ist er irgendwie so halb durchgegangen.

Das ist mir, das ist ehrlich gesagt ein bisschen peinlich, weil ich habe da irgendwie nur sowas hingerotzt und dann kamen da noch so Anmerkungen und was ich noch tun könnte und so.

Und ich habe einfach nicht mehr reagiert und dann hat da irgendjemand dann irgendwie Teile davon einfach so gemercht und waren halt dann drin.

Aber es ist irgendwie, ehrlich gesagt, sehr schlampig von meiner Seite aus.

Aber ja, also

ich kriege immer auf die Finger, wenn ich das nicht ordentlich mache.

Ja, aber prinzipiell geht Wagtail mit Django 4.

Also das funktioniert schon.

Also man muss da gar nicht so wahnsinnig fühlen.

Prinzipiell schon, wenn man noch.

Also es gibt zwei Dinge, die nicht funktionieren.

Das eine ist zwar aus Quote verwendet, das hat sich irgendwie geändert.

Das war früher in Django selber drin.

In Django 4 fliegt das raus, ist sowieso schon deprecated.

Und das bedeutet, man muss jetzt aus vom Urlaub Pass-Import-Quote sagen, statt das aus Django zu importieren.

Also weil das jetzt halt in der Python-Standard-Bibliothek genau das gleiche macht wie halt vorher in Django und das musste man ändern.

Oder wenn man URLs-Qoten meinst du, also um irgendwie so Sachen rauszubekommen, oder?

Ja, genau, um zum Beispiel irgendwie das halt ein Dikt oder so.

Ja, okay.

Dann willst du das halt in URL-Parameter verwandeln.

Ich weiß gar nicht jetzt genau, unter welchen Bedingungen man das jetzt wie verwendet, aber ja, genau, also es ist halt so, dass das aus irgendwas, was nicht halt in der URL stehen kann, was machen wir es halt da drin stehen kann.

Ja.

Und dann eine andere Geschichte ist genau, da ist so ein Is-Ajax, Requestpunkt is-Ajax ist rausgeflogen und das wurde in RecTile halt auch verwendet.

Das wird relativ viel verwendet auch irgendwie, ne?

Von ist Agect, ja.

Und warum ist das nochmal rausgeflogen?

Da gab es irgendeinen

Grund für.

Der Grund ist, dass die Überprüfung, ob das jetzt Ajax ist oder nicht, so ein bisschen darauf basiert, dass das von jQuery aus aufgerufen wird.

Also weil jQuery macht da irgendwelche, also ich glaube, also es setzt halt irgendeinen Header.

Also sowieso, es macht, glaube ich, nicht mehr, als irgendeinen Header zu überprüfen, ob der gesetzt ist.

Das ist nicht die richtige Methode, man soll direkt gucken, ob der Header drin ist einfach.

Genau, das ist halt der empfohlene Workaround, das einfach ersetzen durch, ist der Header da drin oder nicht?

Genau, das habe ich dann in Wacte auch gemacht.

Aber insgesamt hieß es halt so in den Django-Dokumentationen dazu, ja, also das ist sowieso nicht so toll, das darüber zu machen, weil das ist halt jQuery-spezifisch.

Und jQuery ist auch so auf dem Weg nach draußen und die meisten verwenden halt inzwischen Fetch in JavaScript, die Fetch-API.

Und die macht das sowieso irgendwie anders.

Und das heißt, das heißt, das ist ein bisschen nutzlos, ja.

Das ist Ajax, das liefert halt einfach nicht mehr die richtige.

Es ist ein Ajax-Call, ja, aber das kommt halt am Server so nicht an.

Beziehungsweise den Header zu überprüfen, ist so ein bisschen sinnlos und weil das halt irgendwie nur von jQuery gesetzt wird.

Das heißt, im Grunde muss man das streichen, weil das funktioniert so nicht mehr.

Und dann die andere Geschichte ist halt auch so, ja, wozu das überhaupt überprüfen?

Das ist auch irgendwie Quatsch, weil, naja, oder genau, das ist halt empfohlen, was man dann überprüfen soll, weil was möchte man eigentlich machen oft und möchte halt so etwas machen wie, ja, wenn da jetzt ein Browser auf die URL geht, zum Beispiel, und dann halt sonst JSON kriegen würde, dann will man dem nicht einfach JSON schicken, sondern vielleicht eine HTML-Fehlermeldung, so, äh, hallo, geh bitte nicht mit dem Browser hier hin, sondern geh lieber da hin, weil hier gibt es eine JSON, sowas.

Und dafür muss man halt eine Fallunterscheidung machen.

Und da sollte man doch lieber auf Request.accept gucken, ob das Ding jetzt zum Beispiel HTML, äh, Text.html haben will oder so.

Wenn es Text-HTML haben will, dann sagt man halt hier so, hier Fehlermeldung, ich gebe eigentlich nur JSON zurück, ich kann gar nichts anderes als JSON.

Und das ist halt dann besser.

Das funktioniert dann in jedem Fall eigentlich, sozusagen, egal welche, wie der Request gemacht wird von der Kleinseite aus, ob über Fetch oder jQuery.

Genau, das ist halt das, worauf man dann langfristig migrieren sollte, kurzfristig, wenn man es.

Weil es ist Ajax ist halt weg.

Mit Django 4, ja.

Genau, aber ansonsten hat relativ reibungslos funktioniert.

Also Django 4 funktioniert bei mir schon relativ problemlos.

Und ja.

Also Time-Zone-Info haben sich so ein paar Sachen, glaube ich, geändert, wenn man die Fragen hat.

Also die hat ja, weiß ich, Python, wann hat das noch umgeschlecht?

Drei irgendwas.

Dass irgendwie Zone-Info jetzt neu in der Spieler.

Ich weiß nicht, ob das bei Python 3.9 drin war, dass das jetzt ein neues gewandert ist, ja.

Genau.

Genau, und da kann man ja wahrscheinlich mehr machen als PyTZ, das irgendwie raus soll irgendwann.

Ja.

Genau, und das ist ja vielleicht ganz interessant noch.

Auch ein schönes neues Feature.

Ja, und ansonsten die anderen Sachen, ehrlich gesagt, oh, es gibt ein Standard-Redis-Cache-Backen jetzt, das muss man nicht mehr extra dazu packen.

Aber gut, keine Third-Party-Library, aber.

Ja, also ich meine, ändert sich da nicht so viel dran, weil, ja, ich meine, man konnte es ja auch bisher schon alles verwenden.

Also das war, gibt es eine Umfrage, die sie irgendwie gemacht haben, wer verwendet denn, was verwenden denn die User denn so für Caching-Backends und Memcache, die ist halt drin in Django, da muss man nichts zusätzlich installieren.

Und dann kam in der Umfrage raus so, oh, die Leute verwenden aber alle Riders und nicht Memcache die.

Und ja, das ist halt nicht drin, das heißt, alle müssen nochmal irgendwie Zusatzkram installieren.

Oh, das bringt mich fast schon zu meiner nächsten Frage, weil das da so ein bisschen daran anschließt.

Aber das, ja, vielleicht stellen wir das noch kurz zurück.

Wir machen Werbungdödel.

Wieder ein bisschen.

Ja, dann sind wir fertig denn tatsächlich mit Python Dango und News, hast du noch gesagt?

Nee, lass mal überlegen.

Nee, doch, also mit den News auf jeden Fall, aber genau, ich habe noch so ein paar, ach, weiß nicht, ob ich das auch eine News, Cycit Learn, es hat eine Version 1.0.

Ah, mhm.

Das war ehrlich gesagt schon relativ lange stabil, aber jetzt hat sie auch tatsächlich irgendwie eine Version.

Ja, offizielle 1.0 Version, ja, okay.

Major Versionsnummer, was eine tolle Geschichte ist, ja.

Super Projekt.

Genau.

Ja, das ist auch so das Beispiel.

Ich habe letztens, genau, gab es Lex Friedman, der der Gründer von Anaconada und von der Travis Olephant, der hat auch NumPy, SciPi, SciPi hat er zuerst, wusste ich auch nicht was.

Fand ich auch interessant, SciPi zuerst entwickelt und dann NumPy kam später dazu, weil man Numeric und wie ist das andere Ding, NumArray irgendwie zusammenfassen musste, weil es gab zwar eben diese beiden unterschiedlichen Implementationen, dann ist daraus halt NumPy geworden.

Der erzählt halt da auch so ein bisschen und da, der halt hat dann ScikitLearn als so beispielhaftes Projekt, wie das hätte laufen sollen, eigentlich dann erwähnt und ein ganz tolles Projekt.

Ja, also Csicit Learn, wirklich voll gut.

Es gibt auch noch CircleIvinch und noch ein paar andere.

Aber Circit Learn ist eigentlich so das große Ding, was dabei rausgefallen ist.

Ja, voll gut.

Was haben wir noch?

Tja.

Oh, es gab eine Sicherheitslücke.

Das ist jetzt gar nichts mit Python zu tun.

Ich fand das nur deswegen interessant, weil es halt so eine Geschichte ist, die etwas illustriert, was man, wenn man das einfach so erzählt, oft ist das nicht so ein bisschen intuitiv, aber das ist halt ein sehr schönes Beispiel dafür, weil ich habe halt oft das Gefühl, dass ja es sozusagen die Ansicht gibt, dass man Sicherheit irgendwie dadurch herstellen kann, dass man zusätzlich Dinge tut oder Dinge erweitert oder so.

Also man, man, weiß ich nicht, kauft irgendetwas, was dann halt Sicherheit macht.

Oder man installiert zusätzliches Zeug, das dann Sachen sicherer machen soll oder so.

Und ich habe da immer so ein bisschen Bedenken und ich habe das Gefühl, dass das geht eigentlich gar nicht, sondern eigentlich kriegt man also wirklich Sicherheit nur dadurch, dass man Sachen weglässt, weil alles, was halt irgendwas tut, hat halt irgendwie redet halt macht halt die Angriffsoberfläche größer.

Und das ist halt ein Problem und jetzt hat es halt einen so ein Ding erwischt und das fand ich interessant.

Was für ein Ding hat es denn überhaupt?

Fail to ban.

Fail to Ben.

Das ist halt irgendwie so ein Ding, was man sich zusätzlich zu SSH installiert und das dann halt irgendwie sich anguckt, was da passiert und dann halt zum Beispiel den Port zumacht.

Oder sonst irgendwie was.

Und das hatte jetzt, äh, ich meine, die Auswirkungen davon sind nicht ganz so schlimm, weil aber was das Ding gemacht hat, ist halt, ist halt halt, wenn er irgendwas, äh, wenn er jemand irgendwie an diesem SH-Port rumgespielt hat, hat es halt dann irgendwann ein Hues auf die IP, von der diese Login-Versuche kommen, gemacht, sich halt die Informationen rausgeholt und das dann per Mail irgendwie an den Admin geschickt.

Okay.

Kind jetzt erstmal noch nicht so schlimm.

Das Problem ist, da war eine so eine Shell-Escape-Lücke im Mail erzeugen.

Das heißt, das hat irgendwie den Text aus dem Huis genommen, dann irgendwie in die Mail und das hat ein paar Kommandozeile übergeben an das Ding, was

die Huho ist, konntest du modifizieren.

Das heißt, wenn du das Hu-S kontrollieren konntest, konntest du da halt dann irgendwie durch so Bactick irgendwie weißer Teufel irgendwie Spielereien, das Ding dazu bringen, einen beliebigen Code auszuführen.

Und dann konntest du halt einfach eine Rutsche aufmachen.

Also einige Leute passiert sowas ausnahmsweise, aber ich habe, da muss ich jetzt auch noch eine kurze andere security-relevante Geschichte erzählen.

Und zwar, ihr wisst ja, manchmal mache ich auch ein bisschen Azure.

Und da war was ganz Tolles dabei.

Und zwar hat das, glaube ich, weiß nicht so was wie 2,5 Millionen Kunden betroffen oder so, war auch gar nicht so relevant.

Jedenfalls alle Leute, die halt Linux-VMs bei Azure hosten, was ja man ja macht.

Ich habe nämlich schon ein paar Mal gewundert, warum die irgendwie komischen Windows-Fehlermeldungen abstürzen.

Ich dachte so, hä, das kann doch nicht.

Die laufen halt tatsächlich auf irgendeinem Windows drauf.

Und was halt da irgendwie drumrum ist, ist halt irgendwie so ein Rapper und Microsoft macht da irgendwelche Service-Prozesse irgendwie auf.

Und man kann irgendwie auf einen Endpunkt einfach diesen Microsoft-Service-Endpunkt ansprechen.

Und dann musste man halt dann sich authentifizieren, damit man da irgendwie Service-Prams machen darf.

Und ganz besonders cool, weil es ist 2021, wie das sowas irgendwie möglich ist, weiß man nicht genau.

Aber wenn man jetzt die Credentials als Fight angegeben hat, gibt es halt einen Denied.

Und was passiert, wenn man gar keine Credentials angegeben hat?

Ja, dann war alles gut.

Dann war Rut.

Einfach so.

Ihr habt ja gesagt, okay, die Credentials, okay, muss wohl gut sein, ist wohl ein Admin.

Dankeschön.

Und ja, tatsächlich, diese Lücke war tatsächlich einfach da und einfach offen.

Das heißt, wenn du diesen Endpunkt kennst von der Applikation, konnte sich einfach ohne Credentials anmelden und da hast einen Route auf diese ganze Applikation bekommen.

Und es war völlig egal, was du gemacht hast, weil halt deine ganze Anwendung in deinem Linux-VM-Container einfach dann schreiber.

Aber war es ein bisschen Mittelgut.

Und was auch sehr super daran ist, das geht nicht automatisch zu patchen.

Das heißt, du musst hier da hingehen und musst das manuell ausbauen, falls er das irgendwie bei sich aktiviert hat.

Tja, und die sind irgendwie Stefault aktiviert.

Naja.

Ja.

Aber okay, passiert halt wohl.

Also wenn ihr irgendwelche Linux bei Amsterdam Azure habt, guckt da mal vielleicht nochmal nach diesem Bugner.

Klingt auch nur so, nicht so, klingt eher so Mittel.

Das war auf jeden Fall so eine Sache, dass ich dachte, oh mein Gott.

Ja.

Ja, oh, Sicherheitslücken, wo wir geraten bei sind.

Was war vor ein paar Tagen auf Twitch?

Komplett wohl einfach mal komplett geleakt.

Tja, kommt.

Kann halt mal passieren.

Aber immerhin nur Passwort-Hashes.

Naja.

Ja, aber auch halt, was dann auch interessant ist, also halt auch die Bezahlinformationen.

Ja, wäre Pipi.

Mal gucken, wie viel das wert ist.

Da haben wir irgendwie ganz interessante Geschichten dabei.

Ja.

Also wenn ihr jetzt mal wissen wollt, wie viel euer Twitch-Favorite Stream ist und verdient.

Oder wie viele Jochen mit seinen Streams verdienen beiden Podcasts?

Ja, das ist leider relativ traurig, da ist nichts.

Aber ich bin auf deiner Seite.

Wenn es so allgetragen ist, kann man da auch deine Informationen jetzt abrufen.

Ich nehme mal an, dass es nicht draufliegt.

Es ist halt an der Stelle ein bisschen sinnlos, weil es ist eh öffentlich.

Also ich habe da nichts, was irgendwie nicht öffentlich ist, aber ja.

Also ich darf verraten, die Return Investment bei Twitch bei dir im Moment null.

Ich schaffe es auch nicht, in das Affiliate-Programm reinzukommen, weil ich habe noch nicht genug.

Und jetzt kommt vielleicht Werbung.

Genau.

Ja, ja.

Ja, aber ansonsten, ich finde das eigentlich ganz, das mache ich jetzt halt schon eine Zeit lang, dieses Streamen.

Das ist eigentlich schon ganz witzig.

Also das sind teilweise schon, also damit hätte ich nicht gerechnet, dass alle Leute live im Stream mir sagen, dass das, was ich da mache, ist halt falsch und wie es besser machen soll.

Und das stimmt.

Das finde ich echt beachtlich.

Das ist echt hilfreich.

Das fand ich schon mal, hätte ich, hätte ich ehrlich gesagt nicht mit gerechnet.

Also einmal hätte ich nicht damit gerechnet, dass sich irgendjemand dafür interessiert, was ich da tue, wobei ich auch nicht gerechnet hätte, ist, dass, wenn sich da jemand dafür interessiert, dass er auch besser weiß als ich.

Aber ja gut.

Wahrscheinlich wenn ich aber schon besuchen, dann weiß, ist tatsächlich wahrscheinlich wieder besser.

Ja.

Oh ja, offenbar.

Und das finde ich faszinierend.

Was ist dir denn da aufgefallen?

Was war denn?

Zum Beispiel, gut, also bei PyTest waren so ein paar Sachen dabei, wie man das richtig macht.

Und das wusste ich halt nicht.

Oder Py-Charm auch einige Sachen, wie man da Dinge einstellt und so.

Oh ja, aber

gut, da kenne ich mich jetzt auch nicht so aus, das stimmt schon.

Aber da habe ich gerade Bay gesagt, Entschuldigung.

Ich finde Py-Charm gar nicht so schlecht.

Also inzwischen bin ich sogar ein bisschen, also man, ja.

Du bist ein Fan geworden?

Nee, das kann man nicht.

Aber also ich würde sagen, doch, die kann, wahrscheinlich kann die tatsächlich alles, was man so haben will.

Ja.

Ja, also ich, äh, also VSCO kann ja noch nicht alles, was man so haben will, aber ich schreibe fleißig Tickets herum und gucken.

Vielleicht kann das ja in einem Jahr das alles, was ich haben will.

Also das Einzige, was mir bei VS Co tatsächlich noch nicht gefällt, ist tatsächlich ein Datenbankzugriff.

Da muss man halt Extensions nehmen, die alle so mittelgut funktionieren.

Das heißt, direkt die Datenbank einbinden, ist so ein bisschen nervig.

Und ja, Tests nerven mich immer ein bisschen beißend, weil die nicht so integriert sind, wie ich mir das vorstelle.

Also es ist immer ein bisschen gehampelt, die so einzubauen.

Das nervt ein bisschen rum.

Vor allen Dingen, wenn es dann in Containern läuft auch noch oder so, dass das so ein bisschen anstrengend, das dann einzubinden.

Ja, ich würde das, also bei Pycharm zum Beispiel, die letzte Geschichte, die mich da so, man muss dann halt, also Test-Route ist halt irgendwie, also der macht dann halt eine Testkonfiguration, wenn man einen einzelnen Test ausführt und dann, so ganz habe ich es auch noch nicht hingekriegt, aber dann ist zum Beispiel das Working Directory ist halt dann einfach falsch oder so.

Das funktioniert nicht mehr.

Und dann kann er die findet er die Datenbank nicht mehr und ich erinnere mich daran, dass ich diese Geschichten bei PyCharm schon häufiger hatte.

Und dann war halt zum Beispiel die Lösung für einen Großteil dieser Probleme irgendwie dann auf das Root-Verzeichnis irgendwie in der Projektübersicht, Rechtsklick drauf machen und dann sagen Set as Test-Route.

Und dann hat es funktioniert.

So, okay.

Naja.

Also solche Sachen halt.

Aber das muss man halt, also, und vorher dachte ich so, naja, das mit den Tests funktioniert halt einfach nicht richtig.

Also, aber gut, das funktioniert schon, wenn man weiß, wie man es konfigurieren muss, aber das ist halt manchmal schon ein bisschen.

Ja, sowas ist das in der Feind anders.

Wenn es gerade nicht geht.

Ja, keine Ahnung.

Aber ja.

Aber ansonsten, nö, Peitscham, genau, eine Sache auch im Stream, ja, da habe ich dann geflucht darüber, dass das oder nicht geflucht, ich habe gerade gesagt, so hier verwende ich ja Peitscharm auf Intel, aber wenn ich jetzt irgendwie auf meinem M1 Mac unterwegs bin, dann nehme ich immer VS-Code, weil Peitscharm kann ich da gar nicht verwenden.

Das ist einfach zu langsam.

Ich finde es ja auch schon auf Intel langsam, aber auf Arm geht es gar nicht.

Und es zieht die ganze Zeit Strom wie Hölle, ja.

Das heißt, eigentlich hätte ja so ein M1 Mac super Akku Laufzeit, aber wenn man PeitschRAM benutzt, so wie ich das getan habe, dann halt nicht, dann sagt das den Akku sofort leer.

Und deswegen nehme ich dann mal, wie es Code, wie ich dann so, dann kam auch so im Chat und so, ah ja, bist du ja eigentlich sicher, dass du das irgendwie native, dass du die für Arm kompilierte Version da nimmst, irgendwie und nicht die alte Intel-basierte, die dann emuliert wird, weil die, dann bin ich so, oh, Mist, ja, ist tatsächlich so, und dann haben wir ein neues Peitschab genommen und das ist deutlich besser.

Ja, also offenbar brauchte man da eine JVM, die halt für ARM kompiliert ist und nicht die für Intel, weil wenn man die nimmt und die auf dem M1 emuliert wird, dann, also die Emulation funktioniert wohl ganz gut, aber wenn man sowas emuliert, dann ist es halt wohl scheiße.

Okay.

Und das, äh, ja, war auch eine Geschichte, die im Stream mir jemand im Chat einfach so gesagt hat.

Voll gut.

Okay, cool.

Ja.

Tja.

Genau, Security, genau, Twitch hatten wir.

War sonst noch irgendwas mit News?

Nee, mir fällt eigentlich ehrlich gesagt nichts ein.

Meine Güte, vielleicht liegt es auch einfach daran, dass wir so lange nichts mehr gemacht haben.

Aber News und wir sind bei einer Stunde, was ist denn da los?

Ja, ja, vielleicht.

Bisschen gequatscht.

Okay, tja.

Ja, dann stelle ich jetzt einfach nochmal meine paar doofen Fragen und vielleicht fällt hier jetzt sowas ein zu diesem Thema.

Und zwar ging es halt tatsächlich darum, wenn ich jetzt in Python irgendwie mehrere Prozesse habe oder sowas oder Sweats oder so.

Ich weiß nicht, ob das ein Unterschied macht.

Und zwar die ich nicht herausstarte aus einem Main-Swead oder sowas, sondern die beispielsweise wie beim Gunny Korn einfach weggeforgt werden.

Während er es auch macht, der macht dann verschiedene Prozesse auf und macht die gleichzeitig auf und so.

Ich möchte aber überall diese Prozesse hinweg einen geteilten Speicherbereich haben und da irgendwas am liebsten Python-Objekte reinschreiben können.

Mit, weiß ich nicht, Funktionen drin oder irgendwas, dass er halt einfach genau gecallt werden kann.

Wie mache ich denn das am besten?

Geht nicht.

Das würde ich sagen, es geht tatsächlich nicht.

Also mit Threads-Kids, da ist es halt so, die teilen sich halt einen Adressraum und einen Speicher.

Aber also das ist eigentlich der Hauptunterschied zwischen Threads und Prozessen.

So was auf der Betriebssysteme-Ebene.

Also Threads laufen halt im gleichen Prozess und haben den gleichen Hauptspeicher.

Und Prozesse sind halt komplett voneinander getrennt, können ja gegenseitig nicht auf Sachen zugreifen und auch, also sind komplett, da braucht man dann halt so Interprozess-Kommunikationsgeschichten, um halt zwischen den Prozessen zu kommunizieren.

Also das heißt, das geht tatsächlich gar nicht aus Python heraus.

Das heißt, ich muss irgendwie was Externes nehmen, wie ein Memcache-D-Ridis oder sonst irgendwas.

Also eine quasi Art von Datenbank im Speicher, die dann extra läuft und auf die ich dann von allen diesen Prozessen irgendwie einen Zugriff bekomme über URL oder irgendwas.

Ja, also oder was auch immer.

Es muss ja nicht irgendwie jetzt ein Ridis oder Memcache-D sein oder es kann auch eine Datenbank sein oder es kann halt ein File sein oder es kann halt eine Pipe sein oder

das habe ich auch vorlegt.

Also kann man aus Fice-Nachts einfach eine File im Memory aufmachen, auf die dann alle Prozesse haben?

Nein, auch nicht wahrscheinlich.

Alles klar, das kann man schon machen.

In Memory?

In Memory, warum in Memory?

Ja, weil ich will ja nicht I.O.

machen auf der Platte, weil ich will ja genau diesen Speed halt nicht verlieren, den.

Nee, du kannst auch Chat Memory, das geht auch, aber die Frage wäre halt, nein, aber du musst es ja sowieso, also dein Bottleneck wird dann ja eh die Serialisierung, Deserialisierung sein.

Aber das heißt, also okay, das war nämlich genau nochmal die nächste Frage.

Ich muss quasi meine Objekte immer serialisieren, deserialisieren, weil ich nicht darum rumkomme, weil ich nur als irgendwie in Bytes oder so in den Speicher schreiben kann.

Genau, du musst halt das irgendwie in eine Form bringen, die man halt irgendwo hinschreiben kann.

Genau.

Ja, und dann hatte ich die tolle Idee, das dann zu pickeln.

Dann sagte, Junge,

oh, kann man machen, ist aber ja.

Ja.

Ja.

Ja, weil, also Joch hat gesagt, das wäre keine gute Idee, weil man könnte ja dann da, wenn man diesen Speicherbereich kontrolliert, da was reinschreiben, dann wird dann was realisiert und dann macht es bumm.

Ja, genau.

Also Sachen ausentpickeln, ist halt quasi das gleiche wie Code ausführen.

Also daher muss man da ein bisschen.

Gibt es auch tatsächlich Sicherheitslücken, die große Seiten, ich weiß nicht, welche das war.

Das war auch irgendein Contest, ich habe es wieder vergessen, welche Seite das war.

War eine wirklich, war eine von den ganz großen, die, wo jemand so reingekommen ist über Django, auch Django.

Und da, die hatten irgendwie auch, ich weiß nicht, Memcash D oder Redas benutzt und da auch die hatten gepickelte Sachen in User-Cookies abgelegt.

Und das war noch nicht das Problem und man konnte durch irgendeinen Trick konnte man halt den Kram irgendwie in den Memcash die bringen und dann da den Applikationsserver dazu bringen, das dann halt zu entpickeln.

Und dann ist man da, sind da Leute so da reingekommen.

Also ja, das ist problematisch.

Also wenn User es schaffen, irgendwie deine Applikation was gepickelt zu geben, wo sie Kontrolle drüber hatten, dann ja.

Oder es war irgendwie, es war auch irgendwie signiert oder so und an der Signatur war irgendwas kaputt, ich weiß es nicht genau.

Aber ja, also das heißt theoretisch, wenn ich gerade auf meinem eigenen Server läuft, dann, also wenn einer dann da schon drin ist, dann hat er eh schon root.

Also dann wäre es ja nicht.

Ja, aber das ist ja dann zu, also das ist ja, aber das ist ja, vielleicht gibt es ja irgendwie, ich meine, wie kommen die Daten da rein, ja?

Also wenn jemand quasi, vielleicht hat ja jemand dann nur Zugriff auf irgendeinen, ist irgendwo reingekommen über, weiß nicht, der läuft vielleicht auch noch irgendwelche anderen Services und kann halt nur eine Netzwerkverbindung aufmachen, ja.

Und dann lauscht da aber dann ein Memcache-D und dann kann er da was reinlegen und dann wird das ausgeführt.

Also es ist halt, ja, die Frage ist, will man Leuten dadurch, also ich meine, sowas wird da wahrscheinlich nicht ausgenutzt, wenn man da irgendwie eine kleine Geschichte selber hat, aber überhaupt, dass es die Möglichkeit gibt, dass man dadurch, dass man an irgendeinem Port irgendwas hinschreibt, dadurch deinen Code in deiner Applikation ausführt, ist halt schon so, will man wahrscheinlich nicht.

Ja, also ich weiß halt, wie das sonst gehen könnte, da muss man sich halt eine andere Lösung für überlegen, ne?

Ja, also mein Anwendungsfreck ist eigentlich nur, dass tatsächlich über verschiedene Gunning-Worker-Prozesse Zugriff auf ein gemeinsames Dikt haben wollen würde.

Und dass ich halt so Dinge ablegen kann.

Ja, aber warum nicht?

Also jetzt meine Standardfall, warum nicht einfach eine Datenbank nehmen?

Ich meine, dafür ist die Datenbank eigentlich da.

Ja, also weil es halt zum Beispiel keine gibt oder halt, dass nur eine SEG-Light, dass die halt dann schon legt ist und so.

Ja, wenn du keine Datenbank hast, ja.

Warum nicht einen Pfeil nehmen?

Zu langsam?

Wieso ist das langsam?

Muss ja nicht langsam sein.

Also ja, natürlich ist das eventuell langsam, aber kommt jetzt auf deine Daten an.

Gut, aber theoretisch könnt ihr, wenn dann jemand auf das Pfeil hat, kann er dann auch alles mit dir reinschreiben und das dann nicht.

Ja, gepickelte Sachen darf man da nicht reinschreiben.

Ja, aber was will ich dann?

Das ist ja genau dasselbe Problem dann.

Also mein Problem, ja, also.

Aber warum möchtest du gepickelte Sachen abspeichern?

Um sich später zu verwenden.

Also weil ich zum Beispiel, ich habe bestimmte Routinen, die ich ausführen möchte mit Argumenten und so weiter, die quasi schon feststehen, aber die zu einem späteren Zeitpunkt laufen.

Ja, aber du kannst ja sozusagen durchaus sagen, ruf die Funktion mit den Parametern auf.

Du kannst ja die Parameter kannst du ja schon vielleicht irgendwie, je nachdem, was das ist.

Also natürlich.

Ja, aber du kannst ja auch den Namen von der Funktion einfach speichern.

Kann ich das?

Das kannst du machen.

Ja, okay.

Und wie kriege ich die dann rausgepult?

Muss ich nochmal kurz überlegen.

Ja, ja, das ist dann halt nicht mehr so einfach, dass man einfach sagt, JSON Dumps und Loads, sondern dann muss man das halt selber wieder sich daraus ein Objekt zusammenbauen, oder?

Das kann man ja auch machen.

Das heißt, ich muss, aber wie baue ich dann den Pfad zu dieser Funktion zusammen?

Die muss ich dann irgendwie spät ja spontan ein, wie das geht?

Keine Ahnung, ich habe jetzt Pfad zu meiner, das ist jetzt Applikation.functions.fuba.

Ja, kannst ja einfach den Vater reinschreiben.

Den Vater der Funktion tatsächlich einfach.

Dann machst du mit Import-Lib importierst du das Ding dann und.

Mit Import-Lib.

Relativ oder absolut?

Muss ich absolut.

Ist das egal?

Ja, weiß ich nicht.

Wahrscheinlich ist absolut so ein bisschen, also ja, kommt drauf eine, wo das.

Wahrscheinlich wird man es absolut zum Paket halt.

Okay, ja, das muss ich mal probieren.

Weil vielleicht wäre das tatsächlich, da du da den Namen hast, hat der Callabild zu nehmen, eine Rettung, dann hätte ich halt nur noch Argumente, aber gut, die dürfen dann.

Die Frage ist, wie viele unterschiedliche Sachen können das denn sein?

Kann man da nicht das sowieso irgendwie eher in so einem Lookup, dann nimmst du halt irgendeinen Namen, völlig egal, musst du nicht über Import machen, das will ich gerade auch, das ist vielleicht nicht so eine schlaue Idee.

Sondern du hast halt irgendwo ein Dikt, wo die ganzen Funktionen drin liegen, das halt irgendwie mal initialisierst und dann musst du nur noch deine Funktionen halt, du hast sozusagen eine Registry für diese Funktionen.

Okay, ja, das Problem ist halt, dass wenn jemand halt jetzt, also es geht halt um so eine Event-Queue, ja, und wenn jemand halt jetzt neue Events anlegen möchte, die halt quasi dann einfach über so einen Dekorator subscriben kann, auf irgendeinen Typ, den er sich da selber quasi aussuchen kann, indem er das da subscribe, weil er halt der Typ nicht so nicht gibt, wird einfach erstellt, dann müsste man ja quasi diese Funktion, die ja dann, also ein Event ist, dann auch registrieren.

Und wenn derjenige es halt vergisst, dann funktioniert es halt nicht.

Und das ist halt so ein bisschen nervig, weil es halt an schon an zwei Stellen das dann halt überprüft werden muss, der kann halt nicht irgendein Event erstellen und das dann einfach dann registrieren und dann Händler für nehmen, sondern er muss sich halt an eine Stelle an die Registrierung wenden und das muss halt am händisch machen.

Das hätte ich mir halt gerne gespart, weil es halt bestimmte Entwickler gibt, die das verstehen oder nicht verstehen und denen vielleicht einfach eine Methode schreiben können, die dann irgendwas macht.

Naja, gut, aber du kannst ja auch, du kannst es ja auch irgendwie, du kannst ja überlegen, wie man die Funktion adressiert sozusagen und dann, das kannst du ja dann selber machen.

Naja, gut, ich war ja.

Ja, also ich überlege halt, was, also ich glaube, dieses Pickeln ist halt an der Stelle quasi die einfachere Lösung.

Ja, aber da weiß ich nicht.

Also Pickel.

Aber die Frage ist halt, wo es halt geht, ob es halt nur über so ein Mengen-Cache-D geht oder so ein Redis-Kate oder halt noch eine andere Variante gibt, die irgendwie einfacher ist, irgendwie.

Ob man einfach.

Kann man aus Python raus einfach so ein Chat-Memory außer Halbplatten aufmachen oder geht das nur mit sowas wie Memcache-D und Redis?

Gibt es ein Python-Modul, was das kann?

Man kann das schon machen, aber ich weiß nicht, ob das empfehlenswert wäre, weil du musst ja irgendwie auch darin drauf zugreifen.

Und das dafür bietet ja sowohl Memca-D auch Redis-Dinge an und wenn du es selber machst, ist schwierig.

Weil wenn, was ist, wenn dann der Applikationsserver jetzt eine Prozess läuft, jetzt auf dem anderen Rechner damit?

Das ist ja auch wieder ein Problem.

Also ich, ich meine, klar, natürlich die Abhängigkeiten sind halt blöd.

Jetzt dann deswegen noch ein zusätzliches Redis braucht oder so.

Das ist halt die Frage, ob es nicht schon irgendwas gibt, was man schon hat, eine Datenbank oder einen Programm.

Ja, genau, anders

oder eigentlich die.

Ja, also auch die Frage, ob man halt, wenn ihr Projekte voneinander isoliert aufbaut, ob man dann, na ja, ob man, ja, eigentlich müsste man die Sachen dezentral voneinander betreiben, aber das ist halt dann wieder so ein Problem, dann mit Deployment, ganze Deployments zu machen, die vollständig sind und so.

Die dann jeweils unabhängig voneinander sind und dann nicht erwarten, dass schon irgendwo anders dann so ein Redisrup liegt oder so und dann eine neue Verbindung aufmachen, einen neuen Redis-Nutzer mit einem neuen Ausländerbizing, bla bla bla.

Das ist halt alles relativ auffällig für so kleine Sachen, dass man irgendwo mal kurz so zwei Kies im Dick abliegen will.

Dann wäre halt die Frage, wozu brauchst du denn dann mehrere Prozesse?

Ja, gut, aber das liegt halt auch daran, dass der Ganicorn da so ein bisschen mehr Power kriegen soll.

Wenn man jetzt im Gunnycorn sagt, du laufst auf einem Worker, dann reicht es ja halt, ja.

Ich hatte irgendwann bei Stack Overflow mal so eine Art von den hat der Preload gemacht, dann hat er erst die Applikation geladen, dann die Worker.

Ja, aber wozu brauchst du denn da mehrere Prozesse?

Das ist nochmal die Frage, warum mehrere Prozesse an der Stelle?

Gunnycorn macht Workerprozesse auf.

Ja, aber man muss ja nicht, du kannst ja einen aufmachen.

Genau, aber das heißt, das müsste man halt dann als harte Restriktion haben, das geht halt nur mit einem Workerprozess.

Und man hat halt dann unerwartete Seiten.

Du meinst, wenn da jemand, wenn das hier ist,

wenn jemand mehr startet.

Ja, genau, dann stehst du halt dann da und dann funktioniert das halt nicht mehr so richtig.

Ja.

Ja, stimmt.

Nun, die Frage ist, ob man halt so einen Workaround hat für solche Fälle.

Aber was geht ja eigentlich für alle Dinge, die halt irgendwie einzelne Tanzen haben.

Also du hast irgendwie von irgendwas einen Singleton-Pattern oder sowas auf irgendeiner Klasse oder so.

Und das ist ja immer das Problem, dass es halt bei so einem Forken in so einem Web-Applikations-Server-Prozess nicht mehr so wirklich identitär ist.

Okay, aber ich würde sagen, das braucht man ja ganz, ganz selten nur sowas.

Na.

Ist jetzt nicht wohl nicht.

Ich bin ja in letzten Haben ja schon zweimal drüber gestolpert.

Ich hab oder meine Vermutung wäre oft, dann ist irgendwas an dem Problem nicht richtig, weil, oder an der Lösung oder weil, wenn man, also wenn das die Lösung für das Problem ist, dann ist wahrscheinlich das Problem nicht richtig verstanden.

Oder vielleicht ist es, ich weiß es nicht genau, aber das gibt es echt fast nie.

Ja, also als Beispiel, darf jetzt nur eine offene Verbindung zu irgendeinem anderen Rechner geben, weil er nicht mehr als eine gleichzeitige offene Verbindung akzeptiert.

So, und dann könnte man jetzt irgendwie Verbindungen durchreichen und die halt von mehreren Prozessen trotzdem nutzen.

Wenn man die nicht gleichzeitig nutzt, zum Beispiel, wenn er halt dann irgendwie einen Lock drauf hat und dann an der anderen Stelle dann vor einem anderen Prozess halt wartet, bis dieses Log wieder freigegeben ist.

Ja, aber das passiert doch automatisch.

Mit den Logs, ja.

Nein, nein, ich meine, wenn du, ja, wenn du von der Verbindung zu irgendwas ausbaust, was nur eine zulässt, dann musst du halt warten.

Genau, aber das geht halt von den Prozessen her nicht.

Also wenn du da verschiedene Prozesse gleichzeitig das machen zum Beispiel, dann gibt es halt einen Exception-Boom, geht nicht.

Das heißt, du musst das halt irgendwie managen.

Das heißt, du musst halt diesen, also nicht nur diesen State irgendwie dann abwarten und dann wieder wieder versuchen, sondern eigentlich willst du ja quasi dieses Objekt dann durchreichen.

Ich habe das Problem nun, glaube ich, noch nicht so wirklich verstanden, was das, weil ich meine, ja, also ich meine, das ist doch.

Wie willst du das denn lösen?

Das kannst du gar nicht lösen.

Ja, doch, ja, warum?

Also so ein Zugangstoken zum Beispiel, ne?

Den ich ja dafür brauche.

Dann will ich ja nicht unbedingt jetzt jedes Mal irgendwo reinschreiben.

Außer vielleicht in so eine Platte.

Und dann die Frage ist, schreibe ich die halt in, rede es rein, hole mir den immer wieder ab, gucke halt, ob der da ist, wenn es der nicht da ist, dann hole ich mir neu oder so.

Benutze ich den halt immer wieder, ist, weiß nicht.

Das ist halt so ein Prozessding.

Also wie komme ich denn da sonst dran?

Ohne, dass ich dann jedes Mal wieder neu nachfrage.

Also wieso muss das denn geteilt werden?

Also ich würde sagen, wenn du keins hast, dann holst du dir das halt und.

Genau, aber das wurde, ich habe jetzt mehrere Prozesse, ja, und ich habe halt einen Zugangsdoken und beispielsweise darf man Zugangsdoken nur alle so und so vier Sekunden holen.

Oder so.

Sonst kriegt man keinen mehr oder wird geblockt.

Dann gibt es halt so komische Antwort-Server, die sowas machen.

Das ist halt irgendwo zentralhändig.

Genau, ja, genau.

Das Problem, daran stehen wir jetzt.

Was aber auch blöd ist, das willst du ja auch nicht.

Ja, klar.

Sondern das willst du halt, aber ich meine, ist das nicht eher ein Deployment-Problem?

Nee.

Das würde ja sein, weil so gehören solche Sachen eigentlich hin, solche Sachen gehören eigentlich in die Umgebungsvariablen von den Prozessen.

Ja, aber die kann ich ja noch nicht und ich kann ja nicht das also im Deployment dann ablegen, wenn der halt nach zehn Minuten wieder ausläuft.

Das ist ja gerade.

Ich muss ja halt, also ich darf halt nur alle irgendwie fünf Minuten fragen, aber nach einer Stunde ist halt wieder weg.

Oder so.

Und das ist halt blöd, weil ich brauche dann halt alle zwei Sekunden und das ist ja okay, wenn ich mir einmal eine Stunde einholen kann und dann kann ich halt für eine Stunde benutzen, dann ist ja okay, aber ich muss halt von den verschiedenen Prozessen der Anwendung, die parallel laufen, gleichzeitig diesen Key halt haben.

Und dann muss ich irgendwie teilen.

Also klar, ich könnte hier lokal irgendeine File schreiben, was ja auch nicht so eine gute Idee ist, wenn irgendjemand da auch die File-Systeme zugreifen kann.

Das heißt, ich muss dann eigentlich irgendwo den Speicher legen, der geteilt ist, über alle Prozesse hinweg.

Ja, also eigentlich ist das ja nichts, was du irgendwo hin speichern willst.

Ja, also eigentlich dann doch nur in die Datenbank oder so ist halt.

Doch nicht, aber die ist halt wenigstens ein bisschen verschlüsselt, hat wenigstens so ein bisschen noch so ein Layer drumherum.

Ja, oder halt dann in so einem geteilten Memory-Bereich.

Und da ist halt die Frage, wie das dann aussieht, wenn du sagst, okay, ich finde die Idee gar nicht so falsch, dass von verschiedenen Prozessen ja verschiedenen Rechnern liegen können, dann müsste das ja von sowas wie einem Redis oder einem Cache oder so rausgegeben werden, weil das ja quasi auch nur der geteilte Key-Value-Storage, der dann das so irgendwie vergibt.

Tja.

Aber in Python gibt es halt so eine Möglichkeit nicht, okay, dann habe ich nicht mehr.

Ja, aber ich glaube nicht, dass das etwas ist, was man.

Also ja, ich meine, das klingt jetzt blöd, weil das natürlich dein Problem nicht löst, aber ich glaube nicht, dass das etwas ist, was man lösen will.

Also würde ich jetzt.

Ja, also ich glaube tatsächlich, ich glaube, so eine Antwort wäre mit dem Cache-D oder Readest und da muss man halt dann gucken, braucht man das jetzt oder will man das jetzt oder nicht.

Also ich würde sagen, wenn du versuchst, dieses Problem zu lösen, ist die Lösung, macht halt einen Haufen zusätzliche Probleme.

Ja, gut, aber manchmal kann man halt nicht anders sein.

Manchmal kann man nicht anders, ja, dann ist halt so schlecht.

Also wenn ich halt auf der anderen Seite zum Beispiel keine Einflussmöglichkeiten habe, dann kann ich nicht sagen, dass irgendjemand da anpassen.

Ja, ja, klar, klar.

Ja, okay, mit dem Serialisieren, das muss man irgendwie wahrscheinlich im Kopf haben, dass das auch ein sicherheitsrelevantes Problem sein kann.

Aber dann, ja, also als JSON wäre er wahrscheinlich sicher, weil das ja nur irgendwie ein Zeichenketten sind, das nicht ausgeführt ist.

Das heißt, ich muss irgendwie gucken, dass ich alles irgendwie JSON-Serializable mache.

Genau.

Und das heißt tatsächlich, dass ich keine Funktion angeben kann, sondern ich muss eine Funktionpfad oder Import-Fahrt angeben.

Also ich meine, ich habe zum Beispiel sowas, so einen Fall tatsächlich von gerade mit Fast API fällt mir jetzt gerade so ein.

Da habe ich das so gemacht, tatsächlich auch.

Deine Padentik-Objekte, die kannst du ja serialisieren.

Zu JSON, ja.

Aber wenn ich da eine Call Level reinstecke, dann geht das natürlich nicht.

Nee, aber du kannst ja ein neues Objekt erzeugen.

Also du kannst ja das Ding serialisieren.

Ja.

Also nicht immer.

Also das kann ich nur dann, wenn es serializable ist.

Wenn ich jetzt da in Padentik irgendwelche Sachen drin habe, die nicht serializable sind, dann kann ich natürlich mir überlegen, was ich denn mache.

Ja, aber.

Oder muss ich ja meinen eigenen Serializer schreiben für, wenn das dann.

Ja, ja, gut, okay, aber das kannst du ja machen.

Also ich weiß noch, ich hatte das halt ein, ich hatte dieses Problem halt in gewisser Weise auch.

Also ich hatte das in diesem Benchmark-Umfeld, ja, sozusagen, dass man sagt, okay, ich habe hier, ich baue mir zuerst meinen Server zusammen auf einer kleinen Seite, dann schicke ich das Objekt an den Server und der Server startet dann halt irgendwas damit.

Und meine Lösung, also sozusagen, du hast halt in den Pydentech-Modellen sind halt die Daten für das Ding drin, aber ausgeführt wird es dann woanders.

Dann rufst du halt das Ding mit den Daten, die du serialisiert hast, auf und sagst halt so, und jetzt starte mal oder so.

Ja, das geht schon.

Also wenn das Pydentec-Modell das hinbekommt, das zu serialisieren, dann geht das auch so.

Aber das Problem ist halt die Serialisierung von Callabils in JSON-kompliktibles Format.

Das halt da hinzubekommen, da muss man halt dann deinen Serializer und D-Serializer für extra verschreiben für diese einzelnen Felder und ist dann die Frage, wie man so ein Objekt serialisiert.

Und da stehe ich halt wahrscheinlich gerade, vielleicht habe ich das noch nicht gemacht, weil ich nicht weiß, wie ich so ein Pfad zu einer Funktion dann.

Ich kann ja mal gucken, also ich habe da auch tatsächlich so eine Art Registry verwendet, wo man dann halt einfach sagen, ich habe das dann so gemacht, wenn man einen Dekorator nicht klasseregen konnte, dann konnte man sagen, okay, registriere das Ding mal und dann konnte ich quasi das halt wieder komplett so aus dem raushauen.

Ja, ja, aber genau, das kann ich mal drauf gucken.

Ah, das hat tatsächlich, man müsste dann quasi diese einzelne Funktion dann quasi selber registrieren.

Das könnte man ja mit dem Dekorator machen, der eh schon da benutzt wird, für Subscribe und dann könnte man die quasi gleichzeitig durch das Subscribe mit in diese Event-Registrie registrieren unter irgendwas.

Oh ja, und das, dieses, was dann dabei rauskommt, das könnte man in das Patentic Model mit reinschreiben, rauspolen und dann auch quasi eine Methode dran schreiben, die dann diese Funktion ausführen kann.

Wow.

Können wir ja gleich mal sagen.

Ja, so ein

bisschen gepopel, aber ja, das ist das Schöne.

Genau, ich habe letztens für dieses, also was ich gerade in einem Stream baue, ist halt irgendwie das Hosting-Ding für eben den Podcast ja auch.

Ich würde da gerne so eine Software-As-A-Service-Lösung draus bauen.

Und da habe ich so ein Spam-Filter-Dings für gebaut.

Spam-Filter-Feature habe ich letzte Woche vorletzte Woche, letzte Woche, diese Woche, ein bisschen dran gearbeitet.

Und da ist auch so ein Ding.

Das fand ich ganz auch so ähnlich, auch ganz interessant.

Also ich möchte ja natürlich meine Spam-Filter-Modelle auch irgendwie in die Datenbank serialisieren.

Und Postgres hat meiner JSON-Field, das ist ja voll gut.

Aber da habe ich ja jetzt das Problem, okay, ich möchte jetzt ja nicht irgendwie JSON daraus haben, sondern ich möchte hinterher das fertige Modell, auf dem ich dann Predikt aufrufen kann, aus der Datenbank bekommen.

Und da habe ich das auch mit Custom Serializer, Deserializer gebaut, den man dann beim JSON-Field angeben kann.

Da kann man sagen, das ist der Decoder, das ist der Encoder.

Und der Decoder, also der Encoder guckt halt, ja, wie war das?

Ne, der guckt halt, äh, was ist das?

Und dann ruft er halt irgendwie die, gibt mir halt mal halt ein Dikt zurück Methode von einem so ähnlich wie bei Pendentic ist es.

Bei Pythonic ist, glaube ich, auch Punkt Dikt, was man aufgibt.

Und das habe ich dann auch halt quasi genauso gemacht, dann Punkt Dikt und dann kommen dann halt irgendwie Daten aus diesem Modell zurück.

Habe ich dann ins JSON reingeschrieben und beim Dekodieren guckt er halt, okay, gibt es da ein Attribut Klasse drin, Klass, und wenn das Knife-Base ist, dann mach halt Spezialbehandlungen und sag nochmal irgendwie übergib dieses Dikt, was in JSON war, halt als Dikt für diese Klasse und mach dann halt ein echtes Modell draus, wo ich dann hinterher Predict drauf aufrufen kann.

Und dann fällt das gar nicht auf.

Dann sagt man halt im Code einfach nur Spamfilter.predict irgendwas.

Und Spamfilter ist halt die Tabelle in der Datenbank.

Model ist halt sozusagen dieses JSON-Field.

Und dadurch, dass das ein Custom-Deserializer hat, wenn man darauf zugreift auf dieses Attribut, wird es halt dieser realisiert und ist dann halt das richtige Modell wieder.

Das heißt, man kann sagen, also man kann zum Beispiel sagen, Spamfilter.objects, jetzt setzt Django Semantik, Spamfilter.Objects, Punkt First, PunktModel, Punkt Predict und dann übergibt man irgendwas einen Kommentar oder so und dann sagt einem das Spam oder nicht Spam.

Ohne dass man da irgendwas machen muss.

Das funktioniert

einfach so.

Und du hast da quasi ein fertig trainiertes Modell, hängst du dann quasi per JSON dann in das JSON-Feed rein?

Genau, also ich würde es zuerst trainieren und dann sagen, ja, speichere das doch mal.

Also Model ist gleich naiv, ist halt das fertig trainierte Model.

Und dann sage ich halt Spamfilter.model gleich naiv-base.

Also das würde ich sagen, Model gleich naiv-base, irgendwas.fit, irgendwann Trainingsdaten.

Und dann sage ich halt spamfilter.model gleich Model und dann sage ich es beim Filter.save und dann ist es eine Datenbank.

Nett, nett.

Und genau, das, also da ist es auch so ein ähnliches Problem.

Ja, das ging eigentlich relativ problemlos.

Ja.

Und überhaupt bei Knife Base voll gut.

Ja.

Ich habe das am April, glaube ich, irgendwann mal auch in die, weil die Kommentars bei mal, also die ganze Zeit lang, also bis letzten, bis Anfang letzten Jahres oder so, haben sie es nie irgendwie, war das nie ein Problem, weil irgendwie, ja, wahrscheinlich diese CSRF-Protection oder keine Ahnung, was auch immer, Django Dam halt an Dingen macht, die verhindern sollen, dass man da beliebig Dinge reinpostet, schon dafür gesorgt haben, dass die Kommentare später mal draußen geblieben sind.

Irgendwann sind deren Skripte halt besser geworden.

Kommen halt mit diesem Kram klar und nehmen halt das Token dann aus dem GET und packen sie in den Post rein und dann kommen sie halt durch.

Weil wir haben da ja auch keine Authentifizierung oder sowas.

Jeder kann da Kommentare reinschreiben.

Aber wenn man das halt über ein Skript macht und nicht beim Browser, dann fehlen halt vielleicht Daten, die man mit angeben muss und dann sagt Django direkt, nee, nee, so nicht.

Aber sozusagen, wenn man es halt mit einem Headless-Browser macht oder mit einem Skript, das ein bisschen besser ist und das halt weiß, wie diese Formfelder heißen und so, dann geht es halt doch.

Also was man auch, glaube ich, ganz gut machen kann, ist so ein Feld A-Fiden einfach reinmachen, das halt dann mit im Formular drinsteht, was halt automatisch über das Skript ausgefüllt wird und was halt, wenn es halt sowas drinsteht, dann sagt er halt der A-Spam.

Ja, das kann auch, das kann auch sein, dass man, das habe ich mir auch zuerst überlegt, weil das wäre dann die super simple Methode gewesen, dass erstmal alle, dann hätte sich jemand das Skript eddern müssen für diese Seite und das macht dann natürlich keiner.

Aber ich bin mir gar nicht so sicher, ehrlich gesagt, also auch gerade wenn ich mir angucke, wie das Muster von den, also das hatte ich mir auch zuerst überlegt, dass das vielleicht die einfachste Lösung für das Problem ist und dann habe ich mir aber das ein bisschen angeguckt und dann, ich habe so den Verdacht, dass das gar keine Skripte sind.

Da gehen Leute tatsächlich mit Browsern drauf, die halt das irgendwie dafür bezahlt werden, dass sie das machen und machen das von Hand.

Und da hilft das natürlich alles nicht mehr, weil sobald da jemand mit einem Browser drauf geht, dann ja.

Ja.

Und ja, also, und dann dachte ich mir so, okay, also das sieht schon verdächtig danach aus, dass das irgendwelche Leute sind, die da tatsächlich für bezahlt werden und das von Hand machen, dann kann ich mir das auch, äh, dann hilft das nichts.

Dann mache ich es auch gleich richtig und nimm dann baue da halt so einen richtigen contentbasierten Spam-Filter ein.

Und genau, Django, weiß ich nicht, Fluent Commands oder so hat halt auch so ein Schnittstelle drin für Archismit oder so, weiß nicht, dieses Spam-Filter-Dings, aber das ist alles ganz furchtbar, das darf man auch, glaube ich, alles gar nicht so richtig verwenden.

Weil das, weil man damit ja dann Daten weiterreicht, dann ja, also ist es, äh, das ist alles sehr unschön und man kann das aber relativ leicht selber bauen.

Und dann, äh, eben, und Naith Basis bietet sich da halt an, weil das halt keine Abhängigkeiten zu irgendwas anderem.

Sondern das kann man halt rein in Python mit Standardbibliotheksmitteln irgendwie alles machen.

Und ich habe da auch mal eine Streame-Episode nur darüber gemacht, weil das kann man in anderen Programmiersprachen genauso machen.

Das kann man an einem PHP ganz genauso machen.

Das kann man halt irgendwie, egal was man verwendet, kann man das relativ einfach implementieren.

Es kommt mit wenig Trainingsdaten aus, ist es schnell.

Ja, es ist wahrscheinlich für diesen Fall Spam nicht-Sperm, weil die Klassen gut getrennt sind, ist es gut genug.

Also es ist natürlich, wenn man das vergleicht mit anderen Sachen nicht so gut wie andere Dinge, aber in dem Fall ist es vielleicht egal, dass es nicht so gut ist.

Jedenfalls bei, das hat jetzt halt auf den Dingen hat es jetzt praktisch perfekt funktioniert, mehr oder weniger.

Also es ist halt kommt kein Spam mehr durch.

Und die ganzen regulären Sachen kommen halt doch durch.

Also es funktioniert tatsächlich ziemlich super.

Ja, genau.

Ja.

Cool.

Ja, da müsst ihr euch unbedingt Jochen Stream Tablet verlinken vielleicht.

Ja, genau, also die entsprechende Folge auf jeden Fall wäre super.

Ich würde die nämlich auch nochmal sehen.

Ich bin, glaube ich, einmal ausgestiegen, als du dann irgendein Update gemacht hast von Jupiter oder so.

Ja, ich bin da ja, ich weiß ja auch oft nicht, was ich da vorher mache.

Kram halt da.

Tja, wie es halt so ist, wenn man täglich seine Arbeit filmt.

Irgendwas passiert nicht immer so die ganzen mega spannenden Sachen.

Ja, aber doch.

Ja, ja.

Ja, also das mit dem Naiv-Wiss, das finde ich sehr spannend.

Vielleicht ist es eigentlich fast schon eine eigene Folge wert, wie man eine Naip bei

hatten wir schon tatsächlich.

Wenn es bei Filter?

Ja, wir hatten schon eine Naiv-Base-Folge, glaube ich mal, irgendwann.

Das ist jetzt schon ein bisschen was her, aber.

Ja, stimmt.

Ja, ich glaube, Machine Learning-Folgen hat er bei eh noch ein paar mehr nachgefragt.

Vielleicht müssen wir da nochmal.

Ja, da müssen wir sowieso.

Wir müssen mal Struktur und ein Konzept überlegen, die auch noch weg wird.

Ja, also was das auch auf jeden Fall auf dem Plan ist, ist HTMX, das wird jetzt auch nochmal einmal fand ich interessant zu sehen, dass das halt, wenn man sich anguckt, welche Talks sind eigentlich so populär quasi, kann man ja auf YouTube so ein bisschen sehen zum Beispiel auf Konferenzen.

HTMX super.

Ja, HTMX macht auch Spaß.

Also ich habe es, glaube ich, auch schon mal einmal so Spaß halber gebaut.

Ich glaube, da ist noch ein kleiner Bug drin beim Posten von dem Formular, die Validierung geht doch nicht richtig durch, aber sonst müsste man eigentlich mal veröffentlichen.

Ich habe so ein Minimum-Beispiel auf Django gebaut auch.

Ja, ja, ja.

Es gibt ja auch Django HTMX.

Adam Johnson hat es, glaube ich, gemacht.

Super.

Ja, also da muss ich auch mehr mitmachen.

Ja, vor allen Dingen ist es halt wirklich so, das, was einen halt bei Django-Templates insbesondere nervt, ist halt so die Reaktivität der Templates, die halt eigentlich nicht da ist.

Sondern du hast halt jedes Mal einen neuen Request und musst halt dann hingehen und musst immer komplett die ganze Seite nur abholen, was natürlich beim Nutzer einmal Plack hat und was halt irgendwie anzuschauen.

Musst du halt nicht unbedingt, ja genau.

Und mit HTMX ist es halt relativ einfach implementierbar, dass du es halt genau das nicht musst, sondern dass du halt Teile einfach validierst und halt dann tatsächlich gleich Feedback anzeigst für Formular, Varalidierung oder was auch immer man da haben möchte.

Genau, und der Weg, wie man das früher gemacht hat, üblicherweise ist halt jQuery oder sowas oder halt irgendwie, weiß ich nicht, heutzutage nimmt man dann eher so Alpine.js oder PTV oder so.

Aber das Problem dabei ist natürlich, dass sobald das dann halt komplizierter wird und sobald man dann halt irgendwie sowas macht, also was ich ja gerne hätte, ist ja irgendwie, dass auch Pagination darüber funktioniert, man dann so weiterklickt und das halt so schnell ist wie bei einer lokalen App oder so, das ist halt dann doch eher, da ist man dann schon eher schnell im Single Page SPA-Land unterwegs.

Aber genau, und ich dachte bisher immer, und mit jQuery und so wird das State Management dann halt auch irgendwann, wenn es komplizierter wird, sehr, sehr hässlich.

Und ich dachte immer so, naja gut, okay, da muss man halt doch SPA machen.

Aber ich glaube tatsächlich HTMX ist vielleicht tatsächlich eine Lösung.

Ich weiß es noch nicht genau, weil ich habe es noch nicht ausprobiert, aber.

Ja, wir müssen ja mal ein bisschen ausbauen, dass das so ein bisschen voll.

Also die ein bisschen einfacher wird von der Anwendung her, dass man vielleicht noch ein paar eigenen Template-Tex für sowas nimmt oder sowas.

Ist ja natürlich besonders toll, aber.

Ja, bin ich auf jeden Fall gespannt.

Also diesen Trend gibt es ja jetzt auch schon einige Zeit und der gefällt mir tatsächlich sehr gut.

Also da würde ich sagen, es ist ja super, wenn das ein bisschen mehr in die

Richtung macht.

Dass man wieder mehr Server, ja, es sind halt immer so Hype-Cycles, macht alles auf dem Client, oh nein, mach alles vom Server.

Ja, bald, wenn das halt mit The Rust, auch bei Python mit Web im Browser geht, dann können wir auch das wieder beim Client machen.

Ja, ich meine, ich würde ja sagen, eigentlich macht es schon Sinn, viel auf dem Server zu machen.

Eigentlich ist der Terminal, eigentlich brauchst du eigentlich nur eine Tastatur und der Rest ist auf dem Server.

Das einzige Problem ist, wenn die Verbindung abbricht, da muss man halt irgendwie gucken, was dann übrig bleibt, aber ja.

Naja, aber finde ich, finde ich cool, auch interessant, ich habe jetzt so ein bisschen auch mal bei Ruby und Rails gehört, so ich meine, ich würde ja sagen, diese beiden großen oder so, tatsächlich Ruby und Rails ist halt eher so das große Webframework Batteries Included Ding.

Fand ich jetzt auch mal ganz interessant.

Also ich habe jetzt auch irgendwie mal was drüber gelesen, was das alles so kann.

Ich glaube, ich habe auch letztens irgendwo eine Podcast-Episode dazu gehört.

Shownote.

Ja, genau, wieder reinfahren.

Und das kann halt tatsächlich, glaube ich, noch ein bisschen mehr als Django.

Aber Django ist halt immer so das, was man dann auch nennt.

Also Django ist so ähnlich.

Aber zum Beispiel, was er, was ich nicht wusste, was er, so Ruby und Rails hatte schon immer so eine relativ ausgefeilte Asset-Pipeline drin.

Bei Django gibt es sowas so ein bisschen, so mit Django Kompressor oder manchmal, also so ein bisschen gibt es Ansätze, aber nicht mal Ansatz vergleichbar mit dem, was Ruby on Rails da macht.

Und Ruby and Rails hatte da so Dinge, da hat sogar Webpack dann am Schluss eingebaut und jetzt sind sie nochmal irgendwie auf was anderes umgestiegen.

Und da war das ja auch so lange so, dass CoffeeScript verwendet wurde, halt für die ganzen wirklich Front-end-Front-end-Teile und das wurde dann halt aber alles automatisch gebundelt und so und in JavaScript transpiliert und so.

Also, das ist ein Teil, wo Ruby and Rails halt nochmal echt mehr Zeugs hat als Django, würde ich sagen.

Und dann ein auch wichtiger Teil, und da dachte ich so, okay, das ist tatsächlich vielleicht etwas, das ist ja auch sowas, das kann man auch mal muss sich einfach Ruby and Realth angucken und dann vielleicht Dinge in Django nachbauen oder so.

Das fehlt in Django, ist sowas wie so ein Job-Queue-System.

Und zwar gar nicht so, also ich habe mich ja auch schon oft über Salary geärgert und so.

Django Background Task

oder so.

Ja, genau.

Es gibt ja ja dann auch diverse Django Q, es gibt R-Que für diese Redis-Queue-Geschichten, dann gibt es aber auch noch UI oder weiß ich nicht, es gibt noch diverse andere.

Es gibt halt irgendwie zig unterschiedliche Q-Systeme.

Und gut, denkt man sich, oh gut, muss ja nicht unbedingt in Django selber drin sein, ja, wozu auch.

Es gibt ja genug Auswahl, damit man halt irgendwie was am besten gefällt.

Aber der Punkt ist eigentlich bei Ruby und Rails ist es halt drin.

Da gibt es halt, da nennt es sich, glaube ich, Action-Job oder irgendwie so, ich weiß es auch gar nicht genau.

Und das eigentlich Witzige daran ist, dass das halt so ein Ding ist, das ist so ein Interface in Ruby und Rails selber.

Genauso wie es da auch so eine Abstraktion gibt für File-Systemzugriff oder für Files irgendwie.

Und das gibt es ja in Django auch.

Django hast du ja auch irgendwie Default-File, wie heißt das?

File-Storage, Default-File-Storage oder so kannst du setzen.

Und dann implementierst, ist egal, was du verwendest, ob du irgendeinen Object Store verwendest oder das File-System oder was auch immer.

Wenn das halt, es muss halt diese API anbieten und dann kann dahinter liegen, was will, aber du kannst es halt benutzen.

Du hast halt innerhalb von Django ist es immer das gleiche Interface.

Du kannst halt immer Files irgendwie, du kannst auch denen lesen, kannst sie schreiben und so.

Oder wie Cash, ne?

Cash-Backend, ja, genau.

Genau, oder Cash-Backend, ne?

Du kannst hinterher, du kannst hinterher das Cash-Backend austauschen, aber dein Applikationscode muss sich dafür nicht ändern.

Und das kannst du mit diesem Jobkram halt dann auch machen.

Und das ist eigentlich, ja, in der Ruby und Rails-Welt gibt es halt viele Dinge, die dann darauf aufbauen, dass diese Interfaces halt so sind, wie sie sind.

Und das heißt, du kannst halt Third-Part-Party-Packages oder so bauen, die halt dann irgendwie deine Tasks in diese Queue schmeißen und da irgendwie, und sie müssen nicht wissen, welche Implementation du da verwendest.

Ob das jetzt RabbitMQ ist oder was ist ja der Teufel, das ist halt alles hinter diesem Interface versteckt und spielt dann auch keine Rolle.

Und diese Geschichten gibt es halt in Django gar nicht, weil es dieses einheitliche Interface nicht gibt.

Das heißt, wenn ich in Django sowas machen wollte, dann hänge ich halt ab direkt von Celary oder von sonst irgendwas, weil es gibt nicht irgendwie das, ja genau, Django Background Task Interface.

Sondern das ist halt, ja.

Ja, das will ich tatsächlich noch.

Und da dachte ich so, okay, ja.

Und an Lindstein hat Real Wells auch noch so ein bisschen mehr Zeugs.

Ja.

Ja, ja, auch HTMX kommt da ja daher und diverse andere Geschichten.

Ja.

Und sie haben irgendwie für ihren ORM, da kann man, das kann man auch, also normalerweise Default ist relationale Datenbank, aber man kann halt auch MongoDB direkt dranhängen.

Ich dachte so, wow, krass, wie haben sie das denn?

Weil das ist auch immer ein Ding, was in Django requestet wird, dass Leute sagen, ich hätte gerne ein MongoDB.

Kann ich jetzt ehrlich gesagt gar nicht so richtig verstehen, warum.

Müssen wir vielleicht mal, wenn irgendjemand weiß, warum MongoDB cool ist, wir das erklären oder uns mal schreiben, warum das toll ist, weil sagen so, Gott, also verstehe ich gar nicht, warum nimmt man das, aber offenbar gibt es da einen großen Bedarf.

Und das geht halt in Django nicht so richtig.

Aber könnte man sich auch vorstellen, wenn es halt ein.

Dann sag doch mal ganz kurz, warum du das denn doof nest als Wahl oder was.

Das heißt doof.

Ich würde nur sagen, ja, also JSON-Field in Postgres ist schneller.

Ist schneller als MongoDB und ja.

Mehr braucht man nicht auch so.

Und es kann halt zusätzlich noch die ganzen relationalen Geschichten.

Also wozu dann MongoDB?

Also kann halt MongoDB ist ja quasi nur das JSON-Field.

Und kann halt die relationalen Dinge nicht.

Aber die relationalen Features brauchst du ja eigentlich auch.

Und die ganze Transaktionssicherheit und den ganzen Isolationslevel und weißer Teufel, den ganzen Kram willst du eigentlich auch haben.

Naja, also irgendwie, keine Ahnung warum.

Ja, vielleicht auch, wenn man halt sagt, okay, man halt es irgendwie vereinheitlicht und es gibt halt nur MongoDB, ne?

Und jetzt kommt damit klar.

Es kann es halt gar nicht einfach irgendwie was anderes machen.

Okay, ja, dann ist es halt so.

Ja.

Ja, ich finde, wir haben jetzt eine sehr, sehr bunte Folge gehabt.

Ich glaube, es wäre relativ schwierig, uns zu folgen.

Ich hoffe, ihr habt es zum Ende durchgehalten.

Vielleicht habt ihr das ja irgendwie geschafft.

Haben wir noch irgendwas?

Nee, ansonsten.

Achso, einen Pick der Woche, ich glaube, ich habe das schon tausendmal.

Doch, ich hab, also was ich ganz cool fand, habe ich letztens auch eingebaut.

Django Upgrade gibt's.

Es gibt ja für Python, glaube ich, hat Anthony Sotil irgendwie auch irgendwie so ein Ding geschrieben.

Python Upgrade oder so, ich weiß es nicht genau, wie das Paket heißt.

Und so ähnlich gibt es das jetzt auch für Django, wo dann halt sozusagen das.

Die neueste Syntax und die ganzen deprecated Sachen ersetzt werden, automatisch durch die besseren.

Ja, ja, und das habe ich dann halt als Priko-Method irgendwie eingebaut, sodass dann halt immer, wenn halt Sachen deprecated werden oder wenn es eine bessere Art gibt, das zu machen, das wird dann halt automatisch ersetzt und ich muss das nicht irgendwie von Hand machen.

Ja.

Das war nice.

Und das ist ziemlich, naja, das ist ziemlich nett.

Das ist auch von Adam Johnson, glaube ich.

Ja, was nehme ich denn?

Ja, ich habe ja die ganzen Sachen Fast CQM-Bordel habe ich ja schon gesagt.

Habe ich auch schon mal Rich erwähnt, eigentlich irgendwo.

Ja, das habe ich ja auch schon mehrfach gehabt.

Habe ich bestimmt schon mal als schon.

Ich nehme es einfach nochmal.

Ja, das ist auch wirklich toll.

Da gibt es auch jetzt irgendwie Textual oder so irgendwie.

Der Autor von Rich und Textual, der macht jetzt auch, der probiert das irgendwie Open Source zu entwickeln, quasi.

Und versucht jetzt davon irgendwie, damit irgendwie klar zu kommen, damit durchzukommen, seine Projekte zu entwickeln.

Und das fand ich auch faszinierend.

Ja, ich bin mal gespannt.

Das ist ja auf jeden Fall sehr populär, was er macht und es ist ja auch super.

Und ich hoffe mal, das gehabt.

Das wäre irgendwie toll, wenn das irgendwie passiert.

Also falls ihr nicht wisst, was das ist, which macht ein bisschen Farbe in euer Commando-Output.

So ganz, ganz nett.

Oh, ich benutze das gerne mit Humanize, vielleicht noch ein nächster Pick, falls ich schon mal gepickt habe.

Also Humanize macht auch sowas wie Zahlen oder vor allen Dingen Daytime-Objekten irgendwas vor drei Sekunden oder vor kurzer Zeit und man kann so ein bisschen definieren, dass das irgendwie nett sich anhörte.

Ich mag das irgendwie ganz gerne für ein, zwei Dinge.

Ein bisschen Human More Readable Logs oder sowas.

Ja, klingt gut.

Ja, die hatten Richard tatsächlich, ich habe es gerade gesehen, gar nicht so lange her.

Eine Packaging-Folge.

Na, jetzt haben wir Humanized dabei.

Okay.

Okay.

Ja, dann bleibt es gewogen, hört uns weiter, wann ihr wollt.

Und bis zum nächsten Mal.

Dann, bis zum nächsten Mal.

Tschüss.