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, Ferienfieber und so weiter, was man nicht alles kennt.
Ja.
Der alte Wahnsinn.
Ja, genau. Herzlich willkommen Dominik auch zurück. Bist du sicher, dass das Folge 35 ist?
Ja, das ist ein bisschen schwierig zu sagen.
ein bisschen Track.
Du hast verloren. Das ist übrigens Jochen.
Hallo.
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, die haben irgendwann mal gesagt,
sie hätten gern die Episoden-Nummer 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...
Letztens hatten wir 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 Mixed-Folge.
Also ein bisschen über Python
wollen wir erzählen, drei Zehnen und so.
Genau, da muss man ja eigentlich was zu sagen.
Genau, und vielleicht noch über
die alten Neuerungen, die es so gab.
Und dann wollen wir noch ein bisschen über
Shared Memory von
Python-Prozessen sprechen vielleicht.
Ja, je nachdem, wie viel uns da einfällt.
Oder sonst so Dinge.
Andere Dinge auch.
Bist du noch nicht so genau. Mal schauen.
Ja, wir müssen uns wieder strukturierte Formen kriegen,
aber das haben wir bisher noch nicht hinbekommen.
Ja, genau.
Ja, bevor wir jetzt mit Python 3.10 anfangen,
was haltet ihr eigentlich von Werbung?
Wir verhalten, wir verhalten das an einem bestimmten Grund.
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 dazu ein bisschen Feedback gebt,
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 davon überzeugt.
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 mir ein Schloss, Jochen.
Wann das wieder reinkriegen könnte oder so,
keine Ahnung, muss man mal schauen.
Ja, das ist auch so ein Thema, genau.
Ja, ich warte nur
darauf, dass ich wegen dem Podcast ein Schloss
ziehen kann.
Ich glaube, da wirst du noch ein bisschen warten müssen.
Das wird noch etwas dauern. Ich habe Zeit.
Ja.
Wir lieben verlängerte Maßnahmen.
Tja, genau. Wollen wir so ein bisschen News
machen? Dann könnten wir mal wieder...
News, ja.
Also am Montag kam
Python 3.10.0 heraus.
Ja. Also letzten Monat, also am
4.10. Voll gut, genau.
Und dazu gab es auch so ein
Release
Stream irgendwie, fand ich auch nicht.
Oh, den habe ich nicht gesehen.
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 mal reingucken, einfach um
die Leute zu sehen, die das machen. Das ist vielleicht ganz interessant.
Die hatten auch lustige Hüte auf. Das ist auch
super. Oh, cool.
Genau. Ja, und
das war auch ganz witzig.
Ja, es war eine komplizierte
Geschichte, so ein Release.
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 zu kaufen?
Ja, ich benutze schon relativ lange,
jetzt fast zwei Monate, also den Rescandidate, der so dann
draußen kam, habe ich auch schon dann
daily benutzt und habe so ein bisschen gemerkt, was da
ging, was nicht ging. Direkt da, also ich
muss den ja meistens oder oft unter Windows
benutzen, leider, aber
ja, da gibt es halt ein großes Problem mit Pybin32,
das kann man aber relativ einfach
fixen, wer 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, dann Release Candidate, weiß nicht, mal installiert,
mal so ein bisschen zu gucken.
Oder ich glaube, 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
nämlich gerade... Ja, das sind ja so die Hauptfeatures,
das Structural Pattern Matching und
die Typing-Syntax so ein bisschen
angepasst und so.
Na gut, also deswegen frage ich, wie man es sieht.
Also ich glaube,
so ein bisschen
kontrovers.
Aber klar, ich kann schon verstehen,
warum man die als die wichtigsten neuen Features
klassifizieren würde.
Ich glaube, das positivste
Feedback haben
die verbesserten Fehlermeldungen bekommen.
Und das ist tatsächlich super.
Die werden sogar mit 3.11 noch ein bisschen schöner.
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, also bisher ist halt, wenn man da irgendwo
eine 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
wo der Interpreter dann halt drüber fällt.
Aber genau, und
jetzt ist es halt besser. Und das ist
halt auch alles konsequent.
Sogar unterkringelt jetzt richtig die Stelle, an der es ist,
mit den Numbers und so, ein schönes Debugging.
Das ist von einem Pack-Parser, der jetzt da neu ist,
und mit dem kann man einfach mehr machen.
Ja, weiteres Feature,
was halt dem neuen Parser
sozusagen,
der dafür zuständig ist,
ist das jetzt in, das ist auch eher so eine
Randhässlichkeit, aber das ist halt
schon komisch, wenn man diese
Limitierung irgendwie, wenn man
auf die gestoßen ist, dass
in Context-Manager, also wenn man sagt
with irgendwie Context-Manager as irgendwas
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
Context-Manager und
dann irgendwann kommen
dann 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 Klammer dort
nicht funktioniert, dann hat man irgendwann
so ein Problem. Das geht ja jetzt gar nicht mehr
so richtig. Hässlich wird das.
Es wird dann sehr hässlich.
Und das geht jetzt.
Mit Klammern, sodass man mehrere
Zeilen verwenden kann und halt auch mehrere
in einem Dings, sodass man das halt
quasi, wenn man viele
Context-Manager
benutzen möchte, das kann man jetzt einfach
in eine Zeile schreiben,
beziehungsweise halt untereinander.
Ja.
Es sind wahrscheinlich nicht so viele Leute
drauf geschossen auf das Problem, aber
ja, genau.
Manchmal macht das schon Sinn. Also wenn man das schachteln will,
könnte man das auch anders lösen, indem man Dekoratoren verwendet
oder so, aber...
Ja, aber ich meine, 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.
Meistens hat man ja nur so ein, zwei Dinger,
die man machen möchte.
Also in diese Verschachtelung,
oder dass es blöd wurde, ist mir dann
die einzige Male, wo mir das mal passiert ist,
das irgendwie ist halt, wenn ich
in Tests mehrere Sachen,
also wenn ich da mehrere Sachen
wegmocken will oder wegpatchen will
und teilweise
kann man das halt, kann man ja auch im Dekorator machen,
manchmal geht das auch nicht, weil das basiert halt auf anderen Sachen
und dann muss man das halt im
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 man das praktisch
jemals irgendwie begegnet ist, ansonsten.
Ne, 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 Strich?
Die Pipe. Pipe-Operator, ja. Genau.
Den kann man halt jetzt verwenden als Type-In
zwischen einem Oder-Zeichen, einfach sagen,
es ist ein Dict oder ein List, der wartet, dass diese
Funktion, da 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 ein Union
draus machen. Ja, ja, das 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. Will ich auch noch 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 Formen von
Syntax, die man da verwenden kann und bis welcher
Python-Version 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 verwenden kann.
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 Schritt in die richtige, sehr richtige Richtung. Sieht auch gut
aus. Was mich halt noch so ein bisschen
nervt, ist halt so, wenn du zirkuläre Abhängigkeiten
hast oder sowas.
Das passiert halt bei Typing relativ schnell
und das ist noch 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 und dann hat man einige Types, die
als Klassen definiert sind und einige als Strings.
Das ist auch irgendwie hässlich.
Und naja, da wollen sie aber irgendwie dran arbeiten.
Aber ich weiß noch nicht genau, wann das eingeführt wird.
Dass man das halt einfach da 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 Kompilieren.
Okay, auch interessant, ja.
Also das heißt, 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.
Je nachdem, ob man Type-Hints überhaupt mag.
Genau, deswegen, also ich meine, ich würde sagen, eben das ist halt durchaus eine durchaus kontroverse Geschichte, weil es gibt halt auch viele Leute, die finden das gar nicht gut.
Ja, man ist halt nicht persönlich, ursprünglich, da gab es das halt nie.
Und ja, ich kann es so ein bisschen nachvollziehen auf der anderen Seite. Also ich glaube, ja, 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
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
es ist schön, wenn ich in der
IDE sozusagen die, also
sozusagen, wenn die IDE
das verwenden kann, um
mir zu helfen, aber
wenn ich sowieso, wenn das die Libraries,
die Verwender tun und brauche
ich das sozusagen für meinen eigenen Code, den ich nicht
quasi nie aufrufe, brauche ich das ja gar nicht.
Oder der halt nur
verwendet wird, um halt irgendwas
zu tun. Das ist halt irgendwie da. An der Stelle
brauche ich es bis jetzt nicht, ob ich es wirklich
brauche. Also ich mache wahrscheinlich auch im Moment zu
viel Hints, also weil es gerade irgendwie ein bisschen noch
reiner als weniger. Aber ich finde das halt schon
sehr praktisch, wenn ich halt wirklich
das Objekt quasi schon so
getitlet habe, dass ich halt weiß, was für ein Objekt
ich da in der Funktion der Hand habe, weil das
so getitlet 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 nennen, dann weiß man halt, was hat man
denn da in der Hand und das ist irgendwie, also
A, natürlich vom 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 Features entwickle
und wieder irgendwie so einen kleinen Teil baut und was meint
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 das 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 mir so oft aufgefallen, dass irgendwo,
wenn man dann mal die Type-Ins dann
reingebaut hat in so einen Code, der irgendwas war komisch
irgendwie von einem 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 None rausgefallen oder sonst irgendwas
und solche Sachen, die sieht man halt durch die Type-Ins
einfach deutlich schneller und deutlich häufiger.
Ich meine, klar, wenn man sowieso ein so super
Coder und Programmierer ist wie du, lieber Jockner,
Ich würde sagen, dass das echt, also mir hilft es
vielleicht, 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 in diesem ganzen Typing
das Ding, also alles auf so Interfaces aufzubauen.
Ja, dass du halt 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.
Also, genau, was ich total, also gerade mit FastAPI zusammen, was ich total super finde, ist, dass man 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 dein Datenbankmodell ein paar Spalten weg oder sowas und kannst es halt einfach dann als Modell einmal definieren und kannst es als Response-Modell ausgeben und das ist alles dann mit drin.
Das ist schon sehr nice.
Genau, und das funktioniert einfach alles so magisch.
Oh, FastAPI, kennst du das SQL-Modell?
Das ist auch von Sebastian Ramirez und da macht er quasi einen Rapper noch um Pydentic und SQL Alchemy rum und baut das alles zusammen in eine Klasse rein, dass man halt nicht mehr so viel Duplicated Code hat und gleichzeitig irgendwie SQL Alchemy Modelle und Pydentic Scheme nachschreiben muss.
Ja, ja, das ist eine Frage, die ich mir, ich habe irgendwann, ich weiß nicht, wenn ich, war es auch schon über ein Jahr her, als ich zum ersten Mal angefangen habe, so ein bisschen mit FastAPI rumzuspielen, dann dachte 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 Pidentic Modell, damit man es rausrennen kann, sozusagen.
Und mit dem neuen TKM, wo du sagst, einfach table gleich true und das ist wirklich echt angenehm.
Ja, und da dachte ich schon, das ist aber blöd,
dass man das zweimal 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.
Ich glaube, ich fange jetzt,
ich nehme mir noch mal dieses Deployment-Dings,
was ich mal auch, wann habe ich das gebastelt?
Das war auch ungefähr
letztes Jahr um die Zeit, ein bisschen
später noch mal vor
und dann mache ich das noch mal mit FastAPI,
Vue.js und vielleicht
mal mit SQL-Model.
Ja, also was
was mir noch so ein bisschen fehlt, ist das letzte, so ein paar
von den SQL-Alchemy-Features, sowas wie Unique
Constraints oder so, habe ich aber vielleicht auch
noch nicht rausgefunden, wie das gut geht. Ich glaube, man kann das
so mit SQL-Alchemy
extra Quarks machen oder so, aber
ja. 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
Alembic, glaube ich, die heißen da, wie heißt das?
Nicht Migrations, sondern Revision
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 auch schon lange, das verwende ich jetzt auch seit über
anderthalb Jahren schon. Ja, das verwende ich sogar auch mit Django,
aber... Ja, verwende ich auch mit Django, genau.
Ich verwende das dann meistens mit Poetry zusammen.
Genau, ja.
Und dann, genau, gibt's halt,
da kann man Scripts definieren und
dann sind die halt, ich meine,
ich weiß noch nicht, ob das so hübsch ist,
Und dann so ein Commands-PY habe ich die dann
und das sind Funktionen, die dann... Also ich finde das auch super. 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-Commands sowohl auf der Kommando-Teile 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 fly einen User erstellen
und das User-Create-Command hast du
dann halt in den Commands zum Beispiel.
Das gibt es ja zum Beispiel bei Dango ist natürlich mit
inbound, aber das ist dann bei FastAPI 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 3.10 weiter.
Wollen wir das schon inhaltlich nochmal structuren?
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 ein Match
Statement und dann
kann man da halt irgendwie so
Sachen auspacken und dann gucken,
ob das da drauf matcht und
dann führt man halt
dann, also so ein bisschen wie ein Case-Statement auf
Cooks.
Speed, ich weiß nicht.
Genau, und man kann
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 das 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 da sagt man noch, wenn
irgendeine andere Bedingung erfüllt ist, dann kann man
hintendran an den Ausdruck einfach schreiben,
if irgendwas x gleich y oder so,
und dann läuft das da rein, und dann
wenn das nicht so ist, dann läuft es halt weiter in den Default-Fall
zum Beispiel, oder halt.
Okay, das ist der Gart. Genau.
Das ist halt auch nett, weil, ja, also
ich habe noch nicht wirklich tolle
Anwendungsfälle dafür, hätte ich gesagt.
Ja, es ist halt so ein bisschen zum
Filtern von so Dingen, ne? Das war irgendwie mit if, das ist halt
irgendwie sehr verschachtelt, da muss man tausendmal
den Code schreiben und mit diesem Matchcase,
da kann man relativ schön gucken, was denn da übergeben wurde.
So ein Command-Parser zum Beispiel kann man
sehr schön mit Matchcase, glaube ich, abbilden
oder so. Ja, vielleicht wenn man irgendwelche Dinge parsed.
Das könnte man wahrscheinlich deutlich einfacher
hinkriegen. Oder was ich mir auch vorstellen kann,
ist, dass wenn man halt so...
Du hast zum Beispiel so einen generischen Endpunkt
für irgendwas, da kommt irgendwas rein.
Ja, aber das ist nur eine gute Idee,
ist das zu sagen.
Ja, du kannst zum Beispiel sagen, nur dann, wenn es
ein bestimmtes Format hat, dann mach ich
aber was mit, ansonsten schmeiß ich es einfach weg.
Ja, genau. Also das
Einzige, wo ich praktische Dinge gesehen habe,
aber ich bin, ich meine, das kommt natürlich, also
man 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.
Du redest häufig von Elixieren. Ich sehe immer das Buch in der Ecke.
Ja, ja, ich bin immer noch nicht so richtig weitergekommen.
Ja, ich da,
manchmal muss man es halt
nicht nur rumliegen haben, sondern auch mal reingucken, aber
In einem Kopfkissen hilft am besten.
Ja, genau.
Oder halt irgendwie eine andere Sprache, die das halt
kann, aber... Ich lege mir auch immer ganz viel Gold
in das Kopfkissen, damit ich dann das Stoff kaufen kann.
Ja.
Aber
irgendwie...
Genau, weil
weiß ich jetzt, bei Python, also der einzige
Fall, wo ich das Gefühl habe, da ist etwas,
das ist so ähnlich.
Und es ist halt, wenn man jetzt
in JavaScript im Frontend...
Da gibt es ja zum Beispiel React, so Redux oder so.
wo 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 irgendwie ein State oder macht halt irgendwas
und im Kern von diesen
Stores ist halt häufig ein großes Case-Statement
irgendwie
und das könnte man
dann halt, ein 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.
Du musst ja natürlich jetzt alle If-States durch Match-Cases setzen,
erst mal 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, dass man Kontrolle hat, aber wenn das irgendwo,
wenn man jetzt zum Beispiel eine Library schreibt, dann kann man das nicht gut
verwenden, weil dann müsste man sagen,
Geht erst ab 3.10 und...
Oh, 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.
Mit Black geht das noch nicht.
Das heißt,
Autoformat funktioniert
nicht mehr, wenn man...
Das kann ja gar nicht sein.
Das muss doch schon gefixt sein, da muss doch schon
Pull-Requests irgendwo zu geben. Ja, ja, das kommt
bestimmt dann irgendwann, aber momentan jetzt halt noch nicht.
Okay, muss ich mir mal anschauen.
Auch, ah, das habe ich jetzt,
was ist Python Bytes Podcast, ich weiß nicht genau,
das gehört habe, es gibt einen, fand ich auch schön,
man hat ja immer so das Problem, wenn man Sachen
Basen umstellt auf
Black,
dass das dann halt so riesige
Diffs 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 auch ein Projekt, das
nennt sich, glaube ich, Darker.
Und das
macht quasi Black, aber immer nur für die Änderungen, die man
also wenn man einen Code ändert,
dann macht es sozusagen das gleiche wie Black,
aber nur auf dem Diff.
Sodass es halt immer so dunkler wird mit der
Zeit, aber nicht
das heißt, es ändert nur Sachen, die man
angefasst hat und das war nicht auch eine nette Idee, eigentlich eine völlig
offensichtliche Idee, aber ja.
Ja, okay.
Ja, fand ich ganz faszinierend.
Genau.
Ja, Structural
Pattern Matching, was haben wir denn noch?
Ja, also die Disutiles sind deprecated.
Ja. Oh, das ist mir auch
und genau,
Disutiles sind deprecated, da ist auch ein Ding drin,
das mir auf den Fuß gefallen ist, als ich versucht habe, die Sachen
dann, die ich so mache,
mal zu gucken,
ob das unter 3.10 auch läuft.
Und da gibt es eine Abhängigkeit, die hat
Wagtail.
Ach, das schöne Wagtail, ja.
Das liebe ich auch so sehr.
Das hängt ab von L18N,
da ist das irgendwie, das Paket
und es hat irgendwie so ein
L, ich dachte immer, es wäre ein I.
Ja, nee, das macht so leicht was an. Ich weiß, was es genau macht,
weiß ich gar nicht. Aber das ist halt so ein Ding,
das ist halt irgendwie
so zwei Stars auf GitHub
von irgendjemandem
und Wagtail hängt davon ab.
Und da
das Ding verwendet im Setup.py-Skript
irgendwo ein
bdist-wininst oder so was.
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 3.10,
Wagtail nicht mehr installieren.
Was halt so ein bisschen Kacke ist.
Und ja, das ist
halt, ja,
ich habe da mal ein Pull-Request gemacht, mal gucken.
Aber das ist halt,
ja,
schon ein bisschen, vielleicht ist diese Abhängigkeit
nicht so toll.
da wo wir so blöde Abhängigkeiten sind
mit Python 3.10 kaputt gehen, dann müsste ich jetzt nochmal
auf das PyWin32-Problem gehen, weil
PyWin32 ist unter Windows relativ wichtig,
weil das halt relativ oft gebraucht wird
für bestimmte Sachen, um die zu laufen zu lassen.
Das heißt, ohne PyWin32 geht viel
von Python-Wheels-Bauen nicht.
Das heißt, du kannst es fast nicht benutzen, was halt sehr blöd ist.
Und die Abhängigkeit, die viele Projekte
haben, ist sowas wie PyWin32-301.
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 sage mal vorsichtig sperrig,
was das angeht.
Ja, und das ist halt blöd, weil du kannst
halt, dass dann keine Projekte mehr installieren
oder Pultree geht nicht mehr oder so. Und das ist halt
extrem ätzend für Leute, die Windows entwickeln.
Und
Was man aber machen kann, also ich habe einen kleinen Workaround gefunden.
Man installiert einfach PyWin32-301.1, also auch irgendwie komische Varianten.
Die Versionen gehen von 200 auf 301, dann kommt dann 301.1.
Warum? Na gut, vielleicht ist irgendwann so manche Version reingeflogen, ich weiß es nicht.
Es ist auf jeden Fall seltsam und naja, man kann es 301 manuell installieren
und dann, das 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 Foliennamen umbenennen, auch von 301.1
auf 301. Und dann denkt tatsächlich
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. Das ist ein bisschen blöd.
Okay, ja.
Ja, ja, also das sind
ich meine... Ja, wenn es so ein wichtiges Paket
gibt, wo dann so ein Maintaining auf einmal nicht mehr stattfindet
und so, das ist schon anstrengend.
Ja, das ist, ja, das ist schon, 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 Patent-Version gibt, aber bei den Miner-Versions-Updates von Patent 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 Ragtail
per PIP installiert, dann funktioniert es nämlich 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 checkt auch noch die Site Dependencies 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 da ein Wheel ist, dann installiert
es halt stumpf das Wheel, das funktioniert dann.
Das ist halt auf Nahe, 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 Pultree macht sowieso komische Sachen
teilweise. Im Moment, ich bin auch so ein bisschen, also
die Version 1.2 habe ich gesehen, ist gar nicht so
schlecht, die haben aber auch umbestellt das Installation, das heißt
ich muss auch in den Docker-Files überall von
Get-Pultree auf Inside-Pultree 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-Report ziehen. Das ist schon mal ganz gut auch,
ja. Ja, aber das funktioniert halt
dann noch nicht so richtig und dann, dass die PvP-Version
nicht schützen, wir haben die ausprobiert, einfach ab und so.
Naja.
Ja, also ich muss sagen,
Poetry ärgert mich in letzter Zeit auch irgendwie.
Ich verstehe gar nicht, warum.
Zwischendurch lief es wirklich gut, einwandfrei.
Irgendwer hat irgendwas kaputt gekodet.
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.
ich glaube auch Poetry hatte mit 3.10
auch Probleme irgendwie, da ist auch irgendwas, hat
dann nicht so richtig funktioniert, aber halt
NumPy 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 Binary Star sind, aber
ja,
also so richtig rund
ist das alles irgendwie nicht, ja.
Ich warte ja meistens bei wichtigeren Sachen auf
3.1 oder 3.2 oder sowas, also
Ja, aber ich meine
3 aber 0.
Vielleicht sollte man tatsächlich hingehen, 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 meckert, aber...
Ja, ja, eigentlich schon.
Ja, ich habe auch mit dem Pfeifen, ich muss
das eigentlich mal irgendwo hinschreiben, aber naja.
Ja.
Ja, jetzt kommt Werbung.
Was haltet ihr eigentlich von Werbung? Hier.
Ja.
3.11 haben wir noch was zu 3.11,
weil das ist ja so, 3.11 kommt jetzt
ja auch. Ja, 3.11 ist Main
Brand sozusagen bei Python.
Ich glaube, was da ganz
interessant, ich weiß es gar nicht, also eben da gibt es
auch Verbesserungen, wenn man jetzt Fehler
hat.
Weitere, genau, aber es gibt
auch noch, es soll jetzt, also mit 3.11,
was da, habe ich jetzt letztens irgendwie,
gab es auch ein Podcast-Interview mit
Guido, zu
was denn jetzt so alles
ansteht zu Performance-Optimierung und da werden
Oh, da gab es auch noch ein schönes Artikel,
ein Blogpost von Mark Shannon zu, ein Interview.
Ja, Mark Shannon, genau, der beschäftigt sich mit der jetzt auch schon wahnsinnig lange.
Aber den habe ich nicht gesehen, den musste ich mir mal schicken.
Ja, den haben die schon genutzt.
Jedenfalls, genau, in die Richtung geht das halt.
Und da wird jetzt viel daran gearbeitet.
Und da gibt es jetzt erstmal so Basisgeschichten für N311.
bis das sich wirklich auswirkt, wird das
alles noch ein bisschen dauern.
Aber was
halt dann in 3.11, 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
da muss halt viel Kram
geprüft werden. Das kann alles mögliche
sein. Es kann ja halt nicht nur, es kann ja sein, dass
das was anderes ist.
Es kann sein, dass
das überladen
wurde und
weiß der Teufel und
jetzt der Plan sozusagen, wie man
das besser hinkriegt, ist zu sagen,
man kann das spezialisieren.
Also wenn jetzt der Interpreter könnte zum Beispiel
bemerken, okay, jetzt diese Funktion ist
tausendmal aufgerufen worden und zwar immer nur mit
Integern. Jetzt ersetze ich die Funktion,
die da aufgerufen wurde, halt durch
eine
schnellere Funktion,
sozusagen, also anderer By-Code,
der halt nur Integer
macht, ja, 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 da jetzt plötzlich doch ein Float
reinkommt oder so, dann muss das
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.
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 erstmal so ein Frame-Objekt
erstellt. Was ist ein Frame?
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
diese Funktionen auszuführen.
Letztlich. Und
es ist ja auch gut, das zu haben. Wenn man jetzt zum Beispiel
einen Code debugt oder so, dann ist
das 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 ein Code wirklich ausgeführt ist, dann
braucht man das nicht unbedingt.
Und die Dinger werden halt auch dynamisch
alloziert, also sowieso alles dynamisch
und dann hat man halt den ganzen Heap voll,
wenn man jetzt viele unterschiedliche Funktionen aufruft,
hat man jetzt den ganzen Heap voll gesprengelt 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 Mark Schneider vorgeschlagen hat,
ist halt zu sagen, man alloziert 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, dass 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
im Speicher dann lokal und keine Ahnung.
Also seine Performance ist besser und nur wenn man
es debugt, verwendet man halt
diese vollen
Frame-Objekte, die halt man dann sonst normalerweise
immer hat. Und was ist ein Struct?
Ja, das ist jetzt so eine C-Spezialität.
Das ist eine
Datenstruktur quasi mit
mehreren, die halt
aus mehreren Sachen besteht, nicht nur irgendwie
also man hat diese grundlegenden
Datentypen, sowas wie Integer, Float,
ja, so
Charakter
und ein Struct kann dann zum Beispiel, weiß ich nicht,
ein Charakter-Array haben
und ein Float und ein Int oder so.
Und dann der, genau.
Also ein komplexerer Datentyp
in C quasi. Sowas wie ein Base Model.
Ja.
Ist halt kein
Objekt, aber
auch die Art, wie man dann Objekte in C implementiert.
Aber ja.
Dann braucht man halt noch Pointer auf die Funktionen, die das Ding
hat und so. Aber ja, genau.
Aber genau,
was ich auch noch
interessant fand, so an Meta-Geschichten
zu dieser Performance-Optimierungs-Geschichte, ist halt
dass
Guido 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 schiefgelaufen ist. So PiPi hat
ja nicht so richtig, muss man leider sagen, wahrscheinlich
nicht so richtig funktioniert.
Und der Grund
ist halt, dass
aus seiner Perspektive, dass
sie das, 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 immer genau das Problem.
Also PyPI, äh, PyPi
ist halt natürlich, es macht einen, äh,
es ist halt 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.
Ähm,
aber es macht halt irgendwie
dein Python,
die Ausführung von deinem 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 in
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 DC
CAP und so. 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,
es gab es nicht nur, das gibt es auch wieder.
Es gab 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ß jetzt gar nicht genau,
was sie an Optimierung gemacht haben.
Es gab auch vorher schon
so ein paar Sachen.
Wie hießen 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 schneller zu machen, aber das alles
wenn das halt darauf hinaus
lief, dass es halt irgendwie
anders funktioniert als CPython
Bytecode, dann ist es halt
nicht gut, so richtig, weil
ja,
das ist halt dann doch, weil
das Problem ist, dass viele Sachen, die halt da
dranhängen, gehen dann halt nicht mehr.
Unter anderem die ganzen
C-Extensions.
Was mich dazu führt, also es gibt ja
noch Alternativen vielleicht dazu. 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. Das muss man alles zwar neu schreiben,
aber ja. Man muss halt so ziemlich alles neu schreiben,
was halt ein bisschen schwierig ist, aber
wenn man das dann kriegt, dann könnte man das halt auch
da, man Rust halt irgendwie nach
WebAssembly irgendwie kompilieren kann,
könnte man das halt in den Browser bringen.
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.
Man muss halt einfach nochmal neu schreiben, das war noch ein bisschen
die Wegstrecke runter.
Leute entwickeln, 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 in der Kombination,
dann muss das dann in Rust sich dann auch wieder entwickeln
und die ganzen Fehlerchen dann wegkommen.
Ja, ja.
Aber es 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.
Und dann... Ja, ja, klar.
Also es ist auf jeden Fall
sehr interessant. Ich bin gespannt.
Aber genau, um mal wieder den Bogen
zurückzukriegen.
Also Guido hat ja jetzt
wieder, der war ja im Ruhestand,
ist ja wieder zurückgekommen
und hat jetzt da so ein Team bei Microsoft
und das ist auch komisch,
dass er, wie gedacht, dass er jeweils, also
ja, aber so ist es halt.
Ja, ja, er frisst ihre Kinder
oder so, wie war das? Schon irgendwie, ja,
das 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 sich das dann wirklich auswirkt.
Und
aber wir können wahrscheinlich damit rechnen, dass halt
in den nächsten Jahren Python halt noch ein gutes
Stückchen schneller wird und das ist auch schon mal eine schöne Sache.
Genau, ich weiß nicht genau, hatten wir sonst noch
irgendwas zu Python
3.10 oder 3.11 haben wir jetzt gepostet
Genau, also 3.11 Better Facepacks
haben wir ja auch schon gesagt
Das sieht wirklich schick aus, das heißt, man kann sie wirklich mal lesen
Das macht Sinn
Das ist schon gut, ja
Also ja, ich glaube
News gibt es halt noch ein bisschen, Django vielleicht
Ja, Django, da gibt es jetzt auch eine Alpha-Release
von Django 4, das habe ich auch mal ausprobiert
guckt, was dann alles so kaputt geht.
Und, was geht kaputt?
Wagtail zum Beispiel geht kaputt.
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 immer so
die ganzen Comments-Zeugs,
weil das halt auch nur noch so
marginal-maintained ist, irgendwie
Threaded-Comments, Fluent-Comments,
Contrib-Comments, Contrib-Comments ist glaube ich sogar halbwegs gut
maintained, da gab es auch Mai oder so
wieder eine Version, aber
Fluent-Commands und Threaded-Commands vor allen Dingen
eher nicht so. Und genau,
Threaded-Commands ist halt auch kaputt gegangen und da habe ich
dann halt irgendwie auch, glaube ich, einen Pull-Request gemacht.
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 herum gekümmert, weil ich keine Zeit hatte.
Und dann ist er irgendwie so halb durchgegangen.
Das ist mir,
das ist mir ehrlich gesagt ein bisschen peinlich,
weil ich habe da irgendwie nur sowas hingerotzt.
Und dann kam dann noch so
Anmerkungen und was ich noch tun könnte
und so und ich habe einfach nicht mehr reagiert und dann hat
irgendjemand dann irgendwie Teile davon einfach so gemerged
und waren halt dann drin. Aber
es ist irgendwie, ehrlich gesagt, sehr schlampig
von meiner Seite aus. Aber ja,
also... So, so, so.
Ja. Ja. Aber prinzipiell...
Ich kriege immer auf die Finger, wenn ich irgendwas nicht ordentlich mache.
Ja.
Aber prinzipiell
geht Wagtail mit Django 4.
Also das funktioniert schon. Also man
muss da gar nicht so wahnsinnig viel... Prinzipiell
schon, wenn man noch ein bisschen... Also es
gibt zwei Dinge, die
nicht funktionieren. Das eine ist
wenn man
ein All-Pass-Quote verwendet, das hat sich
irgendwie geändert. Das
war früher in Django selber drin.
In Django 4 fliegt das raus. Das ist
sowieso schon deprecated. Und das bedeutet,
man muss jetzt aus
From-All-Pass-Import-Quote sagen, statt
das aus Django zu importieren.
Weil das jetzt in der Python-Standard-Bibliothek
genau das gleiche macht wie vorher in Django.
Und das muss man ändern.
Also bei URLs-Quoten, meinst du,
um irgendwie so Sachen rauszubekommen, oder?
Ja, genau, um zum Beispiel
irgendwie, das ist halt ein Dikt oder so,
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
irgendwas, was nicht halt
in der URL stehen kann, was machen, was halt
da drin stehen kann,
ja, und
dann
eine andere Geschichte ist,
genau, da ist so ein
Request.isAjax
ist rausgeflogen
und das wurde in Racktail halt auch verwendet.
Das wird relativ viel verwendet auch irgendwie,
von IsAjax, ja.
Warum ist das nochmal rausgeflogen?
Da gab es irgendeinen Grund.
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 es setzt halt
irgendeinen Header, also es ist 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 direkt halt 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, Fetch API
und die macht das sowieso irgendwie anders
und das heißt,
das ist ein bisschen nutzlos,
das ist Ajax, das liefert halt einfach nicht mehr
die richtige, es ist ein
Ajax-Call, 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?
Man 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
Fehlermeldungen
so, ey, hallo, bitte nicht mit dem Browser
hier hin, sondern geh lieber da hin, weil
hier gibt's nur 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,
Text-HTML haben will oder so.
Und 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 kleinen Seite aus,
ob über Fetch oder jQuery.
Genau, das ist halt das, worauf man dann
langfristig migrieren sollte, oder kurzfristig,
wenn man es, ja.
Weil
AJAX ist halt weg.
Mit Django 4, ja.
Aber ansonsten,
das 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
verbaut. Also die hat ja, weiß ich nicht,
Python, wann hat das noch umgestellt? 3 irgendwas?
Das ist irgendwie
Zone-Info jetzt neu.
Ich weiß nicht, ob das bei Python-Renewal drin war,
dass das jetzt in die Standard-Gewöhnung gewandert ist, ja.
Genau.
Und da kann man ja wahrscheinlich mehr machen
als PyTZ, das irgendwie rauszuholen irgendwann.
Und das, ja,
ist ja vielleicht ganz interessant noch.
Auch ein schönes neues Feature. Ja, und ansonsten
die anderen Sachen, ehrlich gesagt,
es gibt ein Standard-Redis-Cache-Weckend jetzt,
das muss man nicht mehr extra dazu packen.
Aber gut, keine Third-Party-Library.
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 verwendet denn die User denn so
für
Caching-Backends und
Memcache, die
ist halt drin als in Django,
da muss man nichts zusätzlich installieren.
Und dann kam in der Umfrage raus so, oh, die Leute
verwenden, aber alle Redis und nicht beim CacheD.
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 Werbung.
Wieder ein Wissen.
Ja,
dann sind wir fertig denn tatsächlich mit
Python Dango News. Hast du noch was?
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...
Genau, auch eine News, Psychic Learn
hat eine Version 1.0.
Ah, mhm.
Das war ehrlich gesagt schon relativ lange stabil, aber
jetzt hat es auch tatsächlich irgendwie eine
offizielle 1.0-Version, ja, okay.
Major-Versionsnummer,
was eine tolle, tolle Geschichte ist,
ja, super Projekt.
Genau.
Ja, das ist auch
so das Beispiel, ich habe letztens, genau,
gab es bei Lex Friedman,
Gründer von Anaconda
da und von, also der
Travis Olyphant, der hat auch NumPy,
SciPy, SciPy hat er zuerst, wusste ich auch nicht,
fand ich auch interessant, SciPy zuerst
entwickelt und dann NumPy kam später
dazu, weil man Numeric und
das andere Ding, NumArray
irgendwie zusammenfassen musste,
weil es gab zwar eben diese beiden unterschiedlichen
Implementationen, dann ist es halt NumPy geworden.
Der erzählt halt da auch so ein bisschen
und da, der hat dann
Cyclet Learn als so
beispielhaftes
Projekt, wie das hätte laufen
sollen, eigentlich dann erwähnt und
ein ganz tolles Projekt, ja, also Cyclet Learn
wirklich voll gut, es gibt auch noch Cyclet Image und noch ein paar
andere, aber Cyclet 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,
wenn man das einfach so erzählt, oft
ist das nicht so ein bisschen intuitiv,
aber das ist ein sehr schönes
Beispiel dafür, weil
oder 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.
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,
macht halt die Angriffsoberfläche
größer und das ist halt ein Problem
und jetzt hat es halt so ein Ding erwischt und
das fand ich...
Was für ein Ding hast du denn überhaupt?
Fail to ban.
Das ist halt irgendwie so ein Ding, dass man sich zusätzlich
zu SSI 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 hat ja jetzt,
ich meine, die Auswirkungen davon sind nicht ganz so schlimm,
weil, aber was das Ding
gemacht hat, ist halt
wenn da irgendwas,
wenn da jemand
irgendwie an diesem SH-Port rumgespielt hat,
hat es halt dann irgendwann ein Whois
auf
die IP, von der
diese Login-Vorsuche kommen,
gemacht, sich da die
Informationen rausgeholt und das dann per Mail
irgendwie an den Admin geschickt.
Okay. Klingt jetzt erstmal noch nicht
so schlimm. Das Problem ist, da war
so eine Shell-Escape-Lücke
im Mail
erzeugen.
Das heißt, das hat irgendwie den Text aus dem Whois
genommen, dann irgendwie in die Mail und das dann per
Kommandozeile übergeben.
Also kannst du modifizieren.
Wenn du das Suez kontrollieren konntest,
konntest du da halt dann irgendwie durch
so Backtick irgendwie, weiß der Teufel,
irgendwie
Spielereien, das Ding da zu bringen,
einen beliebigen Code auszuführen, ja, und dann
konntest du halt einfach eine
Rutschschale aufmachen.
Und, äh, gut.
Also einige Leute, passiert sowas
ausnahmsweise, aber ich hab, da muss ich jetzt auch noch
eine kurze andere Security-relevante
Geschichte erzählen, und zwar, ihr wisst ja, manchmal
mach ich auch ein bisschen Asia, 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 hab nämlich schon ein paar Mal gewundert, warum die irgendwie
komischen Windows-Fehlermeldungen abstürzen. Ich dachte so, hä?
Das ist gar nichts. Die laufen halt tatsächlich auf irgendeinem
Windows drauf. Und was halt da irgendwie
drumrum ist, ist halt irgendwie so ein Wrapper.
Und Microsoft macht da irgendwelche Service-Prozesse
irgendwie auf. Und man kann
irgendwie auf einen Endpunkt einfach diesen Microsoft-Service-
Endpunkt ansprechen. Und
dann muss man halt dann sich authentifizieren,
damit man da irgendwie Service-Krams
machen darf. Und ganz besonders
cool, weil es 2021 wird, dass sowas
irgendwie möglich ist, weiß man nicht genau. Aber wenn man
jetzt die Credentials halt falsch eingegeben hat, gibt es halt ein Denied.
Und was passiert, wenn man gar keine Credentials
angegeben hat?
Ja, dann war alles gut.
Dann war Ruth einfach so.
Die hat gesagt, okay, eine Credentials, okay, muss wohl Ruth 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, kannst du dich einfach ohne Credentials
anmelden und hast ein Root-Jay 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 schreibbar war. Da war es so ein bisschen
mittelgut. Und was auch sehr super daran ist,
das geht nicht
automatisch zu patchen. Das heißt,
du musst hier dahin gehen und musst das manuell ausbauen, falls
er das irgendwie bei sich aktiviert hat.
Tja, und die sind irgendwie default aktiviert.
Naja.
Ja.
Aber okay. Passiert halt
wohl. Also wenn ihr
irgendwelche Dinos bei Ames of Azure habt, guckt da mal
vielleicht nochmal nach diesem Buckner.
Klingt auch nur so,
nicht so, klingt eher so mittel.
Das war auf jeden Fall so eine Sache,
wo ich dachte, oh mein Gott.
Ja, na gut.
Oh, Sicherheitslücken, wo wir gerade schon bei sind.
Das war vor ein paar Tagen auf Twitch.
Oh ja, Twitch wurde was geleakt.
Komplett wohl, einfach mal komplett geleakt.
Tja, kann halt mal passieren.
Aber immerhin nur Passwort-Hashes.
Ja, aber auch
was dann auch interessant ist,
halt auch die Bezahlinformationen.
Ja, es wäre viel, viel, auch viel.
Gucken, wie viel das wert ist.
Da haben wir irgendwie ganz interessante
Geschichten dabei.
Also wenn ihr jetzt mal wissen wollt, wie viel euer
Twitch-Favorite-Streams-Podcast verdient,
oder wie viel Jochen mit seinen Streams verdient
vom Python-Podcast.
Das ist leider relativ traurig,
da ist nichts.
Bist du eingetragen? Das kann man da auch
deine Informationen jetzt abrufen.
Ich nehme mal an, dass das rausliegt. Es ist halt an der Stelle
ein bisschen sinnlos, weil es ist eh öffentlich. Ich habe da nichts,
was irgendwie nicht öffentlich ist, aber
ja.
Also da 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 die Advertisement-Werbung.
Genau.
Ja.
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 da Leute live im Stream mir sagen,
dass das, was ich da mache, ist halt falsch
und wie ich es besser machen soll.
Und das stimmt.
Das finde ich echt wachsend.
Das ist wirklich hilfreich.
Das fand ich schon mal,
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.
Womit ich auch nicht gerechnet hätte, ist, dass
wenn sich jemand dafür interessiert, dass er dann auch besser
weiß als ich. Aber, ja, gut.
Wahrscheinlich, wenn sich jemand darauf interessiert,
dann weiß er es tatsächlich wahrscheinlich sogar besser.
Ja, offenbar. Und das finde ich faszinierend.
Was ist dir denn da aufgefallen? Was war denn?
Zum Beispiel, also gut,
also bei PyTest waren so ein paar Sachen dabei,
wie man das richtig macht und
das wusste ich halt nicht. Oder PyCharm,
auch einige Sachen, wie man da Dinge einstellt und so.
Oh ja, aber, äh. Gut, da kenne ich mich jetzt auch
nicht so aus, das stimmt schon.
Habe ich gerade B gesagt, Entschuldigung.
Ich finde Peitscham gar nicht so schlecht.
Also inzwischen bin ich sogar ein bisschen, also man, ja.
Bist du 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, also ich, also VS Code kann ja noch nicht alles,
was man so haben will.
Aber ich schreibe fleißig Tickets herum und gucke,
vielleicht kann das ja in einem Jahr das alles, was ich haben will.
Also das Einzige, was mir bei VS Code tatsächlich noch nicht gefällt,
ist tatsächlich Datenbank-Zugriff.
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
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 allem, wenn es dann in Containern läuft auch noch oder so
das ist so ein bisschen anstrengend, das dann einzubinden
Ja, ich finde das, also bei PyCharm
zum Beispiel, die letzte Geschichte, die mich da so, man muss dann halt
so Testroot 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 und das funktioniert ja nicht mehr.
Und dann findet er die Datenbank nicht mehr und
ich erinnere mich daran, dass ich diese Geschichten bei PyCharm
schon häufiger hatte. Und dann
war 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 root.
Und dann hat es funktioniert.
Okay.
Naja, also
solche Sachen halt. Aber das muss man halt
also, und vorher dachte ich so, naja, das mit den
Test funktioniert halt einfach nicht richtig. Aber gut,
es funktioniert schon, wenn man weiß, wie man es konfigurieren muss, aber das ist halt
manchmal schon ein bisschen...
Ja, so was ist eigentlich die IDE von selber wissen, dass sie
erstmal einen Root ausprobiert oder sowas, wenn es gerade nicht geht.
Ja, keine Ahnung.
Aber ansonsten
Palcharm, genau, eine Sache
auch im Stream, da habe ich dann geflucht
darüber, dass
oder nicht geflucht, ich habe gerade gesagt,
hier verwende ich ja Palcharm auf Intel,
aber wenn ich jetzt irgendwie auf meinem M1 Mac unterwegs
bin, dann nehme ich immer VS Code, weil Palcharm
kann ich da gar nicht verwenden. Das ist einfach zu langsam.
Ich finde es ja schon auf Intel langsam, aber
auf ARM
geht es gar nicht.
Und es zieht die ganze Zeit Strom wie Hölle.
Das heißt, eigentlich hat ja so ein
M1-Mac super Akkulaufzeit,
aber wenn man Peitschrauben benutzt,
so wie ich das getan habe, dann halt nicht.
Dann sagt das den Akku sofort leer.
Also, nee.
Deswegen nehme ich den mal wie das Kot.
Dann kam auch so ein Chat und so,
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
so, oh Mist, ja, ist tatsächlich so
und dann ein neues PyCharm
genommen und das ist deutlich besser.
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, ja,
War auch so eine Geschichte, die im Stream
mir jemand im Chat einfach so gesagt hat.
Voll gut.
Ja, ähm,
tja, ähm,
genau, Security, genau,
Twitch hatten wir, war sonst noch irgendwas
mit News? Ne, mir fällt eigentlich, hätte ich gesagt,
nichts an. 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, ja.
Bisschen gequatscht.
Ja, okay, tja.
Ja, dann stelle ich jetzt einfach nochmal meine paar doofen Fragen
und vielleicht fällt dir jetzt sowas ein zu diesem Thema.
Ja. Und zwar
ging es halt tatsächlich darum, wenn ich jetzt in Python
irgendwie
mehrere Prozesse habe oder sowas,
oder Threads oder so, ich weiß nicht, ob das einen Unterschied macht.
Und zwar
die ich nicht herausstarte
aus einem Main Thread oder sowas, sondern die
beispielsweise wie beim Gunicorn
einfach weggeforkt werden, während er es aufmacht.
Er 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 da halt einfach
genau gecallt werden kann. Wie mache ich das
am besten? Geht nicht.
Das würde ich sagen,
geht tatsächlich nicht.
Also mit Threads geht's, da ist es halt so,
die teilen sich halt
einen Adressraum und
einen Speicher,
aber das ist eigentlich der Hauptunterschied zwischen
Threads und Prozessen, so was Betriebs
auf der Betriebssystem-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-Kommunikations-
Geschichten, 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 Memcached-Diridis
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 Redis
oder ein Merkle-Studio sein oder es kann auch eine Datenbank
sein oder es kann halt ein File sein
oder es kann halt eine Pipe sein oder
Ja, das habe ich auch überlegt. Also kann man
aus weißem Nachweis einfach eine File in Memory aufmachen,
auf die dann alle Prozesse zugriff haben? Nein, auch nicht wahrscheinlich.
Doch, 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, denn...
Naja, du kannst auch Shared Memory, das geht
auch, aber die Frage wäre halt,
nein, aber das,
du musst ja sowieso, also dein
Bottleneck wird dann ja eh die
Serialisierung und 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 dann. Genau, du musst halt das irgendwie
in eine Form bringen, die man halt irgendwo hinschreiben kann, genau.
Ja.
Ja, und dann hatte ich die tolle Idee, das dann zu picken.
Dann sagte Jochen, oh, oh, oh, oh.
Kann man machen, ist aber, ja.
Ja.
Ja, also Jochen 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 es einfach so 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.
Das 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, Memcached oder Redis benutzt.
Und da auch,
die hatten gepickelte Sachen in User-Cookings abgelegt.
Und
das war noch nicht das Problem.
Und man konnte durch irgendeinen Trick,
konnte man halt den Kram irgendwie
in den Memcached bringen und dann da
den Applikations-Server dazu bringen,
das dann halt zu entpickeln und dann
sind da Leute so da
reingekommen. Also ja,
das ist problematisch.
Also wenn die Users
es schaffen, irgendwie deiner Applikation
was Gepickeltes zu geben, wo sie Kontrolle drüber hatten,
dann ja. Oder es war
auch irgendwie signiert oder so
und an der Signatur war irgendwas kaputt, ich weiß es nicht genau.
Aber ja.
Also das ist theoretisch, wenn ich das auf meinem eigenen
Server laufe, also wenn einer da schon
drin ist, dann hat der eh schon Root.
Ja, aber das ist ja dann zusätzlich, also das ist ja,
aber das ist ja, vielleicht gibt es ja irgendeine,
ich meine, wie kommen die Daten da rein, ja, also
wenn jemand
quasi, vielleicht hat ja jemand
dann nur Zugriff auf irgendein, ist irgendwo
reingekommen über, weiß nicht, der läuft vielleicht auch
irgendwelche anderen Services und kann halt nur
eine Netzverbindung aufmachen, ja, und dann
lauscht da aber dann ein Memcached
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 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 dein 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.
Also mein Anwendungszweck
ist eigentlich nur, dass ich tatsächlich über verschiedene
Candy-Con-Worker-Prozesse Zugriff auf ein gemeinsames
Stickt haben wollen würde, dass ich halt so Dinge
abblicken kann. Ja, aber warum nicht, also
jetzt meine Standard-File,
warum nicht einfach eine Datenbank nehmen? Ich meine, dafür ist Datenbank
eigentlich da. Ja, weil es halt zum Beispiel keine gibt oder
halt, dass du eine SQLite hast, die halt dann schon weg ist und so. Achso,
wenn du keine Datenbank hast, ja.
Warum nicht einen File 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önnte, wenn dann jemand durch das File hat, kann er auch
alles Mögliche reinschreiben. Ja, gepickelte
Sachen darf man da nicht reinschreiben.
Ja, aber das ist ja genau dasselbe Problem dann.
Also mein Problem, ja.
Aber warum möchtest du gepickelte Sachen abspeichern?
Um sie 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.
Die Parameter kannst du ja schon,
vielleicht irgendwie je nachdem, was das ist.
Ja, aber du kannst aber auch
den Namen von der Funktion einfach speichern.
Ja, 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 da muss man das halt selber wieder
sich daraus ein Objekt zusammenbauen. Aber das kann man ja auch machen.
Das heißt, ich muss, aber wie baue ich dann
den Pfad zu dieser Funktion zusammen?
Den muss ich dann irgendwie
später von spontan ein, wie das geht.
Keine Ahnung, ich habe jetzt Pfad zu meiner
Setzapplikation.functions.fuba
Ja, kannst du einfach
den Vater reinschreiben.
Den Vater der Funktion, tatsächlich.
Dann machst du mit importlib
importierst du das Ding dann.
Mit importlib.
Relativ oder absolut?
Ist das egal?
Ja, weiß ich nicht.
Wahrscheinlich ist absolut so ein bisschen
also ja, kommt drauf an,
wo das
wahrscheinlich wird man es absolut zum Paket halt
Ja, das muss ich mal probieren.
Weil vielleicht wäre das tatsächlich, also da den Namen
anscheinend der Callable zu nehmen, eine Rettung.
Dann hätte ich halt nur noch Argumente, aber
gut, die dürfen dann halt...
Die Frage ist, wie viele unterschiedliche Sachen können das denn sein?
Kann man da nicht, das ist sowieso
irgendwie eher in so einem Lookup, dann
nimmst du halt irgendeinen Namen, völlig egal, den musst du nicht über
Import machen, das will ich gerade auch, das ist
vielleicht nicht so eine schlaue Idee, sondern
du hast halt irgendwo einen 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 Funktion.
Okay, ja, das Problem ist halt, dass wenn
jemand halt jetzt, also es geht halt
um so eine Event-Queue, ja, wenn jemand halt
jetzt neue Events anlegen möchte, die er 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 subscribt, weil 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
das vergisst, dann funktioniert es halt nicht. Und das ist halt so ein bisschen nervig,
weil es halt an zwei Stellen
das dann halt überprüft werden muss.
Da kann er halt nicht irgendein Event erstellen und das dann einfach
registrieren und dann einen Händler für nehmen, sondern
er muss sich halt an der Stelle an die Registrierung wenden und das
muss er halt händisch machen.
Das hätte ich mir halt gerne gespart, weil es halt bestimmte
Entwickler gibt, die das verstehen oder nicht verstehen,
aber denen vielleicht einfach eine Methode
schreiben können, die dann irgendwas macht.
Naja gut, aber du kannst ja auch
irgendwie
überlegen, wie man die Funktion
adressiert sozusagen und dann
das kannst du ja dann selber machen.
Naja gut, ich
überlege halt was, also ich glaube
dieses Pickeln ist halt an der Stelle quasi die
einfachere Lösung. Ja, aber
das weiß ich nicht, also Pickel
Aber die Frage ist halt, wo es halt geht,
ob es halt nur über so ein Main-Cache-Dee geht oder so ein
Redis geht oder halt noch eine andere
Variante geht, die irgendwie
einfacher ist. Kann man
aus Python raus einfach so ein Chat-Memory außerhalb
aufmachen oder geht das nur mit sowas wie
Main-Cache-Dee und Redis? Gibt es im Python-Modul
man kann das schon machen, aber ich weiß
nicht, ob das empfehlenswert wäre, weil
du musst ja irgendwie auch darauf zugreifen
und
das dafür bietet
ja sowohl mit dem KGD, auch
redest du Dinge an und wenn du das selber machst,
schwierig, weil was ist, wenn dann
der Applikationsserver jetzt
einen Prozess läuft, jetzt auf dem anderen Rechner, dann ist das
auch wieder ein Problem.
Also ich, also gut,
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 ein Redis
oder ein Bank-Hashtag.
Ja, das ist auch die Frage, ob man halt, wenn man Projekte voneinander
isoliert aufbaut, ob man dann
ja, eigentlich
müsste man die Sachen dezentral voneinander betreiben.
Aber das ist halt dann wieder so ein Problem, dann
ganze, mit Deployment,
ganze Deployments zu machen, die vollständig sind und so.
Die dann jeweils unanhängig voneinander sind
und dann nicht erwarten, dass schon irgendwo anders so ein Redis rumliegt
oder so, und dann neue Verbindungen aufmachen,
neuen Redis-Nutzer mit neuem Ausländer-WC
und bla bla bla. Das ist halt alles relativ
aufwendig für so kleine Sachen, dass man irgendwo mal kurz
so zwei Kies im Dikt ablegen will.
Dafür halt so ein Rattenschwanz.
Dann wäre halt die Frage, wozu brauchst du denn dann mehrere Prozesse?
Ja, gut, aber das
liegt halt nur daran, dass der Ganykorn da so ein bisschen
mehr Power kriegen soll. Wenn man jetzt dem Ganykorn
sagt, du brauchst noch einen Worker, dann reicht's ja halt.
Ich hatte irgendwo bei StackOverflow mal
so eine Antwort gesehen, da hat der Preload gemacht, dann hat der
erst die Applikation geladen und dann die Worker.
Wozu brauchst du denn da mehrere Prozesse?
Das ist nochmal die Frage, warum mehrere Prozesse
an der Stelle?
Kennecon macht Worker-Prozesse auf.
Ja, aber das heißt, das müsste man halt dann
als harte Restriktion haben, das geht halt nur mit einem Worker-Prozess.
Und man hat da dann unerwartete
Seiten-Effekte, wenn das jemand macht.
Ja, genau, dann stehst du halt danach
und dann funktioniert das halt nicht mehr so richtig.
Ja.
Ja, das stimmt.
Nun, die Frage ist, ob man halt so ein Workaround hat für solche Fälle.
Aber es geht ja eigentlich für alle Dinge, die halt irgendwie
einzelne Instanzen haben. Also du hast irgendwie von irgendwas
so ein 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 oder sowas.
Ich bin ja in der letzten
Heimat schon zweimal drüber gestolpert.
Meine Vermutung wäre
oft, dann ist irgendwas an dem Problem nicht richtig
oder an der Lösung.
Weil wenn das
die Lösung für das Problem ist, dann ist wahrscheinlich
hat man das Problem nicht richtig verstanden
oder vielleicht ist, ich weiß es nicht genau,
aber das gibt es echt fast nie.
Ja, also als Beispiel
darf es nur eine offene
Verbindung zu irgendeinem anderen
Rechner geben, weil er nicht mehr als eine gleichzeitig
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 an der anderen Stelle dann vom anderen Prozess
halt wartet, bis dieses Log wieder freigegeben ist.
Ja, aber das passiert doch automatisch.
Mit dem Log, ja. Nein, nein, ich meine, wenn du
ja, wenn du von der Meldung 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, bumm,
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 versuchen, sondern eigentlich willst du
ja quasi dieses Objekt dann
durchreichen. Ich habe das Problem
glaube ich noch nicht so wirklich verstanden,
weil ich meine, ja, also ich meine,
das ist ja, wie willst du
das denn lösen? Das kannst du ja gar nicht lösen.
Ja, warum? Also so ein Zugangstoken zum Beispiel,
den ich ja dafür brauche, den will ich ja nicht unbedingt
jedes Mal irgendwo reinschreiben.
Außer vielleicht in so eine Platte.
Und dann die Frage ist, schreibe ich die halt in Redis rein,
hole mir den immer wieder ab, gucke halt, ob der da ist. Wenn es nicht da ist,
dann hole ich mir einen neuen oder so.
Benutze ich den halt immer wieder.
Weiß nicht.
Das ist halt so ein Prozessding. Also wie komme ich denn
da sonst dran? Ohne, dass ich dann jedes Mal
wieder neue Nachfrage.
Wieso muss das denn geteilt werden?
Also ich würde sagen,
wenn du keins hast, dann holst du das halt.
Genau, aber das würde jetzt heißen, ich habe jetzt mehrere Prozesse
und ich habe halt den Zugangstoken und
beispielsweise darf man Zugangstoken nur alle so
und so vier Sekunden holen oder so, sonst
kriegt man keinen mehr oder wird geblockt.
Dann gibt es halt so komische Antwortserver,
die sowas machen. Das ist halt irgendwo zentralhändig.
Genau, ja, das Problem,
daran stehen wir jetzt. Was aber auch
was aber auch blöd ist, ne, das willst du ja auch nicht.
Ja, genau. Sondern das willst du halt, aber
ist das nicht eher ein Deployment-Problem?
Nee. Weil ich würde ja sagen, wo
gehören solche Sachen eigentlich hin? Solche Sachen gehören
eigentlich in die Umgebungsvariablen von dem Prozess.
Ja, aber die kenne ich ja noch nicht und ich kann ja nicht das
also im Deployment dann ablegen, wenn der halt nach
10 Minuten wieder ausläuft, das ist ja krass.
Also ich darf halt nur alle irgendwie 5 Minuten
fragen, aber nach einer Stunde ist er halt wieder weg.
Oder so. Und das ist halt blöd, weil ich brauche
halt alle 2 Sekunden und das ist ja okay, wenn ich
mir einmal eine Stunde eine holen kann
und dann kann ich halt für eine Stunde benutzen, dann ist das okay, aber
von den verschiedenen Prozessen der Anwendung, die parallel laufen.
Gleichzeitig diese, die sind hier halt haben und dann die muss ich irgendwie teilen.
Also klar, ich könnte lokal eine Fall schreiben, was auch nicht so eine gute Idee ist,
wenn irgendjemand da auch die Fall System zugreifen kann.
Das heißt, ich muss den eigentlich irgendwo den Speicher legen,
der geteilt ist über alle Prozesse hinweg.
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 nicht.
Aber ja, genau, aber die ist halt wenigstens ein bisschen
ein bisschen verschlüsselt, also 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 es von
verschiedenen Prozessen ja auf verschiedenen Rechnern liegen können,
dann müsste das ja von
sowas wie einem Redis oder einem Cached oder so
rausgegeben werden, weil das
ja quasi auch nur die geteilte Key-Value-Store ist,
der dann das so irgendwie hergibt.
Aber in Python gibt es halt so eine Möglichkeit
nicht, okay, dann habe ich nicht...
Ja, aber ich glaube nicht,
dass das etwas ist, was man...
Also, ja, ich meine, das klingt jetzt blöd,
weil das natürlich dann ein Problem nicht löst,
aber ich glaube nicht, dass das etwas ist,
was man lösen will.
Ja, also ich glaube tatsächlich,
ich glaube, so eine Antwort wäre mit dem Cash-Dealer-Redis
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.
Manchmal kann man nicht anders, ja, dann ist es halt schlecht.
Also wenn ich halt auf der anderen Seite zum Beispiel
keine Einflussmöglichkeiten habe, dann kann ich nicht sagen,
dass ich da irgendjemanden da anpasse.
Ja, ja, klar, klar.
Tja, ja.
Mit dem Serialisieren, das muss man wahrscheinlich im Kopf haben,
dass das auch ein sicherheitsrelevantes Problem sein kann.
Aber dann, ja, also als Jason wäre
er wahrscheinlich sicher, weil das ja nur irgendwie
Zeichenketten sind, das nicht ausgeführt ist. Das heißt, ich muss
irgendwie gucken, dass ich alles irgendwie Jason
Serializable mache. Und das
heißt tatsächlich, dass ich keine
Funktionen
angeben kann, sondern ich muss
Funktionen Pfad oder
Importpfad angeht. Ja, also ich meine, ich habe zum Beispiel
so einen Fall tatsächlich
von, gerade mit FastAPI
fällt mir jetzt gerade so ein,
da habe ich das so gemacht,
tatsächlich auch,
deine Pidentic-Objekte,
die kannst du ja serialisieren. Zu JSON, ja.
Ja, genau. Aber wenn ich da eine Callable reinstecke, dann geht das
natürlich nicht. Nee, aber du kannst ja
ein neues Objekt erzeugen.
Hä? Also
du kannst ja das Ding serialisieren. Ja.
Also nicht immer.
Das kann ich nur dann, wenn es serializable ist.
Wenn ich jetzt da in Padentic
irgendwelche Sachen drin habe, die nicht serializable sind,
dann kann ich natürlich mir überlegen, was ich denn mache.
Und dann muss ich ja
meinen eigenen Serializer schreiben.
Aber das kannst du ja machen.
Ich weiß noch, ich hatte das halt
dieses Problem
in gewisser Weise auch.
Ich hatte das in diesem Benchmark-
Umfeld, dass man sagt,
okay, 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 Pidentic-Modellen,
da sind halt die Daten für das Ding drin,
aber ausgeführt wird es dann
woanders. Dann rufst du halt das Ding mit dem,
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 Pidentic-Modell das hinbekommt,
das zu serialisieren, dann geht das auch so.
Aber das Problem ist halt die Serialisierung von
Callables in JSON-komplettives
Format. Und das halt dahinter bekommen.
Da muss man halt dann den Civilizer und G-Civilizer
für extra verschreiben, für diese einzelnen Felder.
Und das ist dann die Frage, wie man so ein Objekt realisiert.
Und da stehe ich halt wahrscheinlich gerade, vielleicht habe ich das
noch nicht gemacht, weil ich nicht weiß, wie ich so einen Pfad zu einer
Funktion dann realisieren kann.
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, dass man einen Dekorator in die Klasse
rechnen konnte. Und dann konnte man sagen, okay, registriere das Ding mal.
Und dann
konnte ich quasi
das halt wieder komplett
so aus dem...
Raushauen? Ja, aber genau,
das kann man mal
draufgucken. 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 das Subscribe.
Und dann könnte man die quasi gleichzeitig durch das Subscribe
mit in diese Event-Registry registrieren
unter irgendwas.
Oh, ja.
Und dieses, was dann dabei rauskommt,
das könnte man in das Bidentic-Modell mit reinschreiben,
rauspolen und dann auch quasi
eine Methode dran schreiben, die dann diese
Funktionen ausführen können.
Können wir gleich mal...
Ja, aber...
Ja, das ist ein bisschen gepopelt, aber ja,
das ist das Schöne.
Genau, ich habe letztens
so ein...
Also, was ich
gerade in einem Stream baue, ist halt irgendwie
das Hosting-Ding für
eben den Podcast hier 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 vorletzte Woche, letzte Woche,
diese Woche, ein bisschen
daran 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 der Datenbank serialisieren
und Postgres hat man ja in JSON
viel, 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 Prädikt aufrufen kann,
aus der Datenbank bekommen. Und da
habe ich das auch mit Custom Serializer
D-Serializer 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?
Nee, der guckt halt
was ist das? Und dann ruft er halt irgendwie die
gibt mir halt mal ein Dict
Zurück-Methode, so ähnlich wie
bei Pandentic ist es. Bei Pandentic ist es, glaube ich, auch
.dict.
Das habe ich dann halt quasi genauso gemacht, dann .dict und dann
kommen 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, Class
und wenn das NaiveBase ist, dann
genau, mach halt Spezialbehandlung
und sag nochmal irgendwie
ja,
übergib
dieses Dict, was in JSON
war, halt als Dict für
diese Klasse und mache 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 ja deserialisiert und ist dann halt das
richtige Modell wieder, das heißt, man kann sagen,
also man kann zum Beispiel sagen, SpamFilter.Objects,
jetzt ist jetzt Django-Semantik,
SpamFilter.Objects.First.Model.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, oder? Genau, also
ich würde es zuerst trainieren und dann sagen,
ja, speichere das doch mal, also
Model ist gleich, ist halt das
fertig trainierte Model und dann sage ich halt,
ist beim Filter, also ist beim Filterpunkt Model gleich
Naive Bay, also das, zuerst würde ich
sagen, Model gleich Naive Bay ist
irgendwas, Punkt Fit, irgendwann
Trainingsdaten
und dann sage ich halt, ist beim Filterpunkt Model gleich
Model und dann sage ich, ist beim Filterpunkt Save
und dann ist es halt der Amonk.
Nett, nett. Und genau, das, also
da ist es auch so ein ähnliches Problem.
Ja, das
ging eigentlich relativ problemlos.
Ja, und überhaupt
bei Knifebase, voll gut.
Ja, ich habe das
im April, glaube ich, irgendwann mal auch in die,
weil die Kommentarspammer, also
eine 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 da halt
an Dingen macht, die verhindern sollen,
dass man da beliebig
Dinge reinpostet, schon dafür
gesorgt haben, dass die Kommentarspammer 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 es 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 über einen Browser, dann fehlen
halt vielleicht Daten, die man mit angeben muss. Und dann sagt Django
direkt, 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 und
dann geht es halt doch. Also was man auch
glaube ich ganz gut machen kann, ist so ein Feld
einfach reinmachen, das halt dann mit im Formular drin steht,
was halt automatisch für das Skript ausgeführt
wird und wenn halt was drinsteht, dann sagt
halt der App Spam. Ja, das kann
auch sein, 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 ändern 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 wenn ich mir angucke,
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.
Ich glaube, da gehen
Leute tatsächlich mit
Browsern drauf, die halt 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.
Und ja, also
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
dann hilft das nichts.
Dann mache ich es auch gleich richtig und
baue da halt so einen richtigen Content-basierten
Spam-Filter ein.
Und genau,
Django
Fluent Commands oder so, hat halt auch so
einen Schnittstelle drin für
Akismet 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 man damit ja dann warten
weiterreicht an, ja, also
das ist alles sehr unschön und
man kann das aber
relativ leicht selber bauen und dann
eben, und NaiveBase bietet sich da halt an, weil das
hat keine Abhängigkeiten zu irgendwas anderem,
sondern das kann man halt
rein in Python mit
Standard-Bibliotheksmitteln irgendwie alles machen
und ich habe da auch
eine Stream-Episode
nur darüber gemacht, weil
das kann man in anderen Programmiersprachen genauso machen, das kann man in 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, es ist schnell.
Es ist wahrscheinlich für diesen Fall
Spam, nicht Spam, weil die Klassen gut
getrennt sind, ist es gut genug.
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.
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.
Ja, da müsst ihr euch unbedingt
Jochen's Stream-Channel anschauen.
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 irgendeinen Update gemacht hast
von Jupiter oder so.
Ja, ich bin da ja,
ich weiß ja auch oft nicht, was ich da vorher
mache. Manchmal habe ich einen langweiligen
Kram halt da. Ja, wie es halt so ist, wenn man täglich
seine Arbeit filmt. Irgendwas passiert nicht immer
so die ganzen megaspannenden Sachen.
Ja, aber doch.
Ja, ja.
Das mit dem Naiv-Base, das finde ich sehr spannend.
Ist eigentlich fast schon eine eigene Folge wert, wie man
einen Naiv-Base-Spam findet. Hatten wir schon, tatsächlich.
Spam-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, Maschinen-Learning-Folgen
hattet ihr aber eh noch ein paar mehr nachgefragt.
Vielleicht müssen wir da nochmal... Ja, da müssen wir sowieso...
Wir müssen uns mal Struktur und Konzept überlegen, Jochen.
Ja, also was auch auf jeden Fall
auf dem Plan ist, ist
HTMX, das wird jetzt auch nochmal
Also 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ß.
Ich habe es, glaube ich, auch schon mal einmal so
spaßeshalber gebaut. Ich glaube, da ist noch ein kleiner Bug drin
beim Posten von dem
Formular, die Validierung geht noch nicht richtig durch, aber sonst
müsste man eigentlich mal veröffentlichen.
Ich habe so ein Minimumbeispiel auf Dango gebaut auch.
Ja, ja, ja. Es gibt ja auch Django
HTMLX. Adam Johnson hat das, glaube ich,
gemacht. Super. Ja, also da
muss ich auch mehr mitmachen.
Vor allem ist es halt wirklich so, also das, was
einen halt bei Dango 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 Zack hat und was halt irgendwie... Musst du halt nicht
unbedingt. Ja, genau. Und mit
HTMLX 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,
Validierung 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 nennt man dann eher so AlpineJS
oder
PTView oder so.
Ja. 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
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
irgendwie, wenn es komplizierter wird, sehr hässlich
und ich dachte immer so,
naja gut, okay, da muss man halt doch SPA machen
aber ich glaube
tatsächlich, HTMLX ist vielleicht
tatsächlich eine Lösung, ich weiß es noch nicht genau, weil ich habe es noch nicht
ausprobiert, aber könnte gut sein
Ja, wir müssen 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 eigene Template-Texte für sowas nimmt oder sowas
ist ja natürlich besonders toll, aber
Ja, da 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
das ist ja super, wenn das ein bisschen mehr
in die Richtung läuft, dass man wieder mehr
Server, ja, das sind halt immer so Hype-Cycles.
Irgendwie, macht alles auf dem
Client, oh nein, macht alles auf dem Server, uh.
Ja, weil wenn das halt mit Rust
auch bei Python mit WebMC im Browser geht,
dann können wir auch das wieder beim Client machen.
Ja,
ich meine,
ich würde ja sagen, eigentlich macht das schon
Sinn, viel auf dem Server zu machen.
Ja, würde ich auch sagen. Also eigentlich ist ja das Terminal,
eigentlich brauchst du eigentlich nur eine Tastatur und der Rest ist auf dem
Server. Das einzige Problem ist, wenn die Verbindung
abbricht, dann muss man halt irgendwie gucken, was dann übrig
bleibt, aber ja.
Naja, ja, aber
finde ich auch interessant.
Ich habe jetzt so ein bisschen
auch mal bei Ruby on Rails
gehört. Ich meine, ich würde ja sagen,
die beiden großen, oder tatsächlich
Ruby on Rails ist halt eher so das
große Web-Framework
ja, 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 in der Podcast-Review so dazugehö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
ich nicht wusste, was da so
Rui 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 im Ansatz
vergleichbar mit dem, was Ribbon Rails da macht
und Ribbon 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 es ja auch so lange so, dass
CoffeeScript verwendet wurde, halt für die ganzen
wirklich frontend-frontend-Teile und
das wurde dann halt aber alles automatisch
gebundelt und so
und in JavaScript transpiliert
und so, also das ist ein Teil
wo Ribbon Rails halt nochmal echt mehr Zeugs
hat als Django, würde ich sagen, und dann
auch wichtiger Teil und da dachte ich so,
okay, das ist tatsächlich vielleicht etwas,
das ist auch sowas, das kann man auch machen, man muss sich einfach
Greenwells 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 hast du.
Ja, genau, es gibt ja dann
auch diverse Django-Queue, es gibt
RQ
für diese Redis-Q-Geschichten.
Dann gibt es aber auch noch
Yui oder weiß ich nicht. Es gibt noch diverse andere.
Es gibt halt irgendwie zig
unterschiedliche Q-Systeme.
gut, denkt man sich, oh gut, muss ja nicht unbedingt
in Jago selber drin sein. Ja, wozu auch?
Es gibt ja genug Auswahl.
Nimmt man halt irgendwie, was einem am besten gefällt.
Aber der Punkt ist eigentlich bei
River and Rails ist das halt drin. Da gibt es halt
da nennt es sich glaube ich Actionjob
oder ich war irgendwie so,
ich weiß jetzt auch gar nichts 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 Filesystemzugriff.
Oder für Files irgendwie.
Und das gibt es ja in Django auch.
In Django hast du ja auch irgendwie
Default File
wie heißt das?
File Storage.
Default File Storage.
kannst du setzen. Und dann ist
egal, was du verwendest, ob du irgendeinen Object-Store
verwendest oder das File-System oder was auch immer.
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, kannst auch
sehen, lesen, kannst dich schreiben. Oder wie Cache, Cache-Backend.
Genau, oder Cache-Backend.
Du kannst hinterher
das Cache-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
für die in der Ruby on 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-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 Implementationen
du da verwendest. Ob das jetzt
RabbitMQ ist oder was 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
Celery oder von sonst irgendwas, weil es gibt nicht
irgendwie das, ja genau,
Django-Background-Task-Interface,
sondern das ist halt, ja.
Ja, das fehlt tatsächlich noch. Und da dachte ich so,
okay, ja. Und an
Linschein hat Ruinrails 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 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 gern
MongoDB, kann ich jetzt ehrlich gesagt gar nicht so richtig
verstehen, warum. Wenn irgendjemand
weiß, warum MongoDB cool ist, wir das
erklären oder uns mal schreiben, warum das
toll ist, weil
verstehe ich gar nicht, warum
nimmt man das da wahr.
Offenbar gibt es da 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 nimmst
als why? Was heißt doof? Ich würde nur
sagen, ja, also Jason Field
in Postgres
schneller. Das ist schneller als MongoDB.
Mehr braucht man nicht.
Und es kann halt zusätzlich noch die ganzen relationalen
Geschichten. Also wozu
dann MongoDB?
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ß der Teufel, den ganzen Kram willst du ja eigentlich
auch haben. Also irgendwie
keine Ahnung warum.
Ja, vielleicht auch, wenn man
halt sagt, okay,
hat es irgendwie vereinheitlicht
und es gibt halt nur MongoDB und es kommt damit
klar, sonst kann ich 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 wird relativ
schwierig, uns zu folgen. Ich hoffe,
ihr habt bis zum Ende durchgehalten. Vielleicht habt ihr das ja irgendwie
geschafft. Haben wir
noch irgendwas?
Nee, ansonsten, nee. Hast du einen Pick
der Woche? Ich glaube, ich hab das schon tausendmal. Doch, ich hab
also, was ich
ganz cool fand,
habe ich letztens
auch eingebaut, Django Upgrade
gibt es. Es gibt
für Python, glaube ich, hat Anthony
Soti irgendwie auch so ein Ding geschrieben.
Python Upgrade oder
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 die neueste Syntax und die ganzen
deprecated Sachen ersetzt werden, automatisch durch die
Besserung. Ja, ja und das habe ich dann
als Pre-Commit Hook irgendwie eingebaut
und so, dass 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 nett.
Das ist auch von Adam Johnson, glaube ich.
Ja,
was nehme ich denn? Ja, ich habe ja die
ganzen Sachen, Fast-Fast-SQL-Model, habe ich ja schon
gesagt. Habe ich auch schon mal
Rich erwähnt eigentlich irgendwo? Ja, das habe ich ja
auch schon mehrfach gehabt, ja. Aber ich bestimmt schon mal
als Schoner, 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 probiert das
Open Source zu entwickeln.
Und versucht jetzt damit
durchzukommen,
seine Projekte zu entwickeln.
Und das fand ich auch faszinierend.
Ich bin mal gespannt. Es ist auf jeden Fall sehr populär,
was er macht und ist ja auch super.
Ich hoffe mal, dass es klappt.
Es wäre toll, wenn das
irgendwie
mehr funktionieren würde.
Witch macht ein bisschen
Farbe in euer Command-Output.
Ja.
Ganz nett. Oh, ich benutze das gerne mit
Humanize, vielleicht noch ein nächster Pick, falls ich jetzt schon mal
Gepicks habe. Ah, okay. Also Humanize macht
auch sowas wie Zahlen oder vor allem Daytime-Objekten
irgendwas vor drei Sekunden oder
vor kurzer Zeit und man kann so ein bisschen definieren,
dass das irgendwie nett sich anhört.
Ich mag das irgendwie ganz gerne für
ein, zwei Dinge.
Ein bisschen Human More Readable
Blogs oder sowas.
Ja, klingt gut.
Ja, die hatten
Richard tatsächlich, ich habe es gerade gesehen, ist gar nicht so lange her.
Eine Packaging-Folge.
Jetzt haben wir Humanize dabei.
Okay.
Ja, dann bleibt uns gewogen, hört uns weiter,
wann ihr wollt und bis zum nächsten Mal.
Dann bis zum nächsten Mal. Tschüss.
Tschüss.