Ja, hallo, liebe Hörerinnen und Hörer, willkommen beim Python-Podcast, Episode 39.
Heute reden wir mit euch über FastAPI.
Hi, Jochen.
Ja, hallo, herzlich willkommen, Dominik.
Wir sind mal wieder im schönen Wintergarten, es ist noch relativ dunkel draußen heute mal wieder.
Ja.
Ja, und sind schon ganz gespannt, was ihr uns für Feedback gebt an hallo-at-python-podcast.de.
Genau.
Ja, machen wir wie immer so ein bisschen zuerst News oder so.
Heute haben wir auch keinen Gast irgendwie oder so, sondern...
Nur wir zwei.
Das schaffen wir.
Vielleicht können wir das auch gar nicht mehr. Mal schauen.
Es gibt ja heute ein bisschen Werbung.
Wir sind immer noch gesponsert.
Falls ihr das total doof findet, schreibt uns doch einfach.
Dann überlegen wir, ob wir es direkt wieder sein lassen.
Okay, was haben wir denn so an News?
Wir haben also einen
Pepp, der eigentlich ganz interessant
aussah. Pepp
665.
Kurz bevor The Devil, ich habe geguckt, 666 war schon
seit 2001 belegt.
Ja, die ganzen interessanten Nummern sind alle schon
irgendwie, da haben sich Leute schon viele Gedanken
zu gemacht, was man damit machen könnte.
Ja, um ein
Log-File-Format, also
das gibt es ja, also Log-Files zum
Festnageln von...
Also nicht File, dann Log-File.
Ja, mit CK.
Das gibt es ja
in diversen, also bei Poetry macht das halt,
PipTools macht das,
aber es gibt keinen Standard
dafür und deswegen ist das halt immer ein bisschen
schwierig und
ja, da war halt die Idee, dass
mal so zu standardisieren, zumindest für
Binary-Installationen, weil das geht
eigentlich auch nur so richtig gut für Wheels,
weil bei Source-Distributionen oder so ist halt
unklar, was ist denn jetzt eigentlich der Hash da?
Worüber macht man den denn jetzt?
Also, wobei bei Wheels ist es halt relativ einfach.
Genau, und das war der Pep dazu
von Bracken, der sich
jetzt auch seit einiger Zeit relativ intensiv da mit diesem
ganzen Packaging-Thema beschäftigt hat.
Und ja, das wäre halt eine schöne Gelegenheit
gewesen, das mal zu standardisieren, aber
wurde abgelehnt.
Der war nochmal Bracken, ne?
ist einer aus dem Steering Council
und auch irgendwie, der
macht, glaube ich, eigentlich ist der so, der
verantwortlich für
VSCode-Python-Integration
bei Microsoft, aber der ist eine
ganz bekannte Figur da in der
Python-Entwicklungsszene.
Und weißt du auch noch, warum das abgelehnt worden ist, das PEP?
Ja, weil es eben keine Source-Distribution
irgendwie mit umfasst und
du kannst halt damit dann nur Sachen,
wo es ein Wheel gibt, das locken und dann ist
halt irgendwie, viele sagen dann, das
bringt dann nicht so viel und
Und ach ja, naja, mal schauen.
Vielleicht mal sehen, wie das da so weitergeht.
Vielleicht denkt sich irgendjemand aus,
wie man auch Source-Sachen hashen kann oder so.
Ja, oder vielleicht gibt es da mal was ganz anderes.
Keine Ahnung, mal abwarten.
Das ist Packaging-Problem.
Man könnte ja den Source in einen ZIP runterladen,
den ZIP hashen und dann entpacken.
Naja, also es ist nicht so einfach.
Ja, genau.
Nächste News.
Nächste, was sehr schön ist.
WebAssembly.
WebAssembly ist C-Python, kompiliert komplett
nach, also das ist wirklich
das richtige C-Python, nicht irgendwie
kompiliert nach WebAssembly und
ja, kann man im Browser ausführen. Also es
gehen da natürlich noch viele Dinge noch nicht, aber
dass das überhaupt klappt, ist halt
schon mal irgendwie sehr interessant
und eine sehr gute Nachricht. Das heißt, irgendwann kann man
tatsächlich Python schreiben,
in C-Python kompilieren und dann einfach im
Browser laufen. Nee, der kompiliert mal nichts.
Du nimmst einfach, nein, C-Python ist der Interpreter
von Python. Der ist nach WebAssembly,
Das heißt, der läuft dann sozusagen im Browser
zum Beispiel oder auf irgendwas, was halt
WebAssembly ausführen kann. Und
dann kannst du da einfach Python hinschicken und dann
kann das das ausführen. Das heißt, du schickst
da quasi vom Server Python
Source-Files an den Browserskunden
und das wird dann da. Ja, der könnte das ausführen.
Ist natürlich
so die ganze Umgebung und so,
das ist natürlich dann nicht so wirklich wie
normalerweise.
Du musst halt mit den rechten Beschränkungen klarkommen,
die es dann wahrscheinlich gibt. Ja, und noch diverse
andere Geschichten. Du kannst ja auch nicht irgendwelche Sachen installieren und so, aber
und irgendwie C-Extensions und so,
das geht wahrscheinlich alles nicht, aber
dass das überhaupt geklappt hat, ist schon mal
So wird JavaScript halt endlich
wegschmeißen. Nee, also
das fürchte ich, wird
das aber, aber es ist halt
auf jeden Fall ein Ding, was dazu führen kann,
dass man da
eventuell nicht in so ein
Aussterbeproblem läuft, weil halt alles
irgendwann im Browser ist und so, dann kann man da
vielleicht auch sein oder so, mal schauen.
Was ist so ein Use Case von so WebAssembly
Zeugs? Ja, zum Beispiel
eben im Browser
halt laufen, aber auch eventuell in Zukunft
irgendwann wird es halt vielleicht auch so sein, dass
Telefone oder so das halt irgendwie nativ
ausführen.
Ich meine auch, also
unter iOS oder die
iPhones, die haben ja, da ist ja ganz viel
optimierter Kram auch für
JavaScript schon drin, aber auch für WebAssembly
ist es halt
ja, also da sozusagen das so
zu machen, dass man da den Kram halt auch irgendwie
ausführen kann, das wäre eigentlich relativ einfach.
Das heißt, der macht dann direkt dein Telefon mit die Datenanalyse
live auf dem Gerät direkt oder sowas?
Man könnte sagen, also das kann halt
auch WebAssembly ausführen. Also momentan zum Beispiel
wenn du für iOS entwickelst, geht halt nur
C,
C++, Objective-C,
Swift.
Es gibt zwar auch
Pythonista und so, man kann schon Python da ausführen,
das geht auch, aber das ist alles nicht
so richtig offiziell erlaubt.
Und ja,
JavaScript geht halt auch.
Und vielleicht ist halt
irgendwie WebAssembly irgendwann mal so ein offizielles
Target und dann
könnte man auch Python da so wieder reinschummeln
quasi. Und dann Apps für
Telefone in Python schreiben.
Was ja auch so ein anderes Problem ist.
Die beiden Hauptdinger, auf denen Python nicht da ist,
ist halt Frontend-Web und
halt mobile Geräte.
Und das sind zwei Kategorien, die immens wichtig sind
eigentlich. Und das macht so ein bisschen
Angst, dass die Story für Python da nicht so gut ist.
Aber gut, dass das in die richtige Richtung geht.
Ja, genau.
Genau, Christian Heim ist Hamburger
Python-User-Gruppe, irgendwie
ein paar Mal gesehen, hat da ganz viel gemacht
und das freut mich sehr, dass das irgendwie
coole Sachen macht.
Dann ist Black
jetzt stable. Black ist stable.
Das ist,
ja, genau, das ist toll.
Oder so. Manche Leute finden es auch schrecklich,
aber ich finde es eigentlich eine gute Nachricht.
Das heißt, man kann sich jetzt darauf verlassen, dass das erstmal
eine Zeit lang alles so bleiben wird. Was auch mit
dazugekommen ist, ist Port für Python
3.10-Syntax und so und
ja, eine ganze lange Liste von Dingen, die da
Und damit ist jetzt auch die DIP,
die Django Enhancement Proposal
Ah, ja, ja, ja, es gab
Django Enhancement Proposal
8 sagt irgendwie, lass doch mal
Autofarmata benutzen, aber erst
wenn es Stable ist und genau,
da Blackhead Stable ist, ist Django
jetzt auch quasi mit Black formatiert
und ja.
Ja, wir hatten ja schon mal darüber gesprochen,
wie man Black noch so einsetzen kann mit
Darker oder
Blue war das? Ja, Blue ist halt dann mit
Single Quotes statt Double. Genau, und
Darker ist halt inkrementelles
Black Bike mit
Hooks zum Beispiel.
Ja gut, aber genau, Jungle ist jetzt auch Black.
PyTest. PyTest gibt es
eine neue Version, sieben Seiten.
Der letzte kam irgendwann im Frühjahr letzten
Jahres oder so raus, also das ist ein ganz großer Schritt.
Ich weiß aber gar nicht genau, also es ist nichts, was jetzt irgendwie
rausstechen würde, was man sagen kann, oh das ist ganz toll.
Aber kann man ja mal ausprobieren.
Also die Information, es gibt jetzt eine neue
Version ist vielleicht daran am interessantesten.
Ja,
ansonsten genau zu der
zu der HTMX-Episode
vom letzten Mal. Es gab da noch so ein Essay
von, das habe ich dann gesehen, als ich gedacht habe,
okay, kann man das nicht vielleicht irgendwie einfacher erklären mit diesem
HTUS-Ding?
Was ist das eigentlich? Und so
und habe dann gesehen, es gibt ein
Essay von dem Carson Gross
dazu,
wo er
beschreibt, wie er sich so
gedacht hat und nimmt da halt so ein Bankbeispiel
und sagt halt,
also wenn du eine JSON-API hast, dann
muss, wenn du so eine
JavaScript-Applikation hast, dann muss
ja
sozusagen die Applikation
immer wissen, was zum Beispiel sowas bedeutet,
wie du hast dein Konto überzogen
und welche Aktionen
du dann machen darfst und welche nicht.
Während wenn du halt HTML rüberschickst, dann
können da ja zum Beispiel, ob du jetzt eine Überweisung
machen kannst oder so, ist halt ein Link.
Dann kann der Link da halt entweder drin sein oder nicht.
und dein Browser muss halt nicht wissen, dass du dein Konto überzogen hast, der zeigt einfach nur Formulare an und das Formular zum Überweisen zeigt dir halt einfach nicht mehr an und sozusagen der State, dass der das dann nicht mehr anzeigt, ist halt im HTML und nicht in der Applikation, während in einem JavaScript-Fall kriegst du halt nur die Account-Daten von der Bank und musst dann halt in der Applikation überprüfen, okay, hat er sein Konto überzogen?
Wenn ja, dann darf er nicht überweisen.
Und das ist natürlich sozusagen
einfach ein bisschen anders. Und vielleicht kann man sich das
anhand dieser Geschichte, ich will verlinken,
packen das in die Shownotes. Also ich fand, daran kann man
eigentlich ganz schön sehen, was da eigentlich so gemeint ist
mit Hypermedia
ist die Engine of Application State
nicht.
Was gab es noch? Ach ja, Wagtail.
Wagtail, genau.
Wagtail bekommt einen neuen Page Editor
und zwar von Google.
Genau, von Google gesponsert.
weil Google relativ viel Wagtail wohl intern
benutzt.
Ja, und das ist natürlich schon nett. Also ist
es nicht so wahnsinnig viel Geld, irgendwie, was
sind das, 150.000 Dollar oder so, die sie denen geben,
aber ich meine, da kannst du halt schon
ein bisschen was mit machen und
ja, also freut mich auf jeden Fall auch, dass die Ergebnisse
dann halt allen hinterher zugutekommen, das ist ja
sehr schön.
Genau, und ja, ich meine, ich benutze
ja jetzt auch für meine Geschichten da
Wagtail. Ich bin nicht immer so
ganz super überzeugt, ob das die richtige Entscheidung ist, aber
solche Nachrichten sind auch gute Nachrichten
für mich.
Apropos Open Source,
da gab es doch irgendwie noch eine Meldung von uns.
Ja, Oliver
hat netterweise einen Kommentar
zu der Open Source Episode, glaube ich,
hinterlassen und meinte, da kennt ihr eigentlich diesen
Prototype Fund.
Und nö, kannte ich zumindest überhaupt gar nicht.
Ja, man sagte mir auch nichts.
Und was ist das? Das ist irgendwie
ein Fonds, der
aufgelegt ist, das Bildungsministerium
zahlt dann irgendwie für,
also das geht vom Jahr
2016 bis 2024,
25 Projekte und
16
Förderungsrunden und
also, ja, da sind wir
natürlich jetzt mit 2022 so mittendrin
oder am Ende eigentlich schon fast.
Ja, wenn der jetzt noch einen Förderantrag schreiben will,
also das Problem ist wahrscheinlich immer, der Förderantrag ist relativ
lang, aber ja,
wie immer so bei solchen Dingen, aber
wie viel kriegt man? 50k für 6 Monate?
Ja, 47.500 Euro für 6 Monate
maximal, also vielleicht auch weniger.
Doch, dann dachte ich so, oh,
für ein Team,
die helfen, ja.
Also ich meine, tatsächlich mache ich ja eigentlich genau
das, da steht auch noch in diesem Ding drin, so für Freelancer
oder so, vielleicht ganz interessant, da dachte ich mir so, oh ja, stimmt.
Eigentlich mache ich genau sowas und
eigentlich wäre das ja tatsächlich, vielleicht schreibe ich da
einfach mal was hin, aber andererseits,
ja, so vom Finanziell
ist das jetzt nicht so super attraktiv, ehrlich gesagt.
Und für ein Team ist das natürlich,
ja, nee.
Ja, da kann man, ja, ja.
Ach ja.
Tja, die Preise und so, öffentliche Hand.
Ja, aber prinzipiell sehr interessant
und auch gut, dass das jemand macht,
weil das ist eigentlich total wichtig
und müsste man eigentlich noch mehr machen.
Aber immerhin, das ist ja schon nicht so schlecht.
Und vielleicht weiß ja jemand noch nicht, dass es das gibt.
Ja, und wenn jemand zum Beispiel gerade nach dem Studium
damit durchaus zufrieden sein kann
und dann damit was probieren kann
und damit gefühlt wird, das ist auch schon mal super.
Ja, dann, das war auch jetzt
vor ganz kurzem
EdgeDB 1.0
Release ist vielleicht auch interessant.
Ja,
muss man eigentlich, ich weiß nicht, ob man da so
in Detail drauf eingehen kann.
Aber was ist denn eine EdgeDB trotzdem?
EdgeDB ist, ja,
quasi
ein Versuch, sozusagen
diesen Object Relational
Impedance
Mismatch, irgendwie so ein bisschen.
Okay, jetzt hast du was gesagt, das habe ich überhaupt nicht verstanden.
Edge Relational
in... Object Relational...
Also du hast ja immer das
Problem in
objektorientierten Sprachen, das mappt halt
nicht so richtig gut auf
relationale Datenbanken. Relationale Datenbanken
ist halt so eine Idee aus Anfang
der 70er und
eigentlich eine ziemlich coole Idee, aber damals gab es
objektorientierte Programmierung und sowas gab es einfach nicht.
Und das ist aber
irgendwie das dominante Programmierparadigma
irgendwie geworden.
Und jetzt haben wir halt immer das Problem,
okay, man speichert die Daten
halt in Relationen
oder in einer relationalen Datenbank und man hat aber jetzt
Objekte irgendwie
in der Applikation
und wie kriegt man das jetzt zusammen?
Da gibt es im Grunde zwei wesentliche, also
du kannst auch hohe SQL-Szenen natürlich schreiben, aber
das ist halt so ein bisschen unhandlich.
Die meisten verwenden dann eben
ORMs, also so
Object Relational Mapper.
Wie den von Django oder Peewee oder sowas.
Genau, oder SQL Alchemies für Python
vielleicht der bekannteste.
Und da gibt es zwei grundsätzlich unterschiedliche
Patterns. Das eine ist Active Record Pattern,
was halt Ruby on Rails
verwendet. Django verwendet das auch.
Oder halt Datamapper-Pattern,
das verwendet SQL Alchemy.
Die haben halt so ihre Trade-Offs.
Die haben halt Vorurteile und Nachteile.
Man kann jetzt nicht sagen, das eine oder andere ist besser.
Jedenfalls, aber
sowas muss man halt eigentlich, oder die meisten Leute
verwenden sowas heutzutage einfach deswegen, weil es
halt das Leben einfach deutlich leichter macht.
Aber trotzdem hat man immer noch das Problem,
dass viele Sachen nicht so richtig gut
gehen und schwierig sind.
Und man muss mit den Dingern auch teilweise ein bisschen kämpfen.
Und ja, die Idee bei HDB ist halt einfach zu sagen,
warum denken wir das Ganze nicht einfach nochmal neu
und machen das halt eher so,
dass die Datenhaltung auch zu der Art,
wie wir heutzutage programmieren, besser passt.
Und die Standardfälle,
wo man halt in SQL komische Sachen schreiben muss
oder die mit den normalen ORMs nicht so gut gehen,
die machen wir halt so, dass es halt einfach geht.
und dass man auch,
das ist halt immer so ein Fremdkörper,
selbst wenn man es mit einem ORM macht,
es sieht immer komisch aus,
ein bisschen eigenartig, es passt halt
nicht so richtig und
genau, dafür haben sie sich eine neue Sprache überlegt,
haben gesagt, das eigentliche Problem ist halt, warum die
ORMs nicht so gut sein können, ist halt, dass sie,
dass halt SQL als Compile-Target
sozusagen ziemlich schwierig ist, weil halt
SQL ist ja auch kompliziert, ist eigentlich auch dafür
gemacht, dass Menschen das schreiben,
was ja heute auch keiner mehr macht, eigentlich war das mal gedacht
für das Analysten und so
Queries schreiben.
Weiß ich nicht, ob das jemals passiert ist, aber
heutzutage passiert das kaum, denke ich.
Sondern
es ist halt immer so, dass du verwendest
halt einen ORM, der compiled dann zu SQL,
also zu etwas, was eigentlich dafür gemacht ist, dass Menschen
das finden, das macht irgendwie alles keinen Sinn.
Dann ist es halt auch so, SQL ist nicht so gut composable,
du kannst halt nicht irgendwie
Schnipsel SQL rumreichen und die dann halt
zusammensetzen oder es geht alles nicht so gut.
Das ist eine Gesamtstatement-Syndromie.
Und genau, all diese Dinge sind halt bei
EdgeQL oder so ist, glaube ich, dann die
Sprache besser
sozusagen. Aber da weiß man nicht so genau.
Das ist halt jetzt gerade eine neue Ankündigung.
Die entwickeln da schon seit ein paar Jahren dran, aber
jetzt ist halt die erste
1.0-Version erschienen.
Ja, also
das hört sich auf jeden Fall interessant an. Kann man sich
ja mal angucken. Und es ist halt so eine Mischung.
Das, was sie da gebaut haben, ist
die Sprache soll halt standardisiert
werden. Das ist eher so ein Standard.
Es gibt aber auch eine konkrete Implementation, die
basiert auf
Postgres und
quasi so ein bisschen Erweiterung
Richtung Graphen, Datenbanken,
weil das ist ja auch immer so ein Ding,
es ist eigentlich gar nicht so klar, warum wir jetzt Relationale Datenbanken gewonnen haben
gegenüber den Graphen-Datenbanken und es gibt
ja auch noch Graphen-Datenbanken, Neo4j oder
diverse andere, Dgraph
und Zeugs und
ja, eigentlich will man beides irgendwie haben und
in Postgres kann man das ja ganz gut
auch abbilden und dann haben sie
halt irgendwie so ein Layer über Postgres gelegt und
Ah, wie heißt das? Ein Layer über Postgres?
Klingt ja spannend. Also es klingt auch so, als könnte man das
mit Fast-IP benutzen.
Ja, die haben auch,
also die Leute, die das gemacht haben,
das sind bekannte Leute, das ist nicht so,
dass das irgendwie aus dem Nichts kommt,
sondern
der CEO
von HDB ist dann auch eine Firma,
das macht das Ganze wieder so ein bisschen, ich weiß nicht genau,
die machen halt vor allen Dingen, die haben viel Consulting gemacht
und haben halt viele Probleme gesehen auch,
die man halt
normalerweise so hat.
Ja, der
wie heißt der, Jure Selin
der hat auch
an den
Peps zu
Async Await diese ganzen Geschichten, da hat er hauptsächlich
dran mitgeschrieben, also der ist halt
auch einer der Hauptverantwortlichen
dafür, dass wir jetzt in Python
Keywords für Async Await
also Syntax-Unterstützung
für diese ganzen Async-Geschichten haben
und hat da auch
ganz viele Dinge implementiert und
Lukas Schlanger hat
irgendwie für RGB auch gearbeitet schon
und ja, es ist alles
typisiert, genau, das ist auch sowas.
Den letzten Namen hatte ich jetzt auch noch nicht gehört.
Lukas? Der Release-Manager von Python
für 3.8, 3.9, 3.10.
Ah, okay. Nee, nicht für 3.10, nicht Quatsch.
Das ist Unsinn.
Oder vielleicht noch sogar früher,
ich weiß es gar nicht mehr genau.
Und der, ja, auch ganz einer,
der hat ganz viel zu
Type-Annotation-Geschichten gemacht, der hat Black geschrieben,
genau.
naja, also auch
sehr bekannte
Typ da und
ja, genau, der hatte
und Async.io hat halt mit halt auch
viel zu tun und
das ist alles, die haben auch, genau, die haben
auch
Async.pg geschrieben, das ist halt
die schnellste Postgres-Artenanbindung
sozusagen, die es so gibt.
Ist auch ein ganz tolles Projekt,
also muss man sich, ja,
dann haben sie, genau, haben sie
UV-Loop geschrieben, also das Ding, was halt
unter UV-Corn und so
drunter liegt.
Also eine schnelle Async-IO-Implementation,
die in der Standardbibliothek ist ja sozusagen
nur eine Referenz-Implementation, aber die ist halt
nicht schnell. Und sie haben halt eine schnelle
Version geschrieben, also ganz viel der
Basis-Infrastruktur, die man so, kommt da auch aus
der Ecke schon. Insofern, das
sind schon Leute, die wissen, was sie da tun.
Dann darf man auch ein bisschen Werbung für seine Projekte machen.
Genau, wobei, ja, Firma ist natürlich
Was uns ja zur Werbung bringt.
Moment, wir sind noch nicht mit den News durch.
Wir sind noch nicht mit den News durch.
Achso, was Geheimes, das ich noch gar nicht weiß.
Also
einen Punkt noch, genau, ich habe wieder Podcast
gehört, Problemierbar hat jetzt auch was über
letzte Episode, das war
Laravel, PHP,
Livewire,
das fand ich auch ganz interessant, weil immer so diese
Verbindungen finde ich immer interessant, weil die vielleicht nicht so
klar sind oder mir nicht so klar waren
und wenn man das dann weiß, dann
macht das halt das alles schon mal ein bisschen
verständlicher, nämlich
Laravel
Livewire ist auch tatsächlich
inspiriert von Phoenix Liveview.
Ist aber auch schon ein bisschen älter,
das ist von 2019. Ich hätte das jetzt gedacht, dass es
jünger ist, aber das ist auch schon relativ lange quasi dabei.
Also bei diesem Trend, die Dinge jetzt wieder
vom Server aus zu machen. Und der
Autor von Livewire ist der gleiche wie der von
Alpine.js. Das ist halt, wie heißt der?
Caleb.
Habe ich jetzt den Namen vergessen, aber
irgendwas mit P.
Und Portio, oder
wieso? Und
genau, der hat AlpineJS gebaut und halt aber auch
LiveWire. Und der wollte
eigentlich ja sowas eben wie PhoenixLiveView
bauen. Und dann
ist aber das Problem mit dem PHP,
naja, also so WebSockets,
also PhoenixLiveView macht das ja über
WebSockets. Das geht halt mit PHP
nicht so richtig, weil du hast halt den Async-Teil
in PHP nicht. Also gibt's jetzt
auch seit PHP 8.1,
das ja auch vor ein paar Monaten rausgekommen ist.
Aber es gibt
keine Infrastruktur so richtig dafür und die ganzen
Russer können das nicht und so. Das heißt,
quasi eine Verbindung offen
halten vom Server aus ist in
PHP sehr, sehr schwierig. Das geht eigentlich gar nicht richtig.
Und dann hat er halt angefangen nachzudenken,
so okay, ja Mist, mit WebSocket
das wird irgendwie nicht funktionieren. Wie kann man das
denn sonst machen? Und die machen das,
der macht das auch alles über
AJAX-Calls und Pollen
und, ja, sie
machen so ein bisschen komplizierte Dinge darüber, dass sie
halt immer alles mit übertragen, wenn sobald
irgendwie ein AJAX-Call gemacht wird. Aber
was ich daran cool finde, ist, dass das überhaupt geht
und dass man den Websocket gar nicht so
unbedingt braucht. Also das zeigt das
auf jeden Fall irgendwie. Man kann halt sehr viel machen,
ohne unbedingt einen Websocket haben zu müssen
und das ist eigentlich auch sehr nett, weil
tatsächlich, so Websocket
wird es wahrscheinlich in Django ohne
Django-Channels-Anstützung oder so auch wahrscheinlich nie geben.
Und daher,
aber offenbar scheint man
braucht es auch nicht unbedingt.
Das ist interessant, da können wir vielleicht gleich nochmal drauf eingehen und sagen,
warum oder was FastAPI
Genau, aber mit Fast-TP
könnte man das wahrscheinlich sehr gut machen.
Genau.
Ja, das war's eigentlich.
Ich glaube, das probiere ich
nächstes Mal aus. Habe ich auf Twitter gesehen.
Dachte ich, kann ich hier auch mal anbringen.
Wenn jemand anders das auch
Twitter hat, hat jemand
irgendwie geschrieben.
Jetzt war ich beim Zahnarzt und da hat er
irgendwie
wurde gerückt, beziehungsweise
Moment, warte, gerade dein Zahnarzt
Okay, nochmal.
Nicht ich, ich hab nur gelesen, ich hab es auf Twitter gelesen.
Ja gut, da meint jemand dann, ja, also manchmal fühlt man sich ja so ausgeliefert, wenn man so beim Zahnarzt sitzt, ne, und dann kriegt man auch noch irgendwie so harsche Ansagen wie irgendwie, benutzen Sie eine Zahnseide, ja, Mund auf und dann so, was ist das denn hier, irgendwie, benutzen Sie eigentlich Zahnseide, warum nicht, macht das doch mal bitte häufiger.
Und der meinte dann so, ja, ich habe dann, also nachdem ich diese Zahnseide-Geschichte darauf so hingewiesen worden bin, habe ich dann gefragt, ja, wie sieht es eigentlich bei Ihnen aus, machen Sie Backups?
Und prüfen Sie die auch, ob Sie die ab und zu mal einspielen, ob das überhaupt geht, also wäre schon gut, wenn man das macht, ansonsten, ja.
Das war eine Geschichte, habe ich auch irgendwo im Talk gesehen.
Kein Mitleid.
Kongress, glaube ich sogar.
Schön, muss ich mir merken, muss ich auch mal versuchen
anzubringen. Ja, habe ich mir auch fest vorgenommen,
wenn ich es in Zahlen suche, wenn dann die Frage
kommt, und machen sie eigentlich ihre Backups?
Genau, ja. So, aber jetzt glaube ich,
dann sind wir mit den News durch. Ja, okay.
Ja, okay. Dann wollen wir jetzt wieder
Werbung schalten, also wir wollen nicht, aber wir müssen natürlich.
Ja.
Und wieder mit freundlicher Unterstützung heute von
unserem Werbepartner NordVPN.
Gibt es was Neues?
Ja, ein Exklusiv-Deal
und ein Geschenk obendrauf zum NordVPN-Geburtstag.
Und dann könnt ihr auf den NordVPN-Python-Podcast gehen
und euch den Deal da sichern.
Und da gibt es auch so eine 30-Tage-Geld-Zurück-Garantie.
Genau.
Hatten wir ja auch letztes Mal schon.
Ja, genau.
Ich weiß nicht, benutzt du VPNs irgendwie?
Relativ selten, aber ich glaube,
zum Geoblocking umgehen ist das gar nicht so schlecht.
Ist wahrscheinlich so schlecht, ja.
Wenn du Streaming haben möchtest
und möchtest du irgendwie das Streaming-Programm von zu Hause gucken,
wenn du im Urlaub bist oder so,
ist das doch gar nicht so unnützlich.
Genau, also diese
Geoblocking-Geschichten oder halt auch eben
wenn man sicherstellen möchte,
dass man genug Durchsatz hat
und das irgendwie vom lokalen ISP
vielleicht nicht unbedingt zu erwarten ist,
dann kann das durchaus
hilfreich sein.
Ja, also genau, einfach da
auf https.nordvpn.com
slash pythonpodcast gehen und mal
angucken, was da so von dir gibt.
Genau, damit würdet ihr uns unterstützen.
Jo.
Dann machen wir weiter im Programm
und gehen zu FastAPI.
Ja, FastAPI, das Thema.
Genau, das Thema unserer Folge.
Was ist denn FastAPI überhaupt?
Also es ist ein weiteres Web-Framework, ein neues
Web-Framework und
ersetzt, oder was heißt ersetzt, also ergänzt
vielleicht so ein bisschen die Welt, die es in Python dazu gibt.
Ja, das ist sehr interessant.
Also genau, also eigentlich
die meisten anderen Sachen sind ja sehr alt, also Flask ist
sehr alt, Django ist sehr alt.
Also wenn ich das so richtig verstanden habe,
ist FastAPI quasi das neue Flask, das setzt
du das so ein bisschen, was man da gemacht hat?
Ja, also es ist auf jeden Fall eher, also es kommt
darauf an, aber also auf jeden Fall ist es eher
vergleichbar
mit Flask quasi, was die so
grundsätzliche, den grundsätzlichen
Ansatz angeht, aber
ja, es ist halt auch irgendwie wieder so ein bisschen anders
insofern, aber es ist einfach historisch, man hatte
so eine Explosion von irgendwie unterschiedlichen
Webframework-Projekten
irgendwann halt um diesen Dreh, wo die alle entstanden
sind, 2004, 5, 6, irgendwie so.
Pyramid ist auch aus der Zeit, oder?
Das weiß ich nicht, es kann sein, dass das auch
später, weil ich weiß es nicht so genau
bei Pyramid, aber so viele
Web-Frameworks
kommen halt aus der Zeit.
Oder da gab es halt ganz, ganz viele. Da gab es
so eine Zeit, wo alle zwei Monate
irgendwie was Neues rausgekommen ist.
So wie jetzt bei JavaScript.
Und ja,
die meisten sind wieder verschwunden.
Ich weiß nicht, was gab es damals? Also TurboGears
und ach, was ist der Teufel?
Naja, das meiste ist halt alles wieder
verschwunden und übrig geblieben sind
im Grunde Flask und Django.
Und die repräsentieren ja auch so
irgendwie
gegensätzliche,
die Enden von irgendwie so, also entweder
Batteries included oder halt irgendwie sehr
wenig dabei, aber dafür sehr flexibel.
Ja, genau.
Also der Unterschied auch mit den URMs hatten wir eben schon
gesprochen, dass halt Django
den URM mitliefert
und dass du bei Flask meistens die Core-Icony nimmst.
Ja, aber kannst halt auch irgendwas anderes
nehmen, also bist du halt nicht...
Hast da keine feste Bindung und...
Ja, aber irgendwie seit ein paar Jahren
gibt es halt sowas Ähnliches wieder.
Es gibt wieder viele neue Web-Frameworks.
Also was vor allen Dingen an der neuen Syntax bei Python ist,
liegt halt an der Sprache, dass sie sich geändert hat.
Genau, an den Typefilms, die es dazu gekommen sind.
Typefilms, Async.io.
Genau, das ist Async.
Und was unter FastAPI drunter liegt, ist ja Starlet.
Starlet, genau.
Ja, vielleicht kann man das so ein bisschen
in die ganze Historie so ein bisschen kurz erzählen.
eben, wir sehen so Async-Web-Frameworks
jetzt wieder ganz viele, so Scenic,
Falcon, FastAPI,
Quad,
also jetzt gibt es auch wieder ganz viele
und
der Autor von
FastAPI hat sich auch viele angeguckt
und hat das vorher schon...
Sebastian Ramirez, also Tiandolo,
der viele andere coole Sachen noch macht nebenbei,
neben FastAPI. Also Typer ist auch
sehr ähnlich und dann gibt es auch SQL-Model,
wenn man das irgendwie mit dem OEM machen möchte.
Aber vielleicht erstmal nochmal, was du sagen wolltest.
Genau, der hat viel
Django gemacht oder viel mit anderen,
der hat auch viel APIs gemacht
und war auf der Suche nach einem
Framework, das halt irgendwie bessere
Entwickler-Experience
irgendwie bietet. Also Django REST
Framework oder so.
Er fand das jetzt nicht schlecht, er fand das schon gut.
Also er hat sich halt auch, also die
Browsable API bei Django REST
Framework, es war halt auch eine wesentliche
Inspiration für das, was er dann halt da gemacht hat.
Und fand
das schon gut, aber
es war halt nicht alles dabei,
was er gerne gehabt hätte und
ja,
dann war aber ein Ding
fast perfekt. Also er hat sich
zum Beispiel, Django Rest Framework hat er sich viele Sachen
angeschaut, die er gut fand, aber es war halt nicht.
Dann hat er sich Marshmallow angeguckt, bei Flask
fand er auch gut, diese ganze
Validierungsgeschichten und Serialisierung
von ganzen Objekt-Hierarchien
und so, aber das ist halt
auch noch nicht so
hundertprozentig hat das das getroffen, was er
irgendwie haben wollte. Und
es gab noch ein paar andere Sachen, die er sich auch angeguckt hat.
dann
hat er
sich dann der Autor von
Jungle Rest Framework, Tom Christie, ist ja
auch so einer, der hat ganz, ganz viele Projekte gemacht.
Und
viele Dinge sind auch Basisinfrastruktur für ganz
viele andere Sachen. Also
er hat Jungle Rest Framework irgendwann mal geschrieben.
Dann hat er irgendwann Jungle Rest Framework
quasi abgegeben oder
macht es, weil
ehrlich gesagt ist es auch mehr oder weniger fertig, da ändert sich
schon seit einigen Jahren nicht mehr viel
und hat dann
etwas gemacht, wollte aber schon
APIs weitermachen und hat dann API-Star
mal ins Leben gerufen
und die Idee dabei war halt auch
so ein bisschen irgendwie
das so zu machen, dass es halt von der Kommandozeile
ausgeht plus irgendwie im Web,
dass es halt alles das gleiche Interface hat mit Typen
dran und nativ Async
und all sowas und
genau
Sebastian Ramirez meinte dann auch so,
ja, das war eigentlich schon genau das, was ich gerne gehabt hätte.
Und dann hat er aber
Tom Christie irgendwie angefangen, Starlet zu entwickeln.
Also
auch ein Web-Framework, aber sehr
Basis-Infrastruktur-mäßig, sehr
auf Async fokussiert und gar nicht mehr unbedingt
im API-Bereich. Und AP Star
ist dann eher zu so einem Schema-
Validierungstool geworden.
Und das heißt, das Ding, was
er am besten fand eigentlich oder am besten zu seinen
Anforderungen passte, hat plötzlich
den Fokus gewechselt und was anderes gemacht.
Und dann dachte er so, oh Mist, jetzt gibt's
nix mehr. Jetzt muss ich irgendwie,
ich wollte es wirklich vermeiden, aber jetzt muss ich es vielleicht doch selber
in ein Webfile beschreiben. Und dann hat er das halt
gemacht und dabei ist FastAPI
rausgekommen. Und dabei hat er, glaube ich, relativ viel
auch noch an Pidentic mit rumgewerkelt,
wenn ich das so gesehen habe. Ja, genau. Pidentic
ist halt eine der Geschichten,
die sonst nirgendwo drin sind, die halt da mit
dabei sind. Genau, weil halt so Erweiterung
von Data Classes halt, dass man so ein bisschen
Typen und Modelle hat,
dann direkt mit Validierung und so. Aber darauf
gehen wir gleich ein bisschen genauer ein, würde ich sagen.
Also wir haben gesagt, das ist jetzt ASCII,
hast du gesagt, das ist Async.
Was ist denn da eine ASCII-Applikation
überhaupt nochmal?
Die immer
die Fragen.
Ja, also
ganz lange der Standard für die Kommunikation
zwischen irgendwie dem
Applikationsserver, der halt
irgendwie tatsächlich Requests annimmt und dann
irgendwie, also die Kommunikation mit dem Browser
tatsächlich macht. Das machst du ja normalerweise
nicht, wenn man irgendwie eine Web-Applikation
schreibt, sondern
das nennt sich
WSGI oder WSGI oder
weiß ich nicht, wie man das am besten ausspricht, Micro-Whisky.
Ist das nicht dasselbe wie
What you see is what you get, Whisky?
Ja.
Das Ding,
das ist auch super
einfach. Also eigentlich ist das alles total trivial.
Aber das Gute, dass es halt ein Standard ist,
dass es mehr oder weniger eine Funktion,
die man halt implementieren muss. Und wenn man das
tut, ist man halt ein WSGI
Server. So, das ist der Grund,
warum man da jetzt nochmal irgendwas anderes brauchte.
Also der kriegt im Wesentlichen ein Request,
kommt rein, Response geht raus. Das ist es eigentlich.
Das ist was man klassisch aus HTTP kennt.
Ja,
genau, aber
genau. So, jetzt ist aber
ja, Dinge haben sich
geändert und man will jetzt eventuell auch
solche Dinge machen können wie WebSockets
oder halt, man hat halt eventuell langlaufende
Requests.
Und wenn man viel parallel machen,
dieses Async-Zeugs. Genau, man möchte halt
nicht nur einmal eine Response zurückgeben
können, sondern vielleicht halt auch irgendwie
wieder was zurückbekommen,
dann wieder was rausreichen und
mit Co-Routinen geht das ja super eigentlich.
Und genau,
dann gibt es, aber es gab
keinen Standard und dann
irgendwann, glaube ich, Andrew
Godwin, auch bekannter Django
Entwickler, der hat
das Migrations-Ding gebaut und so.
Der hat dann irgendwann in diesen
ASGI-Standard geschrieben,
um halt das dann halt
möglich zu machen, dass man da halt einen Standard hat für alle.
Und da ist es im Grunde so,
es ist auch wieder super minimal, aber
man hat halt auch eine Funktion, die man implementieren muss
und die kriegt im Grunde eine Receive- und eine Send-Funktion
und halt, ich weiß gar nicht, muss ich nachgucken.
Und Scope. Und Scope, genau.
Ja, aber
da geht das halt. Da kannst du halt dann auch wieder Sachen
nochmal empfangen und
dann irgendwas machen und dann wieder was rausschicken und
bist halt nicht in diesem Request-Response-Ding
so drin.
Ja, und genau.
Ja, und FastAPI
ist halt ein SGI-Server.
Und dann gibt es halt eine gute Implementation
darunter, das ist UV-Con.
Also UV-Loop,
da hatten wir es schon. Also eigentlich ganz
unten drunter ist LibUV.
Das ist das Ding, was halt auch unter Node.js drunter liegt.
Aber ich glaube, da haben wir auch schon
eine Episode mal drüber gesprochen.
Ja, vielleicht einmal doch mal kurz erklären, weil nicht alle Leute haben ja alle
Episoden gehört. Das ist halt eine Bibliothek,
weg abstrahiert, die dieses
Betriebssystem, Syscalls, weg abstrahiert,
die man halt benutzen muss, um halt schnell
I.O. zu machen.
Genau. Und das ist halt unterschiedlich
je nachdem, was man verwendet. Unter Windows
TCP-Completion-Ports oder was auch immer
da verwendet, keine Ahnung.
Unter FreeBSD ist es halt
KQ
und
Linux ist es halt E-Poll
und das Ding bietet halt
ein Standard-Interface für all diese Dinge.
SelectPol, ich weiß nicht, was da noch alles drin ist.
Und das kann man halt benutzen,
da muss man sich nicht drum kümmern, auf welchem Betriebssystem
man läuft und so.
Und genau, das
und Node.js hat
das halt
relativ, hat diese
Entwicklung da getrieben, weil die haben das halt dann
stark verwendet.
Und ja,
mit den
AsyncIO-Primitiv
Keyword-Geschichten in Python
bot es sich dann halt ja auch an, da irgendwie sowas
zu verwenden und da gab es
halt die schnelle Event-Loop-Implementation mit
UV-Loop von den Leuten, die jetzt HDB gemacht haben
und dann so und
auf UV-Loop drauf sitzt halt
UV-Corn, also quasi
so wie G-Unicorn halt als Applikations-
Server, der dann halt Web-Geschichten macht
und dann halt UV-Loop nutzt, um halt schnell
I.O. machen zu können und das ist auch
wieder ein Projekt von Tom Christie.
Okay, ja, da sind die Katzen mit dem Schwanz.
Genau und
darüber gibt es halt dann nochmal so ein minimales
Web-Framework, was halt
dann nochmal die ganzen
Routing-Request-Response-Geschichten abstrahiert
und das ist halt dann Starlet.
Ja, und
FastAPI benutzt Starlet.
Und, ja,
genau.
Aber die Idee ist im Grunde, viele Sachen zu kombinieren,
Pydentic zu kombinieren mit Type-Annotationen,
mit einem
Dependency-Injection-Geschichte.
Parameter und sowas.
Und
ja, halt Starlet als
quasi schnell,
für das schnell unten drunter.
Und ASGI.
Und ja, das
ist eigentlich eine ziemlich coole Kombination
irgendwie. Man kann jetzt sagen, na gut,
ich habe mir jetzt den FastAPI-Source-Code
auch so ein bisschen angeguckt mal.
Also ganz oft sieht man schon
so irgendwie, naja, er importiert
halt Sachen von Starlet und das war's.
Das ganze WebSocket-Modul in FastAPI.
ist halt irgendwie vom Starlet-Import-Websocket fertig.
Ja gut, also abstrahiert halt, ne?
Und dann einen anderen abgibt vielleicht an ein, zwei Stellen und
wird halt gut integriert. Genau.
Das, was man da haben möchte, ja. Und es ist halt, die Dokumentation
ist halt schön geschrieben und so. Er hat das dann irgendwann mal
in Reddit, auf irgendeinem
in einer Reddit-Group oder so angekündigt,
irgendwie, FastAPI. Und die
Reaktionen waren da so ein bisschen geteilt.
Also ich finde das
super, was er gemacht hat, aber
auf Reddit wurde dann halt irgendwie
so, ne? Also diese Dokumentation
und da sind so viele Emojis und das
ist alles so mit diesen GIFs.
Ja, da waren die ganzen, ganz seriösen
Jungs, die alle die ganze Zeit keinen
Humor haben und im Keller sitzen, die fanden das überhaupt nicht witzig.
Die sagen so, das ist so gebraucht,
war ein Verkäufer-Style, das finde ich nicht gut,
da lese ich gar nicht weiter.
Also ich finde das super, weil ich finde die Dokumentation
tatsächlich sehr eingängig, auch
für Leute geschrieben, die mit Python noch nicht so viel zu tun
hatten und gerade mit
Web-Krams und ich glaube, da gibt es relativ
gute Hinweise und so Querlings, man kann es wirklich,
wenn man anfangen möchte, auch mit Web-Frameworks,
finde ich das gar nicht so schlecht, dass man sich das damit mal
anguckt und ich glaube gerade für so Einsatzzwecke
wie man macht eigentlich so Data Science
oder sowas. Ja, man braucht
vielleicht gar keine Webseite, sondern halt eher eine
API oder so, dann ist das halt schon super.
Ja, und dann liest man das halt durch, man lernt da relativ viel
und das Tutorial ist echt nett und angenehm
zu lesen und nimmt einen sehr an die Hand,
auch wenn es so wirklich ein Graufahrenverkäufer ist.
Also man muss ja nicht immer einen Neuwagen kaufen,
das ist ein bisschen teuer und auch aus Sustainability-Gründen
nicht immer so super.
Ja.
Nee, also ja,
im Grunde ist
eine wirklich schicke Geschichte
und überhaupt, ich würde mal sagen, also was daran
halt neu, also es hat sich ja
es gibt es erst seit 2019 ja und das ist
jetzt schon, weiß ich nicht
sehr, sehr verbreitet, keine Ahnung wie verbreitet
aber in den entsprechenden Umfragen ist es halt
irgendwie
nicht mehr viel hinter Django und Flask
sondern wie viele Leute verwenden das
und das
ich glaube einer der Gründe, warum das
so ist, ist einmal, dass es halt
viele Dinge, also wo bei anderen Geschichten was
gefehlt hat, sind halt da mit drin.
Und dann auch,
dass
diese
Developer-Experience-Geschichte da so betont
wird. Das ist auch etwas, was man jetzt in letzter Zeit
immer mehr sieht. Von früher
kenne ich das so nicht.
Da musste man doch alles von Hand und selber und es war alles
schön und hässlich.
Wenn es kryptisch ist und schwer zu installieren,
das war so ein bisschen...
Ja, deswegen macht man das.
Ja, genau. Du musst ja erstmal beweisen, dass du manns genug bist
und hier das Shred aus
zum Stein ziehen, bevor du irgendwie
so und dass man das den Entwicklern
einfach macht und dass die
da irgendwie einfach eine gute Experience...
Ja, das ist irgendwie so ein Ansatz,
also früher
wäre das Leuten fremdartig vorgekommen,
indem man sich sowas... Aber heute ist das
irgendwie... Heute, ja, Zeiten haben sich geändert.
Ja, so will man das wahrscheinlich auch machen, weil man
keine Lust hat, die ganze Zeit nur im Keller rumzusitzen.
Gut ist, wenn die Leute aus dem
Business noch erwarten, dass es doch genauso lange dauert wie früher.
Ja, ja, ja, gut.
Ich meine, es ist halt die Frage, ob einem das wirklich
so wahnsinnig viel hilft, aber
ich würde schon sagen, ja.
Aber
es ist auf jeden Fall irgendwie eine neue
Geschichte und ich finde das ja auch im Prinzip gut,
dass man da so, dass das halt irgendwie alles ein bisschen
angenehmer wird also und nicht so
stachlig ist.
Ja, vielleicht müssen wir mal kurz darüber reden,
wie der das macht. Also zum Beispiel über Type Annotations
geht halt da ganz viel an den Guten dran.
Parameter kannst du übergeben und kannst direkt
sagen, okay,
das Query enthält jetzt ein
Integer oder sowas. Ja, also eine
Geschichte, das hatte mich am Anfang auch so ein bisschen
verwirrt.
Die Query würde ich jetzt so intuitiv
sagen, ich weiß aber nicht, ob es richtig ist, keine Ahnung.
Das hatte
mich am Anfang, da wurde ich dann nach der, also klar,
man schreibt jetzt, also man hat auch immer
die Dinger, die man halt in FastAP
schreibt, sozusagen
die Endpunkte,
was man sagen möchte, sind halt Funktionen
und die Funktionen haben halt Parameter und
dann geht da was rein, also kommt ein Request mehr oder
weniger rein und es geht eine Response raus.
Man sagt jetzt nicht unbedingt Request,
beziehungsweise bei Django wäre es
halt so, da kommt ein Request rein, geht eine Response raus
und dann popelt man sich sozusagen
aus dem Request die ganzen Sachen halt raus,
die man so braucht. Also aus dem,
da gibt es dann Request.get oder Request.post
oder
man nimmt dann halt den Body und dann gut,
wenn man jetzt sowas wie REST-Framework
oder Formulare nimmt an, dann natürlich
eine ganze Menge ab. Oder Class-Based-Views oder sowas, ja.
Ja, aber prinzipiell
muss man sich den, ist der Teil,
man poolt sich den Kram
da selber halt raus, so.
Und das ist bei FastAPI halt nicht so.
Und das passiert halt sehr viel
von dieser Magie direkt,
wenn du die Type-Annotation richtig
dran schreibst, dass halt du...
Man schreibt halt Type-Annotation in die Parameter und dann
kommen die Daten
irgendwie magisch da rein.
Ja, also wenn man besonders gut wird, wenn man da
zu Pidentic-Modelle verwendet als
Parameter-
Annotation, weil dann wird halt
die Validierung von den Objekten, die da beispielsweise
als JSON reinkommen oder so,
direkt mit Pidentic durchgeführt
und das ist sehr cool, weil halt die ganzen Validierungen
dabei sind, die kann man an den Pidentic reinschreiben,
die passieren halt automatisch,
die Type-Konvertierung passiert automatisch,
du hast in den Objekten direkt die richtige
Datenstruktur vorliegen,
du kannst auch das mit, weiß nicht, sogar mit
Daytimes machen, deinen eigenen Parser dafür in dieses
Pidentic-Modell integrieren, wie du das haben willst
und kriegst direkt die nutzbaren
Python-Objekte da raus, die du brauchst.
Das ist schon sehr, sehr, sehr, sehr nett.
Ja, tatsächlich,
Also ich fand es halt am Anfang so, ich habe das nicht
direkt verstanden, dass das so ist und das hat
mich irgendwie eine Zeit lang verwirrt,
weil ich dachte so, okay, wo gebe ich denn jetzt an,
dass das jetzt die Get-Parameter sind
oder wo sage ich denn jetzt, dass es im Body
vorkommt? Und tatsächlich tut man das halt nicht,
sondern man schreibt das halt da in die
Tube-Annotation und dann
magie, findet fast irgendwie
selber raus, ob das jetzt in den Cookies war oder
ob das halt im Body von dem Request
war oder ob das irgendwie in den
Get-Parametern war.
Und ja,
das funktioniert eigentlich auch immer irgendwie ganz gut.
Das ist echt super, ja.
Also was man dann, also vielleicht an der Stelle
nochmal ganz kurz, würde ich gerne eingehen
auf SQL-Model, weil
man diese Pidentic-Modelle, die man dann halt
netterweise geschrieben hat, mit SQL-Model,
das ist auch ein Projekt von Sebastian Ramirez,
ist noch relativ am Anfang, also noch nicht so ganz
produktionsreif, da waren
noch so ein paar Breaking Changes drin, aber
da kann man einfach diese Pidentic-Models
direkt in der Datenbank speichern.
Und der nimmt das dann direkt und zum Beispiel mit
dem SQL-Alchemy drunter,
Dann wird es halt direkt in die Datenbank geschrieben, die man da angeschlossen hat, was halt auch sehr angenehm ist, weil man halt diese Duplikation von der ganzen Logik nicht mehr hat, sondern halt einfach wie bei, wenn man das vielleicht von Dango gewohnt ist so ein bisschen, nur so Modelle schreibt und hat dann direkt seine Datenbankadaptation und die Validierung damit drin.
Ja, und das ist halt dann quasi das Gleiche für Datenbank, man schreibt halt, was das ist, quasi einmal hin und dann gilt das halt für Datenbank, also es wird dann halt ein Datenbank-Schema draus generiert, also es wird halt auch das Schema für die API draus generiert und das ist halt in beiden Fällen gleich und das ist natürlich schon nett, also man kann sich da vielleicht schon eine ganze Menge Schreibarbeit sparen.
Genau, man kann auch dann tatsächlich, das ist auch
in FastAPI mit drin, direkt das
Schema daraus rennen lassen.
Als OpenIP
kompatibles
JSON oder so, das ist direkt mit drin.
Muss man eigentlich eine Funktion aufrufen, dann ist das da.
Auch sehr schick.
Ich mache dabei, also mit SQL Academy
die Migration ist immer mit Alembic.
Damit ich so ein bisschen so eine Art Tango-mäßiges
Migration-System habe, das heißt,
kannst du dann sowas machen wie Migrate schreiben
oder so. Das funktioniert ein bisschen anders.
Das sind halt
andere Formen von Migrationen ran, aber die schreibt man
eigentlich nur in eine Datei an, da kann man relativ viel anpassen
und der macht dann auch relativ automatisch das
Vor- und Zurückspulen.
Das finde ich ganz schick.
Ja, aber gut, das ist halt
dann irgendwie, um diese Sachen muss man sich dann halt
selber so ein bisschen kümmern. Ja, genau, das ist halt das, was
FASAPI nicht mitliefert im Vergleich zu Dango oder sowas,
aber das geht eigentlich auch ganz gut, wenn
man es dann reinbaut. Ja, also was
den Unterschied angeht, also
wir haben ja schon gesagt, irgendwie ist es so
ähnlich wie Flask, aber
also ich würde sagen, der Hauptunterschied ist eben, dass
bei Flask ist, man kriegt
die Werte eher relativ
roh und man hat eben nicht
weiß, wenn man jetzt in Fast
API das schon annotiert hat mit
das ist ein Integer oder so, dann kriegt man halt ein Integer.
Und in Flask ist das halt nicht so.
Genau. Das ist halt der
genau, dann diese Pidentic-Geschichten, das
könnte man in Flask vielleicht auch so machen, aber das
muss man halt selber machen, das ist halt nicht integriert.
Ja, das ist
und vielleicht auch
noch etwas, was halt
interessant ist, wenn man gerade so
Data-Science-Geschichten macht oder halt
Dinge, die so ein bisschen anders sind als
in Django, hast du halt irgendwie eine
relationelle Datenbank darunter, weil der ORM ist halt so,
wenn man den ORM nicht verwenden möchte,
dann macht es eigentlich gar nicht so viel Sinn, Django zu verwenden,
weil das ist halt der Hauptteil von Django.
Und
wenn man jetzt irgendwie eine MongoDB
verwenden will oder so, oder irgendeine andere
NoSQL-Geschichte, dann ist das halt mit
Django eher so, das geht auch,
aber muss man halt,
es geht nicht über die Modelle.
So ein modularer Teil. Also wenn man jetzt das mit SQL-Model zum Beispiel verwendet, habe ich ja gerade versucht zu erzählen, dann genau diese Revision, die man halt hat, die kann man ja vor- und zurückspulen und da kann man sicher alles Mögliche reinhängen.
Naja, NoSQL hat man auch nicht.
Ja, Moment, aber was cool ist, du kannst aus diesen Pydentic-Modellen, die du halt hast, kannst du auch erzeugen aus einer OpenAPI, die du halt hast, wenn du eine OpenAPI-JSON hast oder sowas.
Achso, kannst du dir direkt die Pydentic-Modelle...
Identik-Modelle bauen lassen.
Und so hast du dann halt dann die Sachen direkt, die du dann auch
in eine Datenbank wegschreiben willst.
Das ist halt auch schon sehr, sehr nett.
Klar, man muss sich
dann halt trotzdem, wenn man das jetzt nicht relational ablegen
will, dann irgendwie eine andere Integration nehmen.
Ja, aber sowas geht halt
prinzipiell. Während das mit Django eigentlich nicht wirklich
geht, kannst du halt in FastAPI,
ob du jetzt irgendwie eine relationale Datenbank verwendest
oder halt irgendwas, oder MongoDB oder so,
das geht beides.
Und zwar ist es nicht so, dass man das
irgendwie, dass man dann gegen
das Framework arbeitet, wenn man jetzt irgendwie NoSQL
verwendet mit FastAPI.
Ja, das finde ich sehr, sehr schick.
Genau.
FastAPI selber benutzt
MakeDocs, MKDocs, ist auch sehr schick.
Ja, weißt du, von wem das ist?
Nein.
Ich müsste jetzt einen von
den Namen sagen, die wir jetzt gerade eben schon erwähnt haben.
Von Chris, die ist auch...
Ja, okay, tatsächlich.
Ja, das ist echt erstaunlich, der hat irgendwie, ja,
genau.
Ja, auch ganz schick. Ich habe dazu
einen kleinen Skeleton tatsächlich mal geschrieben, so für die kleinen
Anfangssachen. Da ist so ein bisschen viel vielleicht schon drin.
Ein bisschen rumgespielt. Können wir vielleicht
mal verlinken. Vielleicht mag ja jemand
den direkt benutzen, wenn er es will. Also ist das nichts
Tolles, aber ein bisschen aus.
Ich habe damit noch nicht so viel gemacht.
Ich habe mir aber vorgenommen, dass ich das mal
tun muss, weil...
Ich habe so ein bisschen Django versucht zu enthinken.
Das ist vielleicht nicht immer ganz so cool, aber Typer ist da auch
dabei. Also so Commands-mäßig.
Ja. Was könnt ihr mir denn noch so alles
erzählen über FastAPI? Ja, also vielleicht
noch mal so ein bisschen, wie das funktioniert mit den Datentypen
und diesen Dependency-Injection-Systemen.
Man kann ja auch damit
sowas machen wie Permissions oder sowas.
Wenn du sagen kannst, bestimmte Dinge müssen enthalten
sein, wie Authentifizierung oder so.
Ja, also diese Magie,
dass halt irgendwie
man einfach nur die Annotationen
hinschreibt und dann die Werte so richtig
bekommt.
Depends on us.
Das sind halt,
das funktioniert über diese
Path-Operations-Geschichten
und das ist halt auch irgendwie
über Dependency Injection
wird das halt gemacht. Und du kannst aber auch das
selber definieren, genau. Da musst du halt nur irgendwie
schreibst halt Depends und dann übergibst du halt ein
Callable und das kriegst du dann halt den ganzen Kram.
Da kannst du halt Code wiederverwenden,
der halt irgendwie, weiß ich nicht, irgendwas
eben ein OAuth-Token irgendwie
validiert oder so. Genau, genau.
Oder halt irgendwas anderes macht.
An der Stelle vielleicht.
Datenbankverbindung reinreicht oder so.
Was ist denn ein Dependency Injection?
Oh je, das ist auch so ein Ding.
Genau, in der letzten Episode hat ja schon jemand gesagt,
Thomas hat das...
Weiß ich nicht, ob man das erklären kann.
Das ist halt auch so ein etwas schwieriges
Konzept. Also im Grunde...
Ist das ein Pattern? Kann man das so sagen?
Ja, ist irgendwie
ein Design-Pattern, kann man sagen.
Also wie man ein Objekt in eine Klasse reingibt, ohne
dass man das jetzt mal neu definiert?
Nee, ist eher so, dass du das halt umdrehst.
Sozusagen, also Dependency
Injection ist ein bisschen
sozusagen das Ding, wie man
Dependency Inversion implementiert.
Also du willst halt nicht, also was du halt
nicht machen möchtest vielleicht, ist
in deiner Funktion, die
halt irgendwie Request-Response
macht, irgendwie ein Datenbank-Ding
importieren und dann
was noch machen. Also
weil du dann ja damit hängst.
Genau. Und dann, was passiert jetzt eigentlich,
wenn du testest? Okay, das heißt, du musst dich mit reingeben,
da ist dann alles abstrahiert in diesem Ding.
Genau. Und jetzt willst du das aber auch
nicht explizit irgendwie da rein,
weil du rufst ja gar nicht, du bist ja gar nicht
derjenige, der das aufruft, den
Funktion, die halt irgendwie
Request-Response macht, sondern das wird ja
irgendwie aufgerufen. Das heißt,
du übergibst es nicht wirklich, sondern du injectest es.
Es wird halt irgendwie automatisch...
Depends on database access oder sowas. Genau.
Und damit sagst du halt eigentlich, dass du das gerne
injectest hättest, sozusagen an der
Stelle. Ja. Und dann
kannst du das halt in Tests halt auch ändern.
In Tests kannst du dann einfach sagen,
in der Applikation,
in der Fast API, also dem
Hauptapplikationsobjekt, kann man irgendwie sagen,
Dependency Override,
und dann kannst du halt definieren,
was da injectet werden soll.
Und sagst halt, Depends on Database bedeutet jetzt,
gib mir einfach ein anderes Objekt
oder eine Testdatenbank. Genau, und dann kannst du halt
die Testdatenbank reinreißen oder du reißt halt
irgendeine Memory Repository rein.
Genau, und
ja, das ist halt sozusagen eine Methode,
um diese Sachen
halt voneinander so zu entkoppeln,
dass du halt nicht, weil, also
eingekoppelt wäre es halt, wenn du von irgendwas erbst,
oder wenn du halt irgendwie das importierst oder so,
dann hängst du halt direkt davon ab
und wenn du es halt so indirekt reingereicht
bekommst, dann bist du halt so
ein bisschen losgelöst.
Ja, und das ist
halt auch in Flask alles ein bisschen schwieriger,
das ist halt schon elegant gemacht, wobei
ehrlich gesagt, also ich habe mir den, ich habe mir
kurz den Code angeguckt,
also das Konzept ist relativ
elegant, aber die Implementation ist ein bisschen
ne. Also
da gibt es halt in Flask API so diese
Dependencies-Module-Package
und dann der Hauptinhalt
der Implementation liegt in Utils.py
und das
war schon
schwer zu lesen, also
ja, aber
es funktioniert einfach.
Also ich finde das, du hast schon recht,
wie hast du das eben genommen mit DevFriendly oder sowas, also ich finde
das sehr angenehm. Ja, ja, es ist genau, es ist halt
darauf optimiert, dass man, also
es ist halt anders. Man kann schnellere Ergebnisse erzeugen, wenn du irgendwie
JSON rauspowern willst und hast nicht so viel
Aufgaben, dann kannst du relativ schnell
Erfolge damit erzielen, finde ich. Ja, ja, absolut.
Es ist halt darauf optimiert, dass du als
Entwickler, der das benutzt, um irgendwie ein Ziel zu erreichen,
dass du da gut zum Ziel kommst.
Und ja, diese
anderen Dinge, also ich finde das ganz interessant,
wenn du zum Beispiel Starlet Sourcecode anguckst,
also die Sachen, die Tom Christie so macht, die sind halt
alle super poliert innen
drin, ja. So ein bisschen wie bei
Apple, wenn man Apple Geräte aufschraubt, die sind auch
innen hübsch. Also da sind auch innen
die Sachen, ja.
Man könnte ja mal aufschrauben, reingucken.
Das ist nicht irgendwie so ein Kabelsalat.
Es gibt ja bei anderen Sachen, da schraubst du das halt so auf,
dann nimmst du die Abdeckung ab und dann machst du
platzt da so ein
Gedärmen-Kabel-Ding draus.
Das ist, wenn du Apple-Dinger hast, das ist halt super ordentlich
und alles. Und das ist halt,
wenn du irgendwie Starlet dir den Source-Code
anguckst, der ist halt auch so. Das ist halt irgendwie
alles total, so wenn man
die Fast-API-Source-Code anguckt,
das ist halt schon so,
da hängt dann eher so, da hängt dann
irgendwie Dinge von der Decke und, aber...
Also ich hab zum Beispiel in meinem Computer, wenn ich den aufschraube,
da hab ich auch so ein paar LEDs reingebaut, das hast du.
Ja, genau, ist halt auch
so ein bisschen eine Typfrage.
Die sind auch unnötig halt, die braucht man halt nicht.
Ob man das jetzt hässlich findet oder hübsch ist.
Wichtig ist halt, dass die Luftzufuhr
vernünftig ist, dass es schön kühl ist und dass es
schnell ist.
Ja, genau.
Aber auf der anderen Seite wiederum
zum Beispiel, also auch das
wiederum, das ist halt unterschiedlich.
Auch der Source Code hat kaum Kommentare
oder so.
Dockstrings gibt es fast
gar nicht. Ich habe vielleicht zwei, drei Stellen gefunden,
welche drin sind und Kommentare gibt es eigentlich auch nicht.
Das bin ich auch schon ein paar
Mal drüber gestolpert, ich muss mal gucken. Aber dafür
sind halt die Type Annotations
so aussagekräftig schon
oft.
Ja, aber auch da, das ist halt so ein bisschen,
ja, sie sind aussagekräftig und ja,
wenn du das im Editor mit, der das unterstützt,
halt benutzt, dann ist das halt,
dann ist das für dich halt total cool.
Ehrlich gesagt, aber den Code einfacher
zu lesen, macht das jetzt nichts.
Ja, ich muss auch sagen, den Code selber, wenn ich da reingucke,
muss ich ein bisschen suchen, was macht der denn jetzt.
Geht das alles über Keyword-Only-Argumente?
Was ja auch irgendwie, also es ist klar,
dass das halt für jemanden, der eine IDE benutzt,
vielleicht besser so ist, wenn er halt Funktionen aufruft
oder Dinge, die halt Keyword-Only sind.
Also das heißt, alle Funktionen und Methoden fangen an
mit irgendwie irgendwas, Stern, Komma irgendwie.
Aber für jemanden, der so, von früher hätte man gesagt,
oh mein Gott, was ist das denn?
Das ist ja schrecklich hässlich.
Warum nicht einfach hinschreiben, was man,
und aber
also es ist halt so ein bisschen
also du verbietest ja mit diesem Stern
erstmal, dass es irgendwelche Argumente gibt, außer den
Keyword-Dingern. Auf der anderen Seite
ist es natürlich so, wenn ein IDE dann
halt anbieten kann, was du alles auswählen kannst
an Dingen, die du da reingibst, ist es natürlich für dich
irgendwie angenehmer. Also sozusagen
deine Entwickler-Experience,
wenn du das in einer IDE verwendest,
ist halt besser, aber wenn du das jetzt
in einem Source-Code liest, ist es eher so ein bisschen
ikidigit, ja so sag ich mal.
Ikidigit.
Ja, ja.
Es ist halt die Frage, wie man das gewohnt ist.
Man muss halt damit schnell arbeiten, deswegen ja.
Ja, also ich meine, heutzutage benutzen die Leute halt alle Idees
und gucken halt darüber, was der Code denn macht.
Wenn du dann halt aber mit einem VI da sitzt
und den Source Code liest, dann denkst du ja so,
was ist das denn?
Ich verstehe diese modernen Zeiten nicht mehr.
Ja.
Es hängt es, aber ja.
Der VI kann das ja wahrscheinlich jetzt auch
mit Autocompletion auf den Quarks und so.
Kann man auch alles machen,
wenn man da die entsprechenden Plugins richtig konfiguriert hat,
was einem erstmal ein paar Monate kosten wird.
Ja, ich habe immer zu wenig
Zeit, um das neben der Arbeit noch hinzubekommen, aber
ja. Naja, also
ich finde es interessant. Also es ist
auf jeden Fall irgendwie so ein bisschen was anderes
und das ist, ja.
Also ich mag es sehr gerne. Also zum Benutzen und zum
Anfassen, das gibt einem so ein bisschen
Speed auf der Straße. Ja.
Ja, das auf jeden Fall. Also ich meine, Pidentic ist auch sowas.
Das ist halt. Das ist echt gut.
Das hilft einem enorm. Ich finde auch
ehrlich gesagt, immer wenn ich jetzt so
Alt-Klassen
im alten Style verwende, oder ich meine,
ich habe auch schon häufiger mal irgendwie
Atteris verwendet,
das war ein guter Atteris-Episode,
oder Data-Classes, und
das macht schon, es ist einfach angenehmer,
das so hinzuschreiben, dass halt die
Sachen
als Attribute direkt in die Klasse reinschreibst
und nicht in Init
und dann das nochmal setzt, das ist halt
immer so ein bisschen umständlich.
Jaja, das ist so ein bisschen
ein bisschen wie die neue Variante
von dem Tupel.
Auf der anderen Seite muss man, ich habe jetzt
nochmal geguckt, weil es gab jetzt
bei DDF, da war ich,
warst du da? Ich konnte nicht,
da hatte jemand Geburtstag. Ach ja, richtig.
Genau, ich habe mir das Video
so teilweise jedenfalls angeguckt und
weil mich interessiert hat, irgendwie, weil da
Klaus gesprochen hat über
wie schnell ist eigentlich
Data Class im Vergleich zu einem alten. Genau,
rausgekommen, dass Pylentic ein bisschen langsamer ist bei der
Umformung von vielen Transaktionen. Kann das sein?
Nee, der hatte Pylentic gar nicht. Der hat nur
Data Classes. Achso, ich hatte mal so ein Video
gepostet, wo das verglichen wurde.
Und ja, also
tatsächlich, Data Classes sind auch ein bisschen
langsamer. Die waren früher viel, viel langsamer.
Sind inzwischen gar nicht mehr so schrecklich viel langsamer.
Ein bisschen langsamer sind sie aber.
Und bei Pylentic habe ich es jetzt selber
nochmal nachgeguckt, weil mich das interessiert hat.
Weil ich dachte so, okay, wie schlimm ist es denn eigentlich?
Und gut, ich habe das
jetzt in meinem, ich habe
kleine Objekte genommen,
wo nicht viel Validierung drauf ist.
Aber ich dachte, gut,
ehrlich gesagt kann es dann ja nicht mehr besser werden für
Pydentic, sondern es wird eher schlimmer.
Aber da war der Unterschied schon relativ
riesig. Also da ist es
halt so beim Deserialisieren,
also quasi du hast
sowas wie JSON oder DICT. Ich habe immer DICT genommen, nicht JSON,
weil ich wollte jetzt nicht die JSON-Library
brennschmarken, sondern einfach nur von DICT
zu irgendwie Objekt.
Es ist so, dass Pydentic ist halt
irgendwie so achtmal langsamer.
Und beim
Serialisieren, also von
Objekt zu, also objektgerecht zu
irgendwie dickt, ist es halt
sogar irgendwie zwanzigmal langsamer.
Und das ist natürlich schon, also es kommt drauf an.
Bei WANs wird das dann relevant?
Genau, das ist halt die Frage.
Das ist halt, also ich meine
irgendwie Serialisieren von
irgendwie hundert Objekten, ich weiß
jetzt gar nicht mehr genau, bis ich jetzt nachgucke,
aber es war halt irgendwie so, das ist halt
für einzelne Objekte so ein paar hundert
Nanosekunden.
Bei Nativ
und Pydentic ist es halt dann so, geht in den
Mikrosekundenbereich. Also ich weiß nicht, kostet
dann halt irgendwie 4-5 Mikrosekunden.
Das ist alles relativ
egal, solange das nur ein paar Objekte sind. Wenn du jetzt aber
sagst, du nimmst 100 oder 1000, bei 1000
könnte es sein, dass du schon ein bisschen
möglicherweise schon bei ein paar Millisekunden halt.
So ein paar Mikrosekunden mal 1000 ist ein bisschen
bei Millisekunden. Und ein paar
Millisekunden merkst du dann vielleicht in der Latenz schon irgendwie.
Und es macht natürlich
auch mehr CPU Last, was ja
wenn du viele Sachen parallel machen möchtest, dann darfst
du ja nicht CPU eigentlich. Das heißt, wenn wir über so
Millionen Datensätze reden, die gleichzeitig Prozess werden
würden, dann muss man vielleicht auf so eine Geschwindigkeit dann doch
mal gucken, ob man das... Es kommt halt dann auf die
Gesamtzahl der Dinger an.
Ob du jetzt irgendwie tausend
Dinger in einer Liste serialisierst oder deserialisierst
oder tausend
mal ein Ding gleichzeitig, ist ja
egal.
Aber das Problem ist halt
die CPU-Geschichte
ist halt dann, ja,
die macht
alles irgendwie dann halt langsamer.
Das sind halt die verwöhnten Generationen, die einfach mehr Hardware
auf ein Problem schmeißen. Kannst du natürlich dann auch
machen, ja. Aber also da
muss man schon so, sollte man sich vielleicht klar sein,
dass es halt, dieser Komfort
kostet halt auch ganz schön. Wobei
ich weiß es nicht genau. Vielleicht habe ich es auch noch irgendwie falsch bedient.
Das kann auch sein.
Und vielleicht gibt es da auch noch irgendwie
Geschichten, wie man das schneller
machen kann, dass man halt irgendwie noch was,
ich weiß es nicht, vielleicht hat das
noch irgendwelche Dinge, wo man das
modellieren kann, wo dann irgendwas zu Zeiten
kompiliert wird oder wo es Zeiten zu zählen
oder ich weiß es nicht genau.
Aber also,
wenn man
das verwendet, sollte man sich vielleicht schon klar sein,
das ist unter Umständen ein gutes Stückchen langsamer,
als die alte Art, das zu machen.
Aber es ist auch viel
komfortabler. Also insofern, die meisten haben ja auch
keine Last und haben auch nicht viele Objekte, insofern
ist das alles viel besser.
Ja, ja, ich habe gestern, letztens noch wieder jemanden gehabt,
der keinen Python konnte und ich meinte, ja, ich habe gehört,
das ist voll langsam, weil es die erste Ersagung gibt.
Ja, das hören immer viele,
aber es ist halt die Frage, was das
denn bedeutet und in welcher Hinsicht
langsam und so, das muss man dann halt
so ein bisschen auseinander dividieren.
Und ich, also
meine Ansicht dazu ist ja so, wenn du
mir da genau sagen kannst, was du haben willst,
dann kann ich dir sagen, wie du es hinkriegst.
Insofern, und dann kannst du so schnell sein,
wie du sein willst. Also ich kann mir nicht vorstellen,
dass du mit irgendwas anderem sehr viel
schneller bist.
Ja, aber das ist halt wahrscheinlich der Punkt,
dass die Leute gar nicht den Andenksfall genau verstehen
und warum Peißen dann da vielleicht langsamer ist, wenn man es
falsch macht. Wenn du keine Ahnung hast und irgendwas machst
und dann kann es sein, dass es hinterher langsamer ist, ja.
Das stimmt. Ja, genau.
Das stimmt halt auch für alles andere, also insofern, ja.
Ja.
Äh, genau.
Ja, also schöne Sachen, also um
tatsächlich, wenn du irgendwie einfach sagst, du hast irgendwie
willst einen Dick draus geben, ist das direkt
Jason und so, also Fasshapi ist schon irgendwie
eine schöne Sache für sowas, ich mag das.
Ja, genau.
Ah, vielleicht
die ganze Async-Geschichte.
Genau, normalerweise
sind halt, oder was heißt normalerweise,
aber üblicherweise
hast du ja dann, also
machst du ja dann Async, definierst du dann
eine Funktion als Async und so, dann kann das alles
schön
sozusagen, zumindest
das IOMS sich parallel gemacht werden.
Jetzt hätte ich mal eine Frage. Ich habe eine ganz fiese, gemeine Frage.
Okay.
Was macht eigentlich,
du kannst aber auch in FastAPI
normal Funktionen so definieren.
Oder wenn du auf die Datenbank zugreifst, dann ist das ja auch synchron
alles. Und dann
kannst du ja eigentlich nicht mehr
deine Funktionen async definieren oder wait sagen, sondern du musst das
halt so aufrufen. Und das funktioniert ja auch einfach
so.
Wie
macht, oder was, warum
geht das eigentlich? Oder wie macht
FastAPI das
eigentlich, dass
wenn du jetzt ganz viele
sagen wir mal so, es kommen ganz viele Requests
parallel rein, sozusagen, und jetzt hast du da
diese Funktionen, die synchron sind, die sind ja nicht als
iSync irgendwas definiert, und
die blockieren also,
die blockieren ja alles andere. Wie kann es denn sein, dass
FastAPI dann trotzdem nicht viel langsamer wird?
Was es tatsächlich nicht wird.
Gute Frage.
Mit der Session,
ich weiß nicht, wie du das regelmäßig
für die Datenbank...
Als ich das gesehen hatte,
dass FastAPI,
dass man beides verwenden kann und es auch irgendwie magisch
funktioniert und auch nicht schlechter wird von der
Performance her, wenn man das irgendwie synchron
definiert, so, hä, wie macht denn der das?
Dann muss ich an der Fast-API-Dokumentation ein bisschen
kramen, bis ich das gefunden habe.
Und über zwei-, dreimal
es gibt irgendwie Concurrency, Parallelism
gibt es einen Teil in der Doku
und dann kommt so die erste Warnung jetzt ab,
hier wird es aber technisch und dann kommt noch eine zweite Warnung ab,
hier wird es aber wirklich fies technisch. Und dann nach der dritten,
wo dann steht, also das dürfte jetzt nur wirklich überhaupt niemanden
mehr interessieren, da steht dann noch, wie es wirklich
funktioniert.
Jetzt musst du spoilern.
Naja, also tatsächlich, was FastAPI
macht, ist, es benutzt ein Threadpool,
um die Sachen dann halt irgendwie
concurrent, synchron abzuarbeiten.
Also synchrone Funktionen landen im Threadpool,
der das dann macht. Das geht auch. Also du kannst
ja auch Threads verwenden, um halt
deine I.O.
zu multiplexen. Und wenn man das richtig
macht und, ja, FastAPI
importiert dann ein Threadpool aus Salad, dann
funktioniert das auch schnell. Also
ja, aber wenn man halt
sozusagen wirklich ressourcenschonend
das machen will, dann macht es schon
im Sinne der Async-Geschichten
Funktionen zu verwenden, dann ist es halt direkt
nochmal
irgendwie ein Stückchen eleganter.
Noch schicker.
Und dann sind es halt Co-Routinen und nichts Weißes.
Da haben wir schon immer noch ein bisschen mehr Overhead.
Oh, was auch gut geht,
das hat man ja sonst immer auch
irgendwie,
sind so Geschichten,
Background-Tasks. Oh ja, Background-Tasks.
Ist ja relativ easy, ne?
Kannst einfach so eine Queue haben und dann
geht rein und sagst, was ist das, Dekorator?
oder eine Dependency, die du reingibst,
Background-Task, und dann hängst du was rein
und das läuft dann einfach? Du musst da am Anfang einmal
initiieren, oder? Nee, nee, nee, nee, du sagst,
das hier ist jetzt ein Background-Task
und den da waitest du dann.
Ah ja, okay. Also das kann eine beliebige
Funktion sein und
genau.
Ich weiß es jetzt
aber nicht mehr genau, aber im Grunde ist das auch schon eine Funktion,
die installiert drin ist und damit kannst du halt
so Dinge, aber die
müssen halt, ich glaube, die müssen dann aber auch
Async-Central, können die auch synchron sein? Das weiß ich jetzt gar nicht.
Ich glaube, es geht sogar synchron, aber ich bin auch nicht.
Kann auch sein, ja. Ich meine, es gibt ja diesen
Threat-Pool, da kannst du auch mal einen Threat machen.
Aber für viele einfache Fälle, also das Problem
ist natürlich, wenn du da jetzt irgendwas sehr CPU-intensives
drin machst, das geht natürlich eigentlich
da nicht. Aber wenn du da drin nur irgendwas
machst, wo du auf I.O. wartest, also du machst
eigentlich nicht wirklich was, sondern du wartest nur,
dann ist das
natürlich sehr bequem, dass du das halt direkt integriert hast
und nicht wie, also was man in Django und so
macht, dann nimmt man halt so Celery oder sowas
oder irgendeine andere Task-Queue und dann startet
man halt, schmeißt man das irgendwas mal
in die Queue, dann gibt es irgendwie andere Dinge, die holen
sich das aus der Queue da wieder raus. Ja, und dann in die Queue schmeißt
man es halt erstmal weg zu realisieren in irgendwie
ein String-Format und das
Ja, ja gut, also es gibt
halt Dinge, für die geht es nicht anders, geht es auch mit
Fast-DP, ging es nicht, also wenn du, wie gesagt,
einen Berechnungsjob machst, dann das kannst
du halt nicht in deinem Web-Server-Prozess machen, weil
wenn du das machst, dann machst du halt sonst nichts mehr, dann
kannst du nicht mehr auf Requests antworten, was natürlich
Ja, und irgendwie muss man es ja dann realisieren, damit es
abgespeichert werden kann zwischendurch, aber
Genau, genau. Und wenn du es
in einem anderen Prozess machen willst, dann musst du irgendwie
das serialisieren und dann irgendwo anders aufrufen.
Ja. Insofern
es gibt halt diverse Fälle,
in denen kommst du nicht drum rum, aber für viele
kleinere Sachen, du willst eine E-Mail wegschicken oder
du willst halt einfach nur
Kurze Berechnung.
Berechnung ist nicht so gut, aber du machst halt
irgendwas, du machst eine andere API ab oder
du schickst irgendwas irgendwo hin oder so, dann ist egal.
Dann kannst du das halt machen.
Und das dürften die allermeisten Fälle
sein eigentlich.
Also das ist halt auch integriert.
Dann, was auch
integriert ist, ist halt statische Files, auch wieder
aus Zalett, aber genau
den Code habe ich mal geklaut
für diese Django
Files-Response-Geschichten.
Und
ja, das ist, du kannst halt
dadurch, dass das halt so
effizient geht mit
LibUV, UV-Loop, UV-Corn,
kannst du halt auch Files
sorgen, was du normalerweise in einem Applikationsserver
nie machen würdest, aber
dadurch, dass jetzt halt nichts mehr kostet, irgendwie
eine Verbindung auf, also weil das Problem
bei Filesorving ist halt,
das sind halt Requests, die lange laufen. Also normalerweise
macht das von außen dann der Web-Server, also keine Ahnung,
der Nginx-Server. Nginx oder ein Apache oder
sonst irgendwas, genau,
oder dein CDN,
weil, ja, eben
wenn ein Applikationsserver
lange Zeit irgendwie
einen Request ausliefert, dann ist der halt belegt und kann sonst nichts
mehr machen. Und du hast normalerweise immer nur so ein paar.
Und wenn dann halt mehrere Leute irgendwie Files runterladen, dann ist deine Webseite halt nicht mehr erreichbar.
Das ist halt schlecht.
Daher normalerweise statische Files ausliefern machst du halt von woanders.
Aber wenn du jetzt irgendwie das effizient IO machen kannst, dann macht das ja nichts.
Dann kann das halt auch dein Applikationsserver machen.
Und deswegen statische Files ausliefern kannst du einfach so vom Applikationsserver aus.
Was natürlich total cool ist, weil du kannst nämlich dann auch die ganzen anderen Sachen machen, die halt man so vielleicht auch braucht, die sonst halt sehr schwierig sind, wie sowas wie Authentifizierung und Autorisierung und so.
Das ist halt, wenn das ein anderer Server macht als dein Applikationsserver, eher ätzend und so geht das halt relativ einfach.
Mit den Dekoratoren, die halt die Routen verbinden, dass du halt so Router hast, so ein bisschen wie du es in Flask kennst.
Ja, aber auch
tatsächlich ein bisschen, es gibt sogar dann,
ich glaube, das gibt es in Flask nicht, aber wahrscheinlich
erzähle ich jetzt Unsinn, ich habe keine Ahnung von Flask, aber
dass du das aufblenden kannst
in unterschiedliche, dass du sagen kannst,
unter diesem
Pfad, dafür ist dieser Router
zuständig. Genau, du kannst halt die Router unternehmen,
du kannst auch unterschiedliche Regeln dann versetzen oder
Authentifizierung für einen Router verlangen oder sowas alles.
Du kannst die Responses dafür definieren,
die du halt haben willst, für den Router, die dir halt
rausgegeben werden und sowas alles, die
Vollfehler-Codes.
Damit kannst du eigentlich deine ganze Applikation
halt irgendwie hübsch aufteilen.
Und etwas, was es in Flask gibt,
was es in FastAPI
nicht gibt, ist so ein Plug-in-System.
Also ich meine, das ist halt die Frage, wie teilst du Sachen auf?
In Django würde man das mit Django-Apps
vielleicht machen, in Flask hast du halt diese Plug-ins
und in FastAPI
hast du wieder noch.
Aber du hast halt einmal die Möglichkeit, über die
Router das aufzuteilen und dann noch die andere Möglichkeit
ist halt, über Dependency Injection das zu
machen. Ja, man kriegt ja schon
irgendwie so eine hübsche Applikationsstruktur dann damit hin.
Ja.
Also ich finde das
ganz nett, vielleicht darzustellen nochmal zu Typer.
Also das ist auch ein Projekt von Ramirez
von Chiantolo. Das hat es so ähnlich gemacht.
Das setzt auch auf Klick auf und macht halt auch
mit Type Annotation, das ist eine Kommandozeilen
Geschichte, die so ein bisschen ähnlich funktioniert
wie FastAPI.
Und das in der Kombination ist halt irgendwie sehr, sehr nett,
weil man halt irgendwie damit dann
seine Applikation steuern kann.
Ja, gefällt mir auch sehr gut.
Ja, verwende ich
jetzt auch schon ein paar Mal verwendet.
Das ist irgendwie so sehr charmant, falls ihr das kennt. Das macht irgendwie Spaß,
damit zu arbeiten. Das ist diese Developer Experience
irgendwie, mit der ich halt mag, irgendwie
modern zu arbeiten mit den ganzen modernen
Tools. Da bin ich auch,
ich muss das nicht schwierig haben.
Das ist irgendwie nervig. Also, ja, man kann
durch diesen Berg boxen und dann,
ja, I'm the Hero, ich habe das Schwert
rausgezogen.
Ja, ich kann mit meiner Zeit
Besseres anfangen.
Ja, naja.
Ich meine, die
anderen Sachen haben ja auch so ein bisschen was für sich.
Du meinst, die sind charmant.
Nee, es ist nicht nur,
tatsächlich bist du dann halt eben
nicht auf eine Idee angewiesen, zum Beispiel.
Und du kannst halt schöner allgemeiner
Ja, aber ich weiß nicht, ob das jetzt ein Feature
oder ein Feed ist, dass ich nicht auf
eine IDE angewiesen sein muss. Also come on.
Ja.
Also inzwischen bin ich da ja nicht mehr so.
Der Entharkt ist nur mit meinem BI gestrandet auf meinem
Telefonsitze. Okay, maybe.
Nein, aber ich meine, vor ein paar Jahren
hätte ich dann auch gesagt, so IDE ist das.
Alles Quatsch. Auch keiner
BI. Ja.
Aber inzwischen,
ich meine, ich habe ja einfach mir dann vorgenommen, okay,
bevor ich dann irgendwie mal so
rente, muss ich das mal ausprobiert haben
und habe dann jetzt mehr Peitschamen gemacht,
mehr VS Code und muss sagen, ach ja, das ist eigentlich schon ganz okay.
Aber...
Ja, ich probiere es ja gerade einen anderen Weg herum.
Ich versuche gerade so ein bisschen wie Eis zu lernen nochmal, aber
ja, das ist halt, die Konfiguration
ist so ein bisschen pain, aber wenn man einmal durchgestiegen ist,
dann geht es so ein bisschen, also, aber ich sage mal, das Produktivitätslevel
ist schon ganz nett für
bestimmte TAS, aber für bestimmte TAS halt einfach auch nicht.
Ja, also
genau, also ich will,
ja, es gibt Gründe, warum es so ist,
es ist und das ist auch eigentlich gut.
Aber, ach, naja,
vielleicht Romantik.
Ich glaube, wenn man neu anfängt,
ist es so ein bisschen, ja. Ja, dann machen wir das
vielleicht einfach gar nicht.
Die ganzen,
was haben wir denn?
Ach so, Flask
auch irgendwie gibt,
jedenfalls die alte,
also Flask 2.0 ist ja auch noch nicht so
lange her. Das kann
auch SGI, aber Flask war
sehr stark an WSGI
dran gebunden und deswegen
ist eigentlich
also Flask
unter 2, das wird mit SGI nie funktionieren.
Das ist immer fest auf.
Deswegen nimmt man ja neue Software. Genau, also
insofern, das ist halt sowas, wenn man jetzt
irgendwie was mit WebSockets machen wollen würde.
Ich glaube, WebSockets hat man auch
noch nicht so richtig. Dann
ist Flask, also jedenfalls das alte Flask,
nicht unbedingt, ich glaube, Flask 2.0 geht
vielleicht und Quad
geht halt auch oder vielleicht ist
Quad und 2 plus 2 0 aufgegangen.
Ich weiß es gar nicht mehr so genau.
Aber das alte geht auf jeden Fall
nicht so richtig.
Fast API, kein Problem,
geht einfach so. Und das ist natürlich
auch nett, weil für manche Sachen braucht man das ja
vielleicht schon. Wobei
ich da inzwischen so ein bisschen,
ich habe das ja auch benutzt und habe extra
irgendwie, naja gut, wenn man
ein Fast API machen möchte,
dann kann man natürlich auch direkt
mit allen Pfeifen
und Witzels
und Websocket und so machen.
Dachte ich dann und
hab das dann halt auch mal benutzt.
Du hast auch ein Tutorial dafür gemacht
auf YouTube, glaube ich, wo das ein bisschen
gezeigt wird, FastAPI. Habe ich das mal gemacht?
Zumindest das Topic, was du dann
wirklich gemacht hast. Ich glaube, das ist einfach
nur gestreamt. Das ist einfach nicht
das Einzige, wo ich mir mal was
geplant habe, war zu
NaiveBase implementieren. Da habe ich vorher mal überlegt, was ich
dann implementieren will eigentlich. Die ganzen
anderen Streams sind alle einfach nur so
alle furchtbar. So kann man es auch
umschreiben. Und das ist einfach nur so, ich setze mich hin
und programmiere irgendwas. Und das ist natürlich manchmal spannend,
häufig total langweilig.
Aber für mich, der Vorteil dabei ist
wenig Verbreitungsaufwand.
Man kann das sehen, wenn ihr Jochen mal sehen wollt,
dann könnt ihr mal da reingucken.
Vielleicht sollte ich aber ein bisschen mehr
besser produzierte Geschichten
machen, das ist vielleicht gar nicht so blöd.
Ich habe jetzt sowieso nicht so viel Zeit mehr, irgendwie Streams zu machen.
Wir haben gehört, du sollst einen Didaktik-Code machen, Jochen, haben wir
eine Empfehlung bekommen.
Ja, genau, die ganzen
R's und Übers. Ja, das stimmt.
Ich wäre eher für Didaktik.
Didaktik.
Ja, gut.
Eigentlich am besten alles austauschen.
Didaktik, Rhetorik.
Das Gesicht. Ja.
Ich verstehe schon.
Ja, ein bisschen Schminke hier und da.
Ja, also jetzt,
ich komme sowieso nicht mehr so häufig zum Streamen,
oder habe das auch noch nicht geschafft,
einen Schedule hinzukriegen, wo der irgendwie funktioniert.
daher, vielleicht mache ich das einfach so.
Dann habe ich ja in der Zeit, wo ich,
bereite ich vielleicht was vor und dann mache ich das halt irgendwie mal ein bisschen
besser vorbereitet und dann halt seltener.
Einmal die Woche reicht vielleicht. Einmal die Woche oder alle zwei
Wochen oder sowas und dann halt dafür, aber
vielleicht irgendein Thema ein bisschen fokussierter.
Ja, muss man gucken.
Gut, dann kannst du auch wieder Gäste einladen, wie mich.
Ja, gerne.
Aber every day dann da, da bin ich raus, wenn du da
anfängst, deine Tests neu zu schreiben
oder irgendwelche Pakete nachzunstallieren.
Ja.
Ist ja auch mal nett zu sehen.
Wir haben jetzt davon 100 Folgen oder was archiviert
auf unserer Podcast-YouTube-Seite.
Ja.
Das war schon einiges.
Ja, ja, schon einiges.
Ja, klar.
Genau.
Was hatte ich denn noch?
Ach genau, WebSockets, genau.
Dafür hatte ich WebSockets so ein bisschen verwendet.
Und ja, also ich dachte so, okay, wenn man das denn verwenden kann,
das wäre einfach voll cool, dann machen wir das einfach so.
Das geht tatsächlich ganz gut mit Class-App, gell?
Das geht auch sehr gut, ja.
Also wenn man so einen Anwendungshalter dafür hat,
Aber diesen Webzock ist jetzt prinzipiell
auf die Nerven gegangen, habe ich gemerkt.
Also es war schwieriger, als ich jetzt gedacht
hätte. Ich bin da auf viele Dinge
gestoßen, wo ich schon das Gefühl habe,
war ja, das ist gar nicht so einfach.
Und also fängt
halt schon, und zwar nicht nur auf, also auf der
Serverseite muss man halt aufpassen, wenn man da halt irgendwie
was verwendet, was halt nicht gut damit klarkommt,
dass man halt immer eine Verbindung offen
halten muss, dann
ist es halt schlecht. Also wenn man
halt irgendwie so sich darüber keine Gedanken macht,
oder sowas und dann wieder da irgendwie hin.
Und benutzt halt einfach WebSockers einfach so.
Dann kriegt man Probleme.
Mit FastAPI geht das, aber
naja. Und dann ist halt die Frage, wie gut kann man das so
verwenden? Das geht mit FastAPI
oder geht auch ganz gut.
Und dann ist
aber noch die Client-Seite auch schwierig. Das ist halt nicht so
richtig einfach. Weil was passiert zum Beispiel, wenn
jetzt die Server-Seite sich
neu startet?
Du musst eine neue Verbindung bekommen.
Ja, du musst halt retryen. Weil ansonsten, wenn du einfach nichts
machst, dann ist die Verbindung halt weg. Und das bedeutet,
weg, tot, aus. Genau, du kriegst einfach keine
Absätze mehr. Aus die Maus, danke, nein, das war's, tschüss.
Ja, das heißt, du musst reconnecten.
So, jetzt seht ihr das erste
Reconnect vielleicht nicht, dann, okay,
vielleicht noch einen zweiten. Dann gibt's halt unterschiedliche
Sachen, die auftreten können. Auf die musst du
irgendwie reagieren. Dann,
und dann wird's halt... Ami-Quota exceded.
Ja, dann,
ja, auch auf der Serverseite auch wieder
so ein Problem. Du musst halt dann die Sachen,
du weißt ja nicht unter Umständen, wo du dann
landest, ja, also entweder du hast nur einen einzigen Prozess,
das ist aber vielleicht dann noch ein bisschen wenig, oder
du musst halt dafür sorgen, dass die alle gleich sind
irgendwie in gewisser Weise, dass du auf alle
connecten kannst und es immer das Gleiche dann
passiert. Ach ja,
aber so wirklich,
also was dann wirklich
so ein bisschen so Software-Architektur-Problem wird,
ist halt sowas wie,
du kriegst jetzt die unterschiedlichen Informationen
rein, halt einmal über einen Websocket, kriegst du halt irgendwelche Events,
dass irgendwas passiert ist, du holst
aber auch manchmal Sachen. Und manchmal sind das ja die gleichen
Informationen. Nur in dem einen Fall holst du sie halt
so eine HTTP-JSON-API
und im anderen Fall kriegst du es halt über einen Websocket rein.
Und jetzt musst du es halt irgendwie so chronisieren.
Du darfst halt nicht Sachen doppelt zählen oder so.
Und dann musst du das halt irgendwie
abstrahieren, dass du in dem
Teil, wo du halt
deine Wahrheit über den
Application-State halt hältst, zum Beispiel
in Vue, in so einem Pinia-Store
oder sowas, musst du
halt so wegabstrahieren,
dass es dir an der Stelle egal sein kann, ob das jetzt
über einen Websocket kam oder woanders her oder so. Und dann musst du halt
anfangen, so, muss er schon ein Software-Struktur
machen, so ein Frontend.
Oh nein, wer macht denn das?
Wer kennt schon nicht so richtig
hin und wer macht das denn sauber?
Pinia war ein guter Sighted, das ist nämlich für
einen Superstore, ich finde den auch sehr viel angenehmer
zu schreiben als Vuex,
den man für Vue.js nehmen kann, ja.
Ja, gefällt mir auch sehr gut, aber
tatsächlich irgendwie, manchmal
habe ich auch so Dinge, wo ich denke, oh okay, der Zustand
ist jetzt aber nicht, warum steht denn da, da ist irgendwas
übrig geblieben und da ist irgendwas inkonsistent, wie ist das denn
passiert? Das kann ja jetzt eigentlich gar nicht sein.
Es ist schon so ein bisschen hakelig und
man muss da drüber nachdenken und es ist
alles nicht mehr so einfach. Also das ist,
hätte ich jetzt gar nicht so erwartet, dass
das so kompliziert auch ist
irgendwie. Also, aber es ist halt irgendwie,
ist halt tatsächlich... Ich habe ehrlich gesagt
auch State immer noch nicht so genau verstanden. Also, weil es ist
irgendwas, irgendeine Wahrheit hat irgendwer in der Hand
und der hat den Ball nicht in die richtige Stelle
geschmissen und die Frage ist, wer sammelt denn alle
Bälle ein, um hinterher die wieder weiter zu verteilen?
Also irgendwie so. Das ist so ein bisschen dumm.
Ja, es ist halt das,
woraus quasi dann
das, was du von der Applikation siehst,
gerendert wird. Und wenn sich das ändert, sollte sich das halt
im Spaß ändern. Ja, Single Source of Truth.
Wer weiß das denn überhaupt? Manche Leute rendern ja
irgendwas, obwohl es gar nicht stimmt.
Was auch nicht immer falsch sein muss, vielleicht.
Vielleicht muss man auch manchmal da gucken,
was ist denn wichtiger? Dass man lange
wartet, bis man weiß, was wahr ist?
Nö, man kann ja auch einfach dann so tun, als wüsste man es schon.
Genau. Und das stimmt ja vielleicht oft auch.
Vielleicht ja manchmal auch nicht. Und was macht man denn dann?
Und so. Und ja.
Ja, aber es wird halt schnell kompliziert.
Und genau, also das fand ich schon
ja so ein bisschen, also hätte ich
jetzt nicht so erwartet, dass es so schlimm ist.
Und dann eine andere Geschichte, die halt auch
dann irgendwann,
ich hätte nicht erwartet, dass es so leicht
ist, irgendwie
Polling zu verwenden. Also jetzt mit
HTMLX zum Beispiel,
es ist halt super easy
irgendwie, weil, also ich meine, was ich
früher halt so gesagt hatte, so, oh, pollen, oh mein Gott,
also einmal, das macht viel Last auf dem Server, weil du pollst ja die ganze
Zeit, ne, wenn jetzt viele Leute auf deiner Seite
sind, dann pollen die die ganze Zeit, super,
toll, irgendwie habe ich irgendwie viel mehr
Requests, als ich eigentlich bräuchte
und so.
Da muss ich irgendwie
sicherstellen, dass das JavaScript auch irgendwann aufhört zu
poilen.
In der letzten Unterhaltung darüber, da sagtest du, poilen, das will man überhaupt
nicht machen. Genau. Ruhigbar. Ja, ja, ja, aber
habe ich jetzt inzwischen dann doch, glaube ich, meine Meinung geändert,
weil, wenn man das halt so einfach hinschreiben
kann, wie in HTMLX, wo man schreibt halt
every two seconds oder so,
schreibt man ein Attribut, das war's.
Mehr macht man gar nicht. Und auf der
Server-Seite schickt man halt,
man kontrolliert es von der Server-Seite aus und nicht
von der JavaScript-Seite aus. Und von der
Server-Seite aus schickt man halt so
einen Status-Code 286 zurück.
Ich weiß nicht, der heißt irgendwie auch sowas wie
Stop-Polling oder sowas. Und dann
hört es einfach auf. Und in Stop-Polling steht auch
wie lange, glaube ich sogar, ne? Ja.
Kann man alles irgendwie setzen und man kann halt auch
behalten. Ja, klarerweise, ich glaube, wenn du
einen bestimmten Code machst, also ich glaube 419
kann das auch sein, dass man dann sagt, ey, hör auf
jetzt. Besonders wie lange, sonst wirst du
gebannt oder so. Vier, wie hieß
der Client hat irgendwas falsch gemacht. Ich weiß es nicht so genau.
Keine Ahnung. Aber ja, man kann da auf jeden Fall viel machen.
Und man kann sogar
das halt einfach so machen, dass man das
Element, was halt pollt oder so, einfach austauscht
mit OuterHTML und dann
kann man einfach das Poll-Ding wegnehmen.
Also das Neueste ist ja AuthenticationTimeout.
Und sobald jemand auf irgendwas anderes draufdrückt,
kann man out of band aber das Pollen ja wieder aktivieren
und so. Das heißt, also eigentlich
für ganz viele Fälle, wo man halt
mal eine Zeit lang irgendwie so Live-Updates oder so
braucht auf einer Seite, kann man
das mit Polling relativ schmerzfrei
machen. Und das war mir
vorher nicht so klar. Da hätte ich gedacht, oh Mann, das ist ja alles ganz
furchtbar. Und da würde ich jetzt sagen,
über die aus der
HTMX-Erfahrung heraus würde ich sagen, also das ist gar nicht
so schlimm. Das geht eigentlich relativ gut.
Und der Riesenvorteil ist halt, es ist komplett
stateless. Es funktioniert mit
irgendwie uralten, es funktioniert
mit ganz so einem Standard-Kram, den man halt so verwendet.
Braucht nicht irgendwie SGI oder
Django Channels oder sonst irgendwas. Es funktioniert mit dem
ganz normalen Stack, den man hat.
Ja.
Und dann, ja.
Vielleicht doch leifer, als man denkt.
Da ist jetzt nur die Frage halt, wenn man
viele Clients hat, die einen pollen wollen, ist das vielleicht
dann doch doof. Ja, aber man
hat das ja unter Kontrolle. Wenn du sagst, okay, das ist mir
jetzt zu viel, dann sagst du halt, okay, dann
polle ich halt nicht jede Sekunde, sondern alle zwei Sekunden
hast du schon die Last um die Hälfte gesenkt.
Wenn trotzdem eine Million Leute
alle zwei Sekunden fragen, ist das vielleicht doof, weil es so viel
auf einmal sind. Kannst ja dann irgendwann einen Mehrserver kaufen
und kannst dir dann überlegen, was du machst. Ja, okay, genau.
Aber das ist halt dann, man weiß
dann an welcher Linie des Problems,
in welcher Achse man sich dann abarbeiten kann.
Ja, also das war
schon so ein bisschen, also wenn ich mit dem Wissen von
jetzt, würde ich das nicht nochmal mit wegversorgen.
Aber jetzt habe ich es halt schon gemacht.
Ja, weil ihr könnt ja sehen, wie Jochen es versucht hat.
Das ist ja auch manchmal ganz amüsant.
Ja. Dann hast du hoffentlich noch
einen Pick. Ach, Picks. Dann machen wir jetzt Picks.
Ja, gut.
Ja, also mein Pick für
diesmal wäre
Honsho. Honsho.
Ist das eine Insel?
Ne, das ist
Hauptinsel
Ich weiß gar nicht, wo der Name herkommt
ehrlich gesagt, so grübel ich da gerade
Ne, das ist
es gibt in der Ruby-Welt
gibt es ein Ding, das nennt sich Formen
ist da relativ populär
und Honshu ist das auch, da ist eine
Python-Nachimplementation davon
und das benutzt man, um
ein
Proc-File
zu lesen und dann Dinge, die
darin stehen, zu starten und zu stoppen
Also quasi, wenn man jetzt
so was, man kennt das vielleicht mit Docker-Compose,
Docker-Compose, Minus-F, irgendeine
Config, YAML-Config, Up und
Down und so, dann passiert auch sowas, dann werden alle die
Dinger hochgefahren oder wieder runtergefahren oder so.
Also alle Docker-Container, die in der Compose-Vertrags-Schiene haben.
Jetzt möchte man aber vielleicht zum Beispiel, wenn man
irgendwie, so wie ich,
Docker ganz
nicht so gut
findet, nicht so gut
eher so Mittel
findet, dann
das nicht verwenden möchte und dann
ich hätte aber schon diese Funktion gerne, dass ich halt
mein komplettes System, das ich zum Entwickeln
brauche, einmal hochfahre und einmal runterfahren kann.
Dann kann man das halt in
so ein Proc-File reinschreiben, was man alles
dafür hochfahren muss und runterfahren muss.
Und dann nimmt man Honshu und sagt Honshu start und dann passiert
halt quasi genau das gleiche wie mit Docker-Corpus ab.
Okay, cool.
Nur, dass es halt nicht Docker ist, sondern
einfach ganz normale Prozesse, die gestartet werden.
Und Proc-File hat ja da auch den Format
Diverse-Hoster-Könner-Stack-Lesen, Heroku-Könner-Stack-Lesen.
Und dann kann man
sich eine Konfiguration bauen und dann werden auf dem Rechner
Sachen hoch und runter gefahren.
Ich meine, der Nachteil ist natürlich, es ist nicht isoliert,
der Vorteil ist natürlich, es ist nicht isoliert.
Ja, zum Beispiel ein Pattern, was ich halt in letzter Zeit,
wenn ich meine Sachen mache, tatsächlich viele Dinge,
die ich halt so bezahlt tue, da ist es eigentlich seit Jahren,
es ist halt immer Docker.
Es ist besser geworden, ja.
Davor war es mal eine Zeit lang Vagrant und Virtualbox und so.
Das war noch schrecklicher als Docker.
Aber Docker ist auch ziemlich schlimm.
Und das... Ist jetzt auch bezahlt übrigens,
für Corporates muss man jetzt da richtig...
Wobei die Grenzen sind halt so, dass da viele
nicht drunter fallen. Nur große Corporates müssen das eigentlich machen.
Ja, und wenn du so groß bist, dass du da drunter fallst,
dann ist es... Genau, dann...
Ja, wenn die Leute halt nicht freiwillig für Open Source
dann bereitstellen, dann ist das vielleicht schon ganz gut, dass die
zugezogen werden über ein Modell, aber ja.
Ja, aber genau, aber
tatsächlich würde ich jetzt mal so sagen, also
es geht schon viel Zeit dabei drauf.
Also bei mir jetzt so,
dass ich irgendwie Dinge...
Also morgens, wenn ich mich dransetze,
Irgendwie ist schon wieder einer von den Containern
gestorben oder so. Ich muss halt regelmäßig
Docker-Desktop neu
starten. Ja, ich verstehe auch nicht,
warum Docker ab und zu mal
einfach mal in den Container runterfällt.
Oder ich versuche einen zu stoppen und es geht
irgendwie nicht. Es bleibt irgendwie hängen. Dann kill ich das
irgendwie weg. Manchmal geht es, manchmal geht es nicht.
Dann irgendwie kriege ich
ganz seltsame Fehlermeldungen aus den Tiefen
von irgendwie von Docker.
Und dann liegt es aber daran,
dass intern irgendwie irgendein Teil
ist halt vollgelaufen.
Die Logs von vor drei Jahren sind immer noch ein,
anstatt dass man auf die Idee kommt, wenn es mal komplett
rebuildet ist, dass es wieder von vorne an.
Und wenn man darin debuggen will, es geht schon,
es ist aber alles irgendwie und alles ist langsam.
Es ist halt alles lahm.
Es fühlt sich alles so an.
Es braucht relativ viel Ressourcen.
Ja, genau. Ich bin vielleicht besonders
gestraft, weil ich halt
auf einer Mac-Plattform bin und da ist es halt besonders langsam.
Aber es ist wirklich
es ist so ein bisschen, es ist wirklich aufwendig.
Also ich bin nicht
es kostet
wirklich Zeit, irgendwie das halt zu
verwenden und es macht alles ein bisschen
schwieriger und für meine eigenen Sachen
mache ich das, also da habe ich jetzt den Vergleich, da mache ich das halt nicht so.
Ein Pattern, das ich da halt verwende,
ist eben, ich verwende halt sowas oder
auch ganz lange nicht Honcho verwendet, aber
verwende jetzt dann halt vielleicht Honcho und
den Applikationsverlauf oder das Ding, an dem ich
gerade entwickle, das starte ich dann halt
in der IDE mit dem Debugger zum Beispiel
und kann da halt dann schön drin debuggen.
Ich kann, wenn ich auf den Test ausführen klicke,
ist es halt sofort, sofort ausgeführt,
ja, und ich muss halt nicht erstmal 10 Sekunden warten,
bis das irgendwie sich irgendwie in Docker reingetunnelt
hat und dann da irgendwie...
Ja, weil du erstmal alles die ganze Umgebung wiederbauen musst und so.
Und das
funktioniert tatsächlich ziemlich gut, ist eine sehr
angenehme Erfahrung, aber ja,
diesen, ja, ich weiß auch nicht, aber die Leute,
also in Firmen ist das wohl
offensichtlich inzwischen irgendwie verpflichtend,
Docker zu nehmen, naja.
Klingt gut, also Honschuhe.
Ich wollte...
Danke an Claudio für den Tipp, der hatte das
Ja, also ich wollte
ein Dango-Projekt
picken und zwar Health-Checks
heißt das.
Das ist sehr cool, weil
das kann man selber hosten, einfach Health-Checks und da
irgendwie seine Applikationen reinpacken.
Das ist natürlich ganz wichtig, dass der Health-Check
Server auf dem gleichen Server läuft
wie der Rest.
Ja, ich weiß
es nicht mehr genau.
Das ist ja in Dango-Server
drin, ja.
Ja, genau. Es ist ein Dago-Projekt, Dago-4-Projekt,
wo man halt relativ nett einfach
seinen Server, den man so überwachen
will, rein monitoren kann.
Ganz nettes, kleines Frontend, alles
relativ modern gebaut und
dann nur Postgres peißen, 3.8 glaube ich
und hochfahren,
Webfrontend benutzen,
wie man das halt von anderen Tools kennt, aber
self-hosted und light-white und schick.
Ja, cool, cool, cool.
Muss ich mir mal angucken, was das genau macht.
Ich dachte, das wäre jetzt in dem Ding, was man
innerhalb von Django hat, wo man dann von außen fragen kann,
ob da noch alles okay ist.
Einfach so ein normales Health-Check-Ding,
dass du halt einfach guckst, sind die Server, die du halt haben willst,
sind die noch da oder nicht und was macht das hinterher?
Okay, also eher so ein Monitoring-Tool.
Ja, ja, genau.
Muss ich mal angucken, weiß ich nicht.
Ja, ja, dann sind wir eigentlich, ne?
Ja, sind wir durch.
Vielen Dank, dass ihr wieder eingeschaltet habt.
Ihr habt uns gewogen, trotz Erwärmung.
Hört uns überall, wo ihr uns hören wollt.
Sagt Bescheid, was euch stört, an hallo-at-python-podcast.de.
Ja, oder wenn es euch nicht stört und gut gefällt,
dann könnt ihr auch gerne irgendwie
mal eine Bewertung hinterlassen bei iTunes oder
Spotify geht es jetzt auch bei uns mit Bewertungen.
Oh.
Ich finde das interessant.
Ich habe letztens drauf geguckt, es sind ja auch nicht so viele,
aber es ist halt quasi sehr ähnlich zu den
iTunes-Geschichten. Also es ist auf jeden Fall
konsistent. Das ist schon mal...
Ein paar Leute finden es gut, ein paar Leute finden es doof.
Ja, so ist es halt.
So kann man nichts gegen machen.
Ist auch völlig in Ordnung.
Wie gesagt, Feedback, teilt uns das immer gerne mit.
Genau.
Wir dürfen jetzt eigentlich mal angeben.
Ich glaube, wir dürfen angeben.
Letztes Jahr waren wir über 100 Tage, glaube ich,
in Top-20-Tech-Podcast-Charts. Kann das sein?
Top-50, glaube ich, eher.
Nee, Top-20, weiß ich nicht.
Top-50 ist immer das, was...
Ja, aber relativ lang.
Und jetzt, also dieses Jahr, ich gucke mal,
weil dieses Jahr eigentlich schon die ganze Zeit.
Ja, vielleicht gibt es gar nicht mehr als 50, man weiß es nicht.
Ich gucke mal gerade, aber auf Spotify sind es quasi jetzt gerade so 3.000.
Subscriber. Ja, und wie viel sind
wir, ähm, welcher Platz
sind wir gerade beim Tech?
Und haben sie, glaube ich, gerade wieder rausgefallen.
Haha, tada!
Ja, wir lagen bestimmt an der letzten...
Ich weiß nicht, ob ich jetzt hier die
Spotify-Plattform promoten möchte, weil
ehrlich gesagt... Nein, wollen wir nicht.
Also die Spotify und Podcast ist jetzt irgendwie
vielleicht ein bisschen unglücklich.
Das ist ja ungefähr was, was wir so machen.
Ja, oi.
Ist ja völlig verpönt, okay.
Nein, hast du das mitgekriegt, diese
Joe Rogan-Geschichte und diese unsägliche
Mail, die der Spotify-CEO geschrieben hat.
Die Mail habe ich nicht gelesen, ich habe nur gehört, dass es
irgendeinen Stress gibt mit Joe Rogan, den ich nicht höre
und da habe ich mir gesagt, aha, okay,
die Leute, der hat irgendwelchen Scheiß erzählt und
ein Idiot und einige Leute verlassen jetzt die Plattform
und geben diesen Auftrag, blablabla, ist mir völlig egal.
Weißt du was, ich bin einer der wenigen Leute, die überhaupt kein Spotify
haben. Ach so, okay.
Ich weiß zwar auch nicht, warum unser Podcast da läuft, ich glaube,
jemand hatte die Idee, dass das unbedingt da laufen muss.
Mir ist das Ding völlig egal, ich höre meine Musik
tatsächlich auf anderen Quellen, also
auf Vinyl, falls es genau so ist, aber
boah.
Ich war da, ja, dann
aha, der feine Herr auf dem Vinyl.
Ich mag das halt,
wenn Python-Code gut aussieht, aber okay.
Andere Leute hören halt Sachen auf Vinyl.
Ja, also ich habe aber so ein modernes System,
damit kann ich mir auch jede digitale
Flak auf mein Vinyl schmeißen, wenn ich das
muss. Und dann kann ich sogar mit dem
auf dem Flak rumscratchen.
Das muss ich dann nicht so mit einer Tonspur von dir
aufprobieren.
Egal, aufdrucken.
Bleibt uns gewogen, bleibt wieder rein.
Bis dann, tschüss.