Transkript: FastAPI

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

Heute reden wir mit euch über Fast API.

Hi Jochen.

Ja, hallihallo, 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 unser Feedback gebt an hallo.pythonpodcast.de.

Genau.

Ja, machen wir wie immer so ein bisschen zuerst News oder so.

Heute haben wir auch keinen Gast irgendwie oder so, sondern dachten wir.

Nur wir zwei.

Nur wir zwei.

Das hatten wir.

Kriegen wir.

Ja, vielleicht können wir das auch gar nicht mehr mal schauen.

Ja, es gibt wieder heute ein bisschen Werbung.

Wir sind immer noch gesponsert.

Oh ja.

Also falls ihr es total doof findet, schreibt uns doch einfach, dann überlegen wir, ob er es direkt wir sein lassen.

Okay, ja, was haben wir denn so an News?

Wir haben also einen PEP, der eigentlich ganz interessant aussah.

PEP 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 die Leute schon viele Gedanken zu gemacht, was man damit machen könnte.

Worum ging es in der PEP?

Ja, um ein Log-File-Format.

Also das gibt es ja, also Log-Files zum Festnageln von.

Also nicht Log-Fightern,

Logan-Schlüssels, ja.

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 alles mal ein bisschen schwierig.

Und ja, da war halt die Idee, das mal so zu standardisieren, zumindest für Binary-Installationen, weil das geht eigentlich auch nur so richtig gut für Wheels, weil bei Source-Distribution 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 Breckcan, 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 nee, wurde abgelehnt.

Der war

nochmal Breckcan.

Ist einer aus dem Steering Council und auch irgendwie, der macht, glaube ich, eigentlich ist der so der verantwortliche VS Code Python-Integration bei Microsoft, aber der ist eigentlich eine ganz bekannte Figur da in der Python-Entwicklungssystem.

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 Real gibt, das locken.

Und dann ist halt irgendwie viele sagen werden, das bringt da nicht so viel.

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 nochmal was ganzes, keine Ahnung.

Mal abwarten.

Das ist das Packaging-Problem.

Den Source in einen ZIP runterladen, den ZIP hashen und dann entpacken.

Naja, also ist es nicht so einfach.

Ja.

Nächste, was sehr schön ist, WebAssembly.

WebAssembly ist C-Python kompiliert, komplett nach wirklich das richtige C-Python, nicht irgendwie kompiliert nach WebAssembly und ja, kann man einen Browser ausführen.

Also es gehen dann natürlich noch viele Dinge noch nicht, aber dass das überhaupt klappt, ist halt schon mal irgendwie sehr interessant und

wann kann man tatsächlich Python schreiben, in C-Python kompilieren und dann einfach im Browser laufen.

Nee, du, nee, der kompiliert man nichts.

Du nimmst einfach, nein, nein, der C-Python ist der Interpreter von Python.

Der NPD 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 dann bekannt.

Dann kannst du das ausführen.

Ist natürlich so, die ganze Umgebung und so, dass es natürlich dann nicht so wirklich wie normalerweise ist.

Du musst halt eine rechte Beschränkung klarkommen, das es dann wahrscheinlich gibt.

Ja, und noch diverse andere Geschichte, 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.

Nee, also das für das, 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 das so ein Use Case von so WebAssembly-Zeugs?

Ja, zum Beispiel eben im Browser halt laufen, aber auch eventuell in der 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 halt ganz viel optimierter Kram auch für JavaScript schon drin, aber auch für WebAssembly, also es ist 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.

Nee, aber 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<unk>, Objective, C, Swift, ja.

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.

Okay, das nächste Mal bei den Penn-Apps für Telefone in Python schreiben.

Genau, was ja auch so ein anderes Problem ist.

Also die beiden Hauptdinge, 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 es halt, dass die Story für Python da nicht so gut ist.

Aber gut, dass das in die richtige Richtung geht dann.

Ja, genau.

Christian Heimes, Hamburger Python-User-Group 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 is stable.

Das ist, ähm, ja, genau, das ist toll.

Oder manche Leute finden das auch schrecklich, aber ich finde es eigentlich, das ist 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 Support für Python 13-Syntax und so und ja, eine ganze lange Liste von Dingen, die da irgendwie sind.

Und damit ist jetzt auch die DIP, die Django Enhancement Proposal.

Ah, ja, ja, ja.

Django Enhancement Proposal 8 sagt irgendwie, lass doch mal Autoformater 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 schon mal dadurch drü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 Darka ist halt inkrementelles Black Bike-Comits mit Hooks

zum Beispiel.

Ja.

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.

Das ist ein schon 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 HTMX-Episode von letztem Mal.

Es gab ja 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 HTOS-Ding, was ist das eigentlich und so?

Und hab dann gesehen, es gibt ein Essay von dem Carson Gross dazu, wo er beschreibt, wie er das sich so gedacht hat.

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

Und dann kann der Link da halt entweder drin sein oder nicht.

Und dein Browser muss halt nicht wissen quasi.

Das heißt, der State ist dann ein.

Ja, genau, dein Browser muss nicht wissen, dass du dein Konto überzogen hast, um der zeigt einfach nur Formulare an und das Formular zum Überweisen zeigt dir da 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 hast du halt in der, kriegst du halt nur dir eine 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 die Shownotes.

Also ich fand, daran kann man eigentlich ganz schön sehen, was da eigentlich so gemeint ist mit Hyper Media SC Engine of Application State, nicht.

Okay.

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 es ist 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, also du kannst schon ein bisschen was mitmachen und ja, also freut mich auf jeden Fall auch, dass die Ergebnisse dann halt allen hinterher zugutekommen.

Das wäre aber 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 das ist ja mal, solche Nachrichten sind auch gute Nachrichten für mich.

Ja, okay.

Apropos Open Source, weil das ja Open Source hast, da gab es auch irgendwie noch eine Meldung von uns für.

Ja, Oliver hat mittlerweile einen Kommentar zu einer Open Source-Episode, glaube ich, hinterlassen und meinte, da, da, kennt ihr eigentlich diesen Prototype-Fund?

Und nö, kannte ich zumindest überhaupt gar nicht.

Ja, man sagte mir auch nichts, ja.

Und was ist das?

Das ist irgendwie ein Fonds, der aufgelegt ist, das ist das irgendwie Bildungsministerium zahlt dann irgendwie für, also das geht vom Jahr 2016 bis 2024, 25 Projekte und 16 Förderungsrunden und also ja, dass man natürlich jetzt mit 2022 so mittendrin oder am Ende eigentlich schon fast.

Wenn man jetzt einen Schwarzantrag schreiben will, also das Produkt ist wahrscheinlich immer der zweite Antrag, ist relativ lang.

Aber ja, wie immer so bei solchen Dingen.

Aber wie viel kriegt man 50k für sechs Monate?

47.500 Euro.

Für sechs Monate maximal, also vielleicht auch weniger.

Doch, dass das so, oh, für ein Team.

Die Hälfte, ja.

Nee, ich habe überlegt, 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.

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 von finanziell ist das jetzt nicht so super attraktiv, ehrlich gesagt.

Und für ein Team ist das natürlich, ja, nee.

Ja.

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 mal nicht so schlecht.

Und vielleicht weiß ja jemand noch nicht, dass es gibt.

Ja, und wenn jemand zum Beispiel gerade nach dem Studium damit durchaus zufrieden sein kann und dann damit was probieren kann und damit kümmert, wird das doch schon mal super.

Genau.

Ja, dann, äh, das war auch jetzt vor ganz kurzem EdgeDB 1.0 Release ist vielleicht auch interessant.

Ja, muss man eigentlich, weiß ich nicht, ob man da so en 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 Impact Object-Relational.

Also du hast ja halt immer das Projekt, äh, das Problem in objektorientierten Sprachen, das mappt halt nicht so richtig gut auf relationale Datenbanken.

Relationale Datenbanken ist halt so eine Idee aus Anfang, so Anfang der 70er und eigentlich eine ziemlich coole Idee, aber damals gab es objektorientierte Programmierung und so, das 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?

Dann gibt es im Grunde zwei wesentlich, also du kannst auch hohe SQL-Stensen natürlich schreiben, aber es ist halt so ein bisschen unhandlich.

Die meisten verwenden dann eben ORMs, also so Object Relational Mapper.

Wie den von Django oder Pee Wee oder so.

Genau, oder SQL Alchemy ist für Python vielleicht der bekannteste.

Und da gibt es zwei grundsätzlich unterschiedliche Pattern.

Das eine ist Active Record-Pattern, was halt Ruby on Rails verwendet, Django verwendet es auch, oder halt Data Mapper Pattern, das verwendet SQL Alchemy, halt so, die haben halt so ihre Trade-Offs, also haben halt Vorteile, Nachteile, es kommt, 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 da halt, ja, also man muss mit den Dingern auch teilweise so 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 es halt eher so, dass es zu dem, dass halt die Datenhaltung auch zu dem, 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, es ist halt immer so ein Fremdkörper, ja.

Selbst wenn man es mit einem ORM macht, ist es halt, es sieht immer komisch aus, es ist immer ein bisschen eigenartig, es passt halt nicht so richtig.

Und ja, genau, dafür haben sich eine neue Sprache überlegt, da haben dann gesagt, so das eigentliche Problem ist halt, warum die OMs 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, dass 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 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.

Und das Gesamtstatements sind irgendwie, ja.

Und genau, all diese Dinge sind halt bei Edge QL oder so, ist glaube ich dann die Sprache besser, sozusagen an.

Aber da weiß man nicht so genau.

Es 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 es hört sich auf jeden Fall interessant an, kann man sich aber angucken.

Und es ist halt so eine Mischung, es ist basiertes, also das, was sie da gebaut haben, ist, also 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 mal so ein Ding.

Ist eigentlich gar nicht so klar, warum jetzt relationale Datenbanken gewonnen haben gegenüber den Graphen-Datenbanken.

Und es gibt ja auch noch Graphendatenbanken, Neo4j oder diverse andere D-Graph-Zeugs und ja, eigentlich will man beides irgendwie haben.

Und in Postgres kann man das ja ganz gut auch abbilden und dann haben sie ja halt irgendwie so ein Layer über Postgres gelegt.

Ah, wie es halt ein Layer über Postgres klingt ja spannend.

Also klingt auch so, als könnte man das mit Fast API gut benutzen.

Ja.

Ja, ja, ist auch Async, die haben auch, also die Leute, die das gemacht haben, das sind bekannte Leute.

Das ist nicht so, dass es irgendwie aus dem Nichts kommt, sondern da, äh, der CEO, glaube ich, 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.

Und ja, der ist, äh, wie heißt der, Juri Selinarov, ich weiß nicht, Namen jetzt, der hat auch irgendwie an den Paps 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 irgendwie Keywords für Async and Await, also Syntaxunterstützung für diese ganzen Asyn-Geschichten haben.

Und hat er auch ganz viele Dinge implementiert und Lukas Langra hat irgendwie für LGB auch gearbeitet schon und ja, es ist alles typisiert, genau das ist auch sowas.

Den ersten Namen hatte ich das auch noch nicht gehört.

Welchen?

Lukas.

Der Release Manager von Python für 3.8, 3.9, 13.

Aha, okay.

Nee, nicht für 3.10 nicht, Quatsch.

Das ist uns, das aber für, oder vielleicht noch sogar früher, ich weiß es gar nicht mehr genau.

Und der, äh, ja, auch ganz alle, der hat ganz viel zu Type-Annotation-Geschichten gemacht.

Der hat Black geschrieben, genau.

Naja, also auch ist er bekannter Typ da, ähm, und ja, genau, der hätte, ähm, und Async.io hat halt mit halt auch viel zu tun.

Und die, äh, 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, äh, ja, dann haben sie, äh, dann haben sie UV-Loop geschrieben, ne?

Also das Ding, was halt unter Juve-Corn und so drunter liegt.

Also eine schnelle Async.io-Implementation, ja, die in der Standardbibliothek ist ja sozusagen nur eine Referenzinplation, aber die ist halt nicht schnell.

Und sie haben halt eine schnelle Version geschrieben.

Also ganz viel der Basisinfrastruktur, die man so, kommt da auch aus der Ecke schon.

Okay, okay.

Insofern, das sind schon Leute, die wissen, was sie da tun.

Und dann darf man auch ein bisschen Werbung für seine Projekte machen.

Genau.

Wobei, ja, Firma ist natürlich auch.

Was uns jetzt zu Werbung bringt.

Moment, Moment, wir sind noch nicht mit

den News durch.

Wir sind noch nicht mit den News durch.

Achso, hast du was Geheimes, was ich noch gar nicht weiß.

Also ein Punkt noch, genau, ich habe wieder Podcasts gehört, Programmierbar hat jetzt auch was über letzte Episode, das über Laravelle, PHP, äh, PHP, Livewire.

Das fand ich auch ganz interessant, weil immer so diese Verbindungen finde ich mal 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 Live View.

Ist aber schon ein bisschen älter als von 2019.

Ich dachte, ich hätte das jetzt gedacht, dass es jünger ist, aber es ist auch schon relativ lange quasi dabei, also bei diesem Trend, die Dinge jetzt wieder vom Server auszumachen.

Und der Autor von Livewire ist der gleiche wie der von Alpine.js.

Das ist halt, äh, wer ist er, Caleb?

Habe ich jetzt den Namen vergessen, aber irgendwas mit P.

Und Portio oder irgendwie so.

Und genau, der hat Alpine.js gebaut und halt aber auch LiveWire.

Und der wollte eigentlich ja sowas eben wie Phoenix Live View bauen.

Und dann ist aber das Problem mit einem PHP, äh, naja, also so WebSockets, also Phoenix Live View macht das ja über WebSockets.

Das geht halt mit PHP nicht so richtig, weil du hast halt den Asen-Teil in PHP nicht.

Also gibt es 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 also 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 ein 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-Anstonersstützung und so auch wahrscheinlich nie geben.

Von daher, aber offenbar scheint man, man braucht es auch nicht unbedingt.

Das ist interessant, da können wir vielleicht gleich nochmal drauf eingehen und sagen, warum oder was, fast API.

Genau, aber da könnte man das wahrscheinlich sehr gut machen, ja.

Ja, das war es.

Ich glaube, ich hatte es, das probiere ich nächstes Mal aus.

Habe ich auf Twitter gesehen, dachte ich, kann ich ja auch mal anbringen, wenn jemand anders das auch aus meiner Twitter hat jemand irgendwie geschrieben.

Letztens war ich für ein Zahnarzt und da hat er irgendwie gerückt, beziehungsweise.

Okay, nochmal.

Nicht ich.

Ich habe nur gelesen, ich habe es auf Twitter gelesen.

Ja, gut.

Da meinte 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, benutzt man Zahnseide, ja, Mund auf und dann so, was ist das denn hier?

Irgendwie benutzen Sie eigentlich Zahnseide, warum nicht?

Mach das doch mal bitte häufiger.

Und der meinte dann so, ja, ich hab dann, dann habe ich, also nachdem nachdem ich diese Zahnseitegeschichte darauf so hingewiesen worden bin, habe ich dann gefragt, ja, wie sieht es eigentlich bei Ihnen aus?

Machen Sie bergab.

Und überprüfen Sie die auch, ob Sie die ab und zu mal einspielen, ob das überhaupt geht.

Wäre schon gut, wenn man das macht.

Ansonsten.

Das ist ein Blackgeschichte, habe ich auch irgendwann irgendein Talk gesehen.

Kein Mitleid.

Schön.

Muss ich bemerken, muss ich auch mal versuchen anzubringen.

Ja, habe ich mir auch fest vorgenommen, den nächsten Tag zu.

Wenn Ihnen dann die Fragen kommt unten, machen Sie eigentlich Ihre Backups, ja.

Genau, ja.

So, aber jetzt, glaube ich, dann sind wir mit den News durch.

Ja, okay.

Okay, dann.

Dann wollen wir jetzt wieder Werbung schalten.

Also wir wollen, aber wir müssen natürlich.

Und wieder mit freundlicher Unterstützung heute von unserem Werbepartner NordVPN.

Da ist etwas Neues.

Ein Exklusiv Deal und ein Geschenk obendrauf zum NordVPN Geburtstag.

Und da

könnte auf den NordVPN.comPython-Podcast gehen und euch den Deal da sichern.

Und da gibt es auch so eine 30-Tage-Gall-Zurück-Garantie.

Genau.

Hatten wir auch letztes Mal schon.

Ja, genau, ich weiß nicht, benutzt du V-Fans irgendwie?

Relativ selten, aber ich glaube, zum Geoblocking-Umgehen ist das gar nicht so schön.

Das ist gar nicht so schlecht, ja.

Wenn du Streaming haben möchtest, dann möchtest du irgendwie das Streaming-Programm von zu Hause gucken, wenn du im Urlaub bist oder so, ist das doch gar nicht so cool.

Genau, also diese Geoblocking-Geschichten oder halt auch eben, wenn man sicherstellen möchte, dass die, 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.vpn.com.

Und mal angucken, was das von dir gibt.

Genau, damit würdet ihr uns unterstützen.

Dann machen wir weiter im Programm und gehen zu FastAPI.

Ja, FastAPI, das Thema.

Genau, das Thema unserer Folge.

Was ist denn Fast API überhaupt?

Also es ist ein weiteres Webframework, ein neues Webframework 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.

Dango ist sehr alt.

Also wenn ich das so richtig verstanden habe, ist Fast Abi quasi das neue Flask.

Ersetzt du das so ein bisschen, was man da gemacht hat?

Ja, ja, also es ist auf jeden Fall eher, also es kommt drauf an, aber auf jeden Fall ist es eher vergleichbar mit Flask quasi, was sie so den grundsätzlichen Ansatz angeht, aber ja, es ist halt auch irgendwie wieder so ein bisschen anders insofern.

Aber einfach historisch, man hatte so eine Explosion von irgendwie unterschiedlichen Webframework-Projekten irgendwann halt um diesen Dreh, wo die alle entstanden sind.

2004, 2005, 6, irgendwie so.

Pyramid ist auch aus der Zeit, oder?

Das weiß ich nicht.

Es kann sein, dass das auch später war, ich weiß es nicht so genau bei Pyramid, aber sag mal, so viele, viele Webframeworks kommen halt aus der Zeit.

Oder da gab es halt ganz, ganz viele.

Da gab es irgendwie so eine Zeit, wo irgendwie 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 Turbo Gears und ach, weiß 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, also die Enden von irgendwie so, also entweder Batteries included oder halt irgendwie sehr wenig dabei, aber dafür sehr flexibel.

Ja, und

genau, also der Unterricht auch mit den URMs hatten wir eben schon besprochen, dass halt Django den URM mitliefert und das bei FLAS meistens SQL Academy nimmst und.

Ja, aber kannst halt auch irgendwas anderes nehmen, also bist du halt nicht.

Hast du keine feste Bindung und ja, aber irgendwie so seit ein paar Jahren gibt es halt sowas ähnliches wieder.

Es gibt wieder viele neue Web-Frameworks, ne?

Also sowas wie, also was vor allen Dingen an der neuen Syntax bei Python, es liegt halt an der Sprache, dass sie die ganze Zeit

geändert hat.

Genau, an den Typings, die es dazu gekommen sind, die

Python, der Async iPhone benutzt.

Genau, das ist Async.

Und unter Fast API drunter liegt, ist ja Stalett.

Stallett, genau.

Ja, vielleicht kann man das so ein bisschen in die ganze Histor so ein bisschen kurz erzählen.

Also eben, wir sehen so Async Webframeworks jetzt wieder ganz viele, so Senic, Falcon, FastAPI, Quart, also jetzt gibt es auch wieder ganz viele.

Und ja, und der Autor von FastAPI hat sich auch viele angeguckt und hatte.

Sebastian Ramirez, also Tianjolo, genau.

Viele andere coole Sachen noch macht nebenbei neben dem Fast API.

Also Typer ist auch sehr ähnlich und dann gibt es auch SQL-Model, wenn man das irgendwie mit dem OM machen möchte.

Aber vielleicht erstmal nochmal was zu

sagen wolltest.

Genau, der hat viel Django gemacht oder viel mit anderen, der hat auch viele APIs gemacht und war auf der Suche nach einem Framework, das halt irgendwie bessere Entwickler-Experience irgendwie bietet.

Also Django Rest Framework oder so.

Ja.

Er fand das jetzt nicht schlecht, er fand das schon gut.

Also er hat sich ja halt auch, also diese 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 hat er, dann war aber ein Ding fast perfekt.

Also er hat sich, er hat sich zum Beispiel Django Rest Framework hat er sich viele Sachen angeguckt, die er gut fand, aber es war halt nicht, dann hat er sich Marshmallow angeguckt, bei Flask fand er auch gut, diese ganzen Validierungsgeschichten und Seralisierung von ganzen Objekthierarchien und so, aber das ist halt auch noch nicht so hundertprozentig das getroffen, was er irgendwie haben wollte.

Und es gab noch ein paar andere Sachen, die er sich auch angeguckt hat.

Und dann hat er sich dann der Autor von Jungle Rest Framework, Tom Christie, ist ja auch so ein, der hat ganz, ganz viele Projekte gemacht.

Und viele Dinge sind auch Basisinfrastruktur für ganz viele andere Sachen.

Also eben, er hat Jungle Rest Framework irgendwann mal geschrieben, dann hat er irgendwann Jungle Rest Framework quasi abgegeben oder macht es, weil es ehrlich gesagt ist 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, hat einen AP-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, äh, 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 Christi irgendwie angefangen, Starlet zu entwickeln.

Also auch ein Web-Framework, weil er basisinfrastrukturmäß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 besten zu seinen Anforderungen passte, hat plötzlich den Fokus gewechselt und was anderes gemacht.

Und dann dachte so, oh Mist, jetzt gibt es nichts mehr.

Jetzt muss ich irgendwie, muss ich es finden, ich wollte es wirklich vermeiden, aber jetzt muss ich es vielleicht doch selber in ein Webframe schreiben.

Und dann hat er das halt gemacht.

Und dabei ist FastAPI rausgekommen.

Und dabei hat er, glaube ich, relativ viel auch noch an Pythonic mit rumgewerkelt, wenn ich das so gesehen habe.

Ja, genau, Piedentic ist halt eine der Geschichten, die sonst nirgendwo drin sind, die halt da mit dabei sind.

Genau, weil halt, also so Erweiterung von Data Class ist 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 den Fragen.

Ja, also ganz lange der Standard für die Kommunikation zwischen irgendwie dem Applikations-Server, der halt irgendwie tatsächlich Requests annimmt und dann irgendwie die Kommunikation mit dem Browser tatsächlich macht, das machst du manchmal 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-Risky, nennt das auch.

Nicht dasselbe wie WhatDCs, What2Get Risky.

Sorry.

Das Ding, das ist auch ein super einfacher, also eigentlich ist das alles total trivial.

Aber das Gute, dass das halt ein Standard ist, das ist mehr oder weniger eine Funktion, die man halt implementieren muss und wenn man das tut, ist man halt einen WSGI-Server.

Der Grund, warum man da jetzt mal nochmal irgendwas anderes brauchte, also der kriegt im Wesentlichen eine Request, kommt rein, Response geht raus.

Das ist eigentlich.

Das, was man klassisch aus HTTP kennt.

Ja, genau.

Aber genau.

So, jetzt ist aber Dinge haben sich geändert und man will jetzt eventuell auch solche Dinge machen können wie Websockets oder halt, man hat halt eventuell lang laufende Requests.

Wenn man viel parallel machen, so dieses Bacing-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-Routine geht das ja super eigentlich.

Und genau, dann gibt es da, aber es gab keinen Standard und dann hat irgendwann, glaube ich, Andrew Godwin, auch bekannter Django-Django-Feldentwickler, der hatte das Migrations-Ding gebaut und so.

Der hat dann irgendwann in diesen SGI-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, man 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.

Scope.

Un Scope.

Genau.

Ja, aber da geht das halt, ne?

Da kannst du halt dann auch wieder Sachen nochmal empfangen und dann irgendwas machen und dann wieder was rausschicken.

Und musst halt nicht, bist halt nicht in diesem Request-Response-Ding so drin.

Ja, und genau.

Ja, und Fast API ist halt ein SGI-Server.

Und dann gibt es halt eine gute Implementation darunter.

Das ist UV-Corn, also UV-Loop, da hatten wir es schon.

Das ist halt das.

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 Episoden mal drüber.

Ja, vielleicht haben wir doch mal kurz erklären, weil sich alle Leute haben ja alle Episoden gehört.

Das ist halt eine Bibliothek, die wegabstrahiert, die diese Betriebssystem Suscalls wegabstrahiert, die man halt benutzen muss, um halt schnell Dinge zu machen, I.O.

zu machen.

Genau.

Und das ist halt unterschiedlich, je nachdem, was man verwendet unter Windows.

Das ist TCP-Completion Ports oder was oder was auch immer da verwendet, keine Ahnung.

Unter FreeBSD ist es halt KQ, KQ und Linux ist es halt E-Poll.

Und das Ding bietet halt ein Standardinterface für all diese Dinge.

Select Pol, ich weiß nicht, was das 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 Node.js hat das halt relativ, hat dazu halt diese Entwicklung da getrieben, ja, weil die haben das halt dann stark verwendet.

Und ja, mit den Async.io 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 Juve-Loop von den Leuten, die jetzt HDB gemacht haben.

Und auf Juve-Loop drauf sitzt halt Juve-Corn, also quasi so wie Gunicorn halt als Applikations-Server, der dann halt Webgeschichten macht und dann halt Juve-Loop benutzt, um halt schnell I.O.

machen zu können.

Und das ist auch wieder ein Projekt von Tom Christie.

Okay, ja, der weißt du die ganze Schwanz.

Genau, und dann 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 Stalett.

Ja, und Fast API benutzt Stalad.

Und ja, genau.

Aber die Idee ist im Grunde viele Sachen zu kombinieren, Pydentic zu kombinieren mit Typen-Annotationen, genau, mit einem Dependency-Injection, mit einer Dependency-Injection-Geschichte für Parameter und sowas.

Und ja, halt Stalet 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, gut, also ich habe mir jetzt einen Fast API-Source-Code auch so ein bisschen angeguckt mal.

Also, also ganz oft sieht man schon so irgendwie, naja, er importiert halt Sachen von Starlet und das war's.

Also die ganze Websocket-Modul in FastAPI ist halt irgendwie vom Starlet-Import-Websocket fertig.

Ja gut, also abstrahiert halt, ne?

Und dann einen anderen Abhieb vielleicht an ein zwei Stellen und wird halt gut integriert.

Genau.

Das, was man da haben möchte.

Und es ist halt, die Dokumentation ist halt schön geschrieben und so, er hat das dann irgendwann mal in Reddit, äh, auf irgendeinem irgendeiner Reddit-Group oder so angekündigt, irgendwie Fast API.

Und die Reaktionen waren da so ein bisschen geteilt.

Also ich finde das, ich finde das super, was er gemacht hat, aber Freddit wurde dann halt irgendwie, was man so, also diese Dokumentation und da sind so viele Emojis und das ist alles so mit diesen Gips, die sind.

Oh, so bunt.

Ja, da waren die ganzen, ganz seriösen Jungs, die alle die ganze Zeit keinen Humor haben und im Keller sitzen, die fand das überhaupt nicht witzig.

Die sagen so, das ist so gebraucht, Warnfas-Verkäufersstyle, 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 nicht so viel zu tun hatten.

Und gerade mit so Webcrams und ich glaube, der relativ gute Hinweis und so Querlings, man kann es wirklich, wenn man anfangen möchte, auch mit so Webframeworks, 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 dafür ist es 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 Rauchfahrerverkäufer ist man muss ja nicht immer Neuwagen kaufen, oder?

Das ist ein bisschen teuer und auch aus Sustainability-Gründen nicht immer so super.

Nee, also ja, im Grunde ist eine wirklich, wirklich schicke Geschichte.

Und überhaupt, ich würde mal sagen, also was daran halt neu ist, also ich sag sicherlich 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 viele Leute verwenden das.

Und das ist, 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 das diese Developer Experience Geschichte da so betont wird.

Das ist auch was, was man jetzt in letzter Zeit immer mehr sieht.

Von früher kenne ich das so nicht.

Da musste man noch alles von Hand und selber und zwar alles schön und hässlich.

Man hatte so, wirst du, dass das kryptisch ist und schwer zu installieren, das war so ein bisschen.

Oh, ja, deswegen macht man das.

Ja, genau.

Du musst ja erstmal beweisen, dass du mans genug bist irgendwie und hier das Pferd aus dem Stein ziehen, bevor du irgendwie so und dass man das den Entwicklern einfach macht und dass die da irgendwie einfach eine gute U-Tür.

Ja, das ist irgendwie so ein Ansatz, dass denen, also früher wäre das Leuten fremdartig vorgekommen, indem man sich sowas.

Aber heute ist das irgendwie, heute, ja, Zeiten haben sich gerne hat.

Ja, so will man das wahrscheinlich auch machen, weil man keine Lust hat, die ganze Zeit nur im Keller rumzusitzen, vielleicht.

Gut, dass 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.

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 und nicht so stachlich ist.

Okay.

Ja, vielleicht müssen wir einmal kurz darüber reden, wie der es macht.

Also zum Beispiel über Type-Annotations geht halt da ganz viel an den Minuten 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ß es aber nicht, ob es richtig ist, keine Ahnung.

Das hatte mich am Anfang, da würde ich danach da nach der, also klar, also man schreibt jetzt, also man hat auch immer, also die Dinger, die man halt in FastAP schreibt, sozusagen, die Endpunkte 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, ja, so, beziehungsweise bei Django wäre es halt so, da kommt ein Request rein, geht eine Response raus und dann pupelt man sich sozusagen aus dem Request die ganzen Sachen halt raus, die man so braucht.

Also aus den, da gibt es dann Request.get oder Request.get.

Oder ja, man nimmt dann halt den Body und dann gut, wenn man jetzt sowas wie REST Framework oder Formulare, nimmt man dann natürlich eine ganze Menge ab.

Oder Class-Based-Views oder sowas, ja.

Aber prinzipiell muss man sich den, ist der Teil, man poolet sich den Kram da selber halt raus.

Das ist bei FastAPI halt nicht so.

Fast API passiert halt sehr viel von dieser Magie direkt.

Wenn du die Type-Annotation richtig dran schreibst, dass halt du.

Man schreibt halt Type-Annotationen in die Parameter und dann kommen die Daten irgendwie magisch da rein.

Ja, also wenn man besonders cool wird, es halt, wenn man dazu Pydentic-Modelle verwendet als Parameter-Annotation, weil dann wird halt die Validierung von den Objekten, die da beispielsweise als JSON reinkommen oder so, direkt mit Pydentic durchgeführt.

Und das ist sehr cool, weil halt die ganzen Validierungen dabei sind, die kann man an einen Padentic 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 Daytime machen, deinen eigenen Parser dafür in dieses Padentik-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 AVI 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.

Also was man dann, also vielleicht an der Stelle nochmal ganz kurz würde ich gerne eingehen auf SQL-Model, weil man diese Piedentic-Modelle, die man dann halt netterweise geschrieben hat, mit SQL-Model, das ist auch ein Projekt von Sebastian Remirez, ist noch relativ am Anfang, also noch nicht so ganz produktionsreif, da waren noch so ein paar Breaking-Changes drin, aber dann kann man einfach diese SQL, diese Piedentic-Models direkt in der Datenbank speichern.

Und der nimmt das dann direkt und zum Beispiel mit dem CQ-IKEM drunter wird es halt direkt in die Datenbank geschrieben, die man da angeschlossen hat.

Was halt auch sehr angenehm ist, weil man dann 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 ein Modell schreibt und hat dann direkt seine Datenbank-Antestation 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 halt halt ein Datenbankschema drausgeneriert, aber sonst wird halt auch das Schema für die API daraus generiert und das ist halt in beiden Fällen gleich.

Genau.

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 auch in FastAPI mit drin direkt das Schema daraus rennen lassen.

Also als OpenIP-kompatibles Place oder so, dass das direkt mit drin muss man eigentlich eine Funktion aufrufen, dann ist das da.

Auch sehr schick.

Und also ich mache dabei mit SQL Akim die Migrations immer mit Alembic, damit ich so ein bisschen so eine Art Django-mäßiges Migration-System habe.

Das heißt, kannst du dann sowas machen wie Migrate schreiben oder so.

Oder es funktioniert ein bisschen anders.

Da sind halt andere Formen von Migrationen ran, aber die schreibt man eigentlich nur an der Datei an, da kann man relativ viel anpassen und dann macht dann auch relativ automatisch das Vor- und Drückspulen.

Das finde ich ganz schick.

Ja, aber gut, das ist aber dann irgendwie um diese Sachen, muss man sich dann halt selber so ein bisschen kümmern.

Ja, genau, das ist halt das, was Fast API nicht mitliefert im Vergleich zu Django 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, 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 einen Integer.

Und in Flask ist das halt nicht so.

Genau.

Das ist halt der, genau, dann diese Padentic-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, äh, das ist es, 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 relationale Datenbank darunter, weil der ORM ist halt so, wenn du den ORM nicht verwenden möchte, 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.

Das ist so ein

bisschen Pain, aber ja, lass das halt.

Also nicht über die Modelle.

So ein modularer Teil.

Also wenn man jetzt das mit SQL-Modell zum Beispiel verwendet, habe ich ja gerade versucht zu erzählen, dann genau diese Revisionen, die man halt hat, die kann man ja vor- und zurück spulen 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 Open-API, die du halt hast, wenn du eine Open-API-JSON hast oder sowas.

Achso, kannst du dir direkt die Pyden-Modern

die Piedentic-Modelle bauen lassen.

Ach, okay.

Und so hast

du dann halt dann die Sachen direkt, die du dann auch in eine Datenbank wegschreiben willst.

Also das ist halt auch schon sehr, sehr nett.

Ja, und

also 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, äh, dass das ist halt, man dann gegen das Framework arbeitet, wenn man jetzt irgendwie eine USQL verwendet mit Fast API.

Ja, das finde ich sehr, sehr schick.

Mit drin ist also FastAPI selber benutzt, ähm MakeDocs, MK Docs.

Ist auch sehr schick.

Ja, weißt du, von wem das ist?

Äh, nein.

Warte mal.

Ich müsste jetzt einen von den Namen sagen, die wir jetzt gerade eben schon erwähnt haben.

Von Chrissy ist auch.

Ja, okay, tatsächlich.

Ja, das ist echt erstaunlich.

Das ist irgendwie, ja, genau.

Ja.

Ja, auch ganz schick.

Also 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 es ist nichts Tolles, aber ein bisschen aus.

Ich habe damit auch nicht so viel gemacht.

Ich habe mir aber vorgenommen, dass ich das mal tun muss.

Ja, ich habe so ein bisschen Dango versucht zu enthinken.

Das ist vielleicht nicht immer ganz so cool, aber.

Typer ist da auch dabei.

Also so Commands-mäßig.

Was könnte man denn noch so alles erzählen über Fast API?

Ja, also vielleicht nochmal so ein bisschen, wie das funktioniert mit den Datentypen und den Dependency-Injection-System.

Man kann ja auch damit sowas machen wie Permissions oder sowas.

Nee, du sagen kannst, bestimmte Dinge müssen enthalten sein, wie Authentifizierung oder so.

Ja, also diese Magie, dass halt irgendwie man einfach nur die Annotation hinschreibt und dann die Werte so richtig bekommt.

Du kannst wahrscheinlich einfach so Depends on OS.

Also so abstrahiert.

Ja, nein, ich wollte nur gerade, das sind halt, das funktioniert über diese Pass-Operations geschrieben.

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 kriegt dann halt den ganzen Kram.

Dann kannst du halt Code wiederverwenden, der halt irgendwie, weiß ich nicht, irgendwas, eben ein O-Out-Token irgendwie validiert oder so.

Genau, genau.

Oder halt irgendwas anderes macht.

An der Stelleverbindung

reinreicht oder so.

Was ist denn eine Dependency natürlich?

Oh je, das ist auch so ein Ding, genau.

In der letzten Episode hat ja schon jemand gesagt, nee, 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 ein Pattern, kann man das so sagen?

Ja, ist irgendwie so ein Design-Pattern, kann man sagen.

Also wie man ein Objekt in eine Klasse reingibt, ohne dass man das jetzt mal neu definiert.

Nee, es ist eher so, dass du das halt umdrehst.

Also Dependency-Injection ist ein bisschen sozusagen das Ding, wie man die 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 da

was noch machen.

Okay, eben.

Also, weil du dann jetzt.

Du 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, deine 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 injectet hättest, sozusagen an der Stelle.

Und dann kannst du das halt in Tests halt auch ändern.

In Tests kannst du dann einfach sagen, ich weiß, wie er es in der Applikation, in der Fast API, also in dem Hauptapplikationsobjekt, kann man irgendwie sagen, Dependency Override, ich weiß nicht genau, wie das heißt.

Und dann kannst du halt definieren, was da injected werden soll.

Dann sagst du halt, Depends on Database bedeutet jetzt, gib mir einfach ein, weiß ich, anderes Objekt oder eine Testdatenbank.

Genau, und dann kannst du halt die Testdatenbank reinreißen oder du reißt halt irgendeinen Memory-Repository rein oder was auch immer.

Genau, und ja, das ist halt sozusagen eine Methode, um diese Sachen halt voneinander so zu entkoppeln.

Dass du halt nicht, weil, also eng gekoppelt 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, so, also das Konzept ist relativ elegant, aber die Implementation ist so ein bisschen.

Also da gibt es halt in Fast API so dieses Dependencies-Modul-Package und dann der Hauptinhalt der Implementation liegt in Utils PY und der ist schon schwer zu lesen.

Ja.

Aber es funktioniert auf jeden Fall.

Aber ich finde das Interesse, also du hast schon recht, weil ich hast du das eben genannt mit Dev-Friendly oder sowas.

Also ich finde das sehr angenehm.

Es ist halt darauf optimiert, dass man.

Also es ist

Ergebnisse zu erzeugen.

Wenn du irgendwie Jason rauspowern willst und hast nicht so viel Aufgaben, dann kannst du relativ schnell Erfolge damit erzählen,

finde ich.

Ja, ja, absolut.

Also 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 Source Code 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 ein Aufschrauben reingucken.

Das ist nicht irgendwie so ein Kabelsalat, der irgendwie so schraubst, das gibt es ja bei anderen Sachen, dann schraubst du das halt so auf, dann nimmst du die Abdeckung ab und nochmal so und dann platzt da so ein

Paket vertraut

raus, ja, so das ist, wenn du Apple-Dinger hast, ist es halt super ordentlich und alles.

So, und das ist halt, wenn du, wenn du, wenn du irgendwie Starlet dir den Hauscode anguckst, der ist halt auch so, ja, das ist halt irgendwie alles total so, wenn man sich Fast APIs Hauscode anguckt, das ist halt schon so, da hängt dann eher so, da hängt dann irgendwie Dinge von der Decke und aber.

Nee, also ich habe zum Beispiel in meinem Computer, wenn ich ihn aufschraube, habe ich auch so ein paar LEDs reingebaut, dass das

ja, genau, ist halt auch so ein bisschen Typfrage.

Ja, also ein bisschen Abnötig halt braucht man halt nicht, ne?

Rennt ja auch.

Ob man das jetzt hässlich findet oder hübsch ist.

Ja, also wichtig ist halt, dass die Luftzufuhr vernünftig ist, ne?

Dass es schön kühl ist und dass das schnell ist.

Ja, genau, aber auf der anderen Seite wiederum zum Beispiel, also auch das wiederum, da ist es halt unterschiedlich.

Auch der Sourcecode hat kaum Kommentare oder so, also so so Doc-Strings gibt es fast gar nicht.

Ich habe vielleicht zwei, drei Stellen gefunden, wo welche drin sind und Kommentare gibt es eigentlich auch nicht.

Ist mir auch schon ein paar Mal drüber gestolpert, weil ich muss mal gucken, aber dafür sind halt die Type-Annotations so aussagekräftig schon oft, dass

das auch.

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

Ja, ich fand das auch, also ich muss auch sagen, den Code selber, da wenn ich da reingucke,

wenn man ein bisschen suchen, was macht er denn jetzt?

Ja, dann geht das alles über Keyword-only-Argumente.

Was ja auch irgendwie, also es ist klar, dass das halt für jemanden, der eine Idee 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 außer so von früher hätte man gesagt so, oh mein Gott, was ist das denn?

Das ist ja schrecklich hässlich, ja, so warum nicht einfach hinschreiben, was man.

Und aber es ist halt so ein bisschen, also du verbietest ja mit diesem Stern erstmal, dass es irgendwelche Argumente gibt, außer den Kevertingern.

Auf der anderen Seite ist es natürlich so, wenn deine Idee dann halt anbieten kann, was du alles auswählen kannst an Dingen, die du da reingibst, ist natürlich für dich irgendwie angenehmer.

Also sozusagen deine Entwickler-Experience, wenn du das in einer Idee verwendest, ist halt besser.

Aber wenn du das jetzt mit dem Source-Code liest, ist es eher so ein bisschen ickidigit.

Ja, so, sag ich mal.

Igitig.

Ja, ja.

Dann würde man damit schnell arbeiten, ne?

Ja, also ich meine, heutzutage benutzen die Leute halt alle Idees und das irgendwie sind halt so, gucken halt darüber, was der Code denn macht und wenn du dann halt aber mit einem VI da sitzt und den Source Code liest, dann denkst du dir so, was ist das denn?

Ich verstehe diese modernen Zeiten nicht mehr.

Ja.

Aber ja, also.

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 ein paar Monate passen wird.

Ja, ich habe immer zu wenig Zeit, an das neben der Arbeit noch hinzubekommen, aber.

Naja, also ich finde es interessant.

Also es ist auf jeden Fall irgendwie so ein bisschen was anderes und das ist ja was.

Also ich mag es ja gerne, also zum Benutzen und zum Anfassen, das gibt einem so ein bisschen Speed auf der Straße.

Ja, das ist auf jeden Fall, also ich meine, Pydentic ist auch sowas, das ist halt 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 mir auch schon häufiger mal irgendwie Atris verwendet, das war eine 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.

Ja, ja, das ist also ein bisschen ein bisschen wie die neue Variante von dem Tubel.

Auf der anderen Seite muss man, ich habe jetzt nochmal geguckt, weil es gab jetzt bei DDF, da war ich, du warst 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, weil da Klaus gesprochen hat über wie schnell ist eigentlich Data Class im Vergleich zu einem alten.

Genau, der hat halt herausgefunden, dass Pydenk ein bisschen langsamer ist bei der Umformung von vielen Transaktionen, kann

das sein?

Nee, der hatte Pydentic gar nicht.

Der hat nur Data Classes.

Achso, dann hatte ich, 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, die sind inzwischen gar nicht mehr so schrecklich viel langsamer.

Ein bisschen langsamer sind es selber.

Und bei Pydentic habe ich es jetzt selber nochmal nachgeguckt, weil mich das interessiert hat, weil ich dachte so, okay, wie schlimm ist es denn eigentlich?

Und ich gut, ich habe das jetzt in meinem, ich habe kleine Objekte genommen, wo nicht viel Validierung so drauf ist, aber ich dachte, gut, es ist 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 irgendwie sowas wie JSON oder ein Dikt.

Ich habe immer einen Dikt genommen, nicht JSON, weil ich wollte jetzt nicht die JSON-Library Benchmarken, sondern einfach nur von Dikt zu irgendwie Objekt ist es so, dass Pydentic ist halt irgendwie so achtmal langsamer.

Also man beachtet ist schon und beim beim Serialisieren, also von Objekt zu, also Objekthierarchie zu irgendwie dict, ist es halt sogar irgendwie 20 Mal langsamer.

Und das ist natürlich schon, also es kommt drauf an, also

bei was wird das dann relevant, das ist vielleicht auch.

Genau, das ist halt die Frage.

Das ist halt, äh, also ich meine, irgendwie Serialisieren von irgendwie 100 Objekten, ich weiß, ich weiß jetzt gar nicht mehr genau, bis 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 halt dann so, geht in den Mikrosekundenbereich.

Also weiß ich nicht, kostet dann halt irgendwie vier, fünf Mikrosekunden.

Das ist alles relativ egal, solange das nur ein paar Objekte sind.

Wenn du jetzt aber sagst, du sind 100 oder 1000, bei 1000 könnte es sein, dass möglicherweise schon bei ein paar Millisekunden halt.

So ein paar Mikrosekunden mal 1000, das ist so 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 bei so Millionen Datensätze reden, irgendwie, die so gleichzeitig processert 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 dir serialisierst oder tausendmal ein Ding gleichzeitig ist ja egal.

Aber das Problem ist halt die CPU-Geschichte ist halt dann, ja, ist halt, die macht alles irgendwie dann 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, also, aber 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 imortieren kann, wo dann irgendwas zu Zeiten kompiliert wird oder wo Seiten zu C, ich weiß es nicht genau.

Aber also wenn man wenn man das verwendet, sollte man sich vielleicht schon klar sein, dass es unter Umständen ein gutes Stückchen langsamer ist 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.

Die ist das alles viel besser.

Ja, ja, ich habe gestern letztens noch wieder jemanden gehabt, der kein Python konnte, nicht mehr hat.

Ja, ich habe gehört, das ist voll langsam, dabei ist das erste Argument.

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

Und ich, also meine Ansicht dazu ist ja so, wenn du, wenn du mir 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 dann mit irgendwas anderem sehr viel schneller bist.

Ja, ich glaube, das ist halt wahrscheinlich der Punkt, also die Leute gar nicht den Anlegungsfall genau verstehen und warum Pysen dann da vielleicht langsamer ist, wenn man es falsch mag.

Wenn du keine Ahnung hast und irgendwas machst und dann kann es sein, dass es hinterher langsam ist, ja.

Das stimmt.

Ja, genau.

Aber das stimmt halt auch für alles andere.

Also insofern mit dem Tage.

Ja, also schöne Sachen, also um tatsächlich, wenn du irgendwie einfach sagst, du willst ein Dick drausgeben, dass das direkt Jason und so weiter, Fassab, 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 wenn machst ja dann Async, definierst du dann Funktionen als Async und so, und dann kann das alles schön sozusagen zumindest IO-mäßig parallel gemacht werden.

Jetzt hätte ich meine Frage, ich habe eine ganz fiese gemeine Frage.

Okay.

Was macht eigentlich, was, du kannst ja aber auch in Fast API ja Normalfunktionen so definieren?

Oder wenn du auf die Datenbank zugreifst, dann ist es ja auch synchron alles.

Und dann kannst du eigentlich nicht mehr async, äh, deine Funktion async definieren oder Wait sagen, sondern du musst das halt so aufrufen.

Und das funktioniert ja auch einfach so.

Wie macht, äh, oder was, warum geht das eigentlich?

Oder wie macht FastAPI das eigentlich?

Dass, wenn du, äh, wenn du jetzt ganz viele, sagen wir so, es kommen ganz viele Requests parallel rein, sozusagen und jetzt hast du da diese Funktionen, die synchron sind, die sind ja nicht als ISIN 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 das regelmäßig verlieht.

Ja, das dachte ich auch so, dass da, 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.

Ich so, hä, wie macht denn denn das?

Dann muss ich in der FastAPI-Dokumentation ein bisschen kraben, bis ich das gefunden habe.

Und über zwei, dreimal, es gibt irgendwie Concurrency, Parallelism gibt es einen Teil in der Doku.

Und dann kommst du die erste Warnung jetzt ab, hier wird es aber technisch und dann kommt noch eine zweite Warnung ab, hier wird es aber wirklich fiestechnisch.

Und dann nach der dritten, wo dann steht, also das dürfte jetzt nur wirklich überhaupt niemanden mehr interessieren.

Da steht dann noch, fies wirklich funktioniert.

Jetzt musst du spoilern.

Naja, also tatsächlich, was FastAPI macht, ist, benutzt ein Thread-Pool, um die Sachen dann halt irgendwie concurrent synchron abzuarbeiten.

Also synchrone Funktionen landen in einem Threadpool, der das dann macht.

Das geht auch.

Also du kannst ja auch Threads verwenden, um halt

zu machen.

Ja, deine IO zu multiplexen.

Und wenn man das richtig macht und ja, FastAPI importiert da ein Threadpool aus Solid, dann funktioniert das auch schnell.

Also ja, aber wenn man halt sozusagen wirklich ressourcenschonend das machen will, dann macht es schon Sinn, da Async-Geschichten-Funktionen zu verwenden.

Dann ist es halt direkt nochmal irgendwie ein Stückchen eleganter.

Noch schicker.

Und dann ist es halt Coroutine und nichts, weil es ja schon immer haben noch ein bisschen mehr Overhead als so.

Ja, ja.

Was auch gut geht.

Das hat man ja sonst immer auch irgendwie sind so Geschichten, Background-Tasks.

Oh ja, Background-Tasks.

Ist halt relativ easy, ne?

Ganz einfach.

Ist auch einfach.

So eine Queue haben und dann geht es rein und sagst du irgendwie, was ist das, Dekorator?

Oder eine Dependence, die du reingibst, Background Task und dann hängst was rein.

Und das läuft dann einfach.

Du musst halt am Anfang einmal initiieren, oder?

Nee, nee, nee, nee, du sagst, das hier ist jetzt ein Background-Task und hinaitest du dann.

Ah ja, ja.

Also das

kann eine beliebige Async-Funktion sein und genau.

Ich weiß es jetzt aber nicht mehr genau, aber im Grunde ist das auch schon eine Funktion, die ein Installer drin ist.

Und damit kannst du halt so Dinge, aber die müssen halt, ich glaube, die müssen dann aber auch Async sein oder können die auch synchron sein?

Das weiß ich jetzt gar nicht.

Kann auch sein, ja, ich meine, es gibt ja diesen Thread-Product, da kannst du auch mal einen Thread 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 IO 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 Salary oder sowas oder eine andere Task-Queue und dann startet man halt, schmeißt man das, irgendwas mal in eine Queue, dann gibt es irgendwie andere Dinge, die holen sich das aus der Queue da wieder raus.

Ja, und dann

in die Queue schmeißen, muss man erstmal wegrealisieren in irgendwie ein String-Format und das bald.

Ja, ja, gut.

Also es gibt halt Dinge, für die geht es nicht anders.

Geht es auch mit First AP, ging es nicht.

Also wenn du, wie gesagt, irgendeinen Berechnungsjob machst, dann 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 serialisieren, damit es irgendwo 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.

Ja.

Also das halt auch integriert.

Dann, was auch integriert ist, ist halt statische Files, auch wieder aus Salad, aber genau, den Code habe ich mal geklaut für diese Django Async Files-Response-Geschichten.

Und ja, das ist, du kannst halt, dadurch, dass das halt so effizient geht mit Lib UV, UV-Loop, UV-Corn, kannst du halt auch Files serven, was du normalerweise in einem Applikationsserver nie machen würdest.

Aber dadurch das jetzt halt nichts mehr kostet, irgendwie eine Verbindung auf, also weil das Problem bei File-Serving ist halt, das sind halt Requests, die lange laufen.

Also normalerweise macht das von außen an der Web-Server, also keine Ahnung, der Nginx.

Macht Nginx oder ein Apache oder sonst irgendwas, genau, oder dein dein CDN.

Weil eben, wenn ein Applikations-Server 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 machen die halt, dann ist deine Webseite halt nicht mehr erreichbar.

Das ist ja halt schlecht.

Daher, normalerweise Statisch-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 statisch 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 deinen 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 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 aufsplitten kannst in unterschiedliche, dass du sagen kannst, hier ab die unter diesem Pfad, dafür ist dieser Router zuständig.

Genau, du kannst halt die Router unterdecken, da kannst du auch die Regeln dann versetzen oder Authentifizierung für einen Router verlangen oder sowas alles, ne?

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 voll vieler Kursum.

Dann kannst

du eigentlich deine ganze Applikation halt irgendwie hübsch aufteilen.

Genau, ja.

Und etwas, was es in Flask gibt, was es in FastAPI nicht gibt, ist so ein Plugin-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 Plugins.

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.

Also ich finde das ganz nett, vielleicht dann an der Stelle nochmal zu Typer, also das ist auch ein Projekt von Sebastian Ramirez von Tiangolo.

Das hast du ähnlich mal tatsächlich auch auf Klick auf und macht halt auch mit Type-Annotations eine Kommandozeileng-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 und

gefällt mir auch so gut, verwendet, für wenn ich das 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, mit der ich halt mag, irgendwie so modern zu arbeiten mit den ganzen modernen Tools.

Da bin ich auch, also ich kann nicht, ich muss das nicht schwierig haben.

Das ist irgendwie nervig.

Also ja, man

kann das

durch diesen Bergboxen und dann, ja, I'm the Hero, ich habe das Schwert rausgezogen.

Ja, ich kann mit meiner Zeit besseres anfangen.

Ja, naja, ich halt.

Ich meine, die anderen Sachen haben ja auch so ein bisschen was für sich.

Du meinst diesen charmanten.

Nee, es ist nicht nur schlecht.

Also tatsächlich bist du dann halt eben nicht auf eine Idee angewiesen zum Beispiel.

Und du kannst halt schöner allgemeinere Funktionen.

Ich weiß nicht, ob das jetzt ein Feature oder ein Feed ist, dass ich nicht auf eine Idee angewiesen sein muss.

Also come on.

Ja.

Also inzwischen bin ich da ja nicht mehr so, aber.

Not mit meinem VI gestrandet auf meinem Telefontze, okay, maybe.

Nein, aber ich meine, von vor ein paar Jahren hätte ich dann auch gesagt, so Idee ist das, alles Quatsch.

Keiner VI.

Yeah.

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 Peitschaben gemacht und mehr VS Code und muss sagen, ach ja, das ist eigentlich schon ganz okay.

Ja, ich probiere es ja gerade den anderen Weg rum.

Ich versuche gerade so ein bisschen VI zu lernen nochmal, aber ja, es ist halt, die Konfiguration ist so ein bisschen Pain, aber wenn man einmal durchgestiegen ist, dann geht es ein bisschen.

Aber ich sag mal, das Produktivitätslevel ist schon ganz nett für bestimmte Taster, aber für bestimmte Taster einfach auch nicht.

Ja, also, genau, also ich will, ja, es gibt Gründe, warum es so ist, wie es ist und es ist auch eigentlich gut.

Aber, ach, naja, vielleicht rum man die Kind.

Ich glaube, wenn man neu anfängt, ist das so ein

bisschen, ja.

Ja, dann machen wir das vielleicht einfach gar nicht.

Die ganzen, was haben wir denn?

Achso, Flask auch irgendwie gibt, gibt jedenfalls die alte, also Flask 2.0 gibt es ja auch noch nicht so lange her.

Das kann auch SGI, aber Flask ist sehr stark an WSGI drangebunden.

Und deswegen ist eigentlich, also der ganze, also Flask unter 2, das wird mit SGI nie funktionieren.

Das ist immer fest ausgemacht.

Deswegen nimmt man ja neue Software.

Genau, also insofern, das ist halt sowas, wenn man jetzt irgendwie was mit Websockets machen wollen würde.

Also, ich glaube, Websockets hatten wir auch noch nicht so richtig.

Dann ist Flask, also jedenfalls ist das alte Flask nicht unbedingt die Bereiche.

Ich glaube, Flask 2.0 geht vielleicht und Quart geht da halt auch.

Oder vielleicht ist Quart irgendein Flask 2.0 aufgegangen, ich weiß es gar nicht mehr so genau.

Aber das alte geht auf jeden Fall nicht so richtig.

Und genau, FastAPI 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 hab extra irgendwie, naja, gut, wenn man Fast API machen möchte, dann kann man natürlich auch dann direkt so mit allen Pfeifen und Welzen Whistles und Websocket und so machen, dachte ich dann.

Und hab das dann halt auch mal benutzt und

das auch ein Tutorial dafür gemacht auf YouTube, glaube ich, wo das ein bisschen gezeigt wird, Fast API.

Habe ich das mal gemacht?

Ja, also ich habe, zumindest das Top-Was dann wirklich gemacht hast, würde ich nicht

alles genau an.

Das ist einfach nur gestreamt, das ist einfach.

Das Einzige, wo ich mir mal was, wo ich was geplant habe, war zu Naiv Base implementieren.

Da habe ich vorher mal überlegt, was ich dann implementiert will eigentlich.

Die ganzen anderen Streams sind alle einfach nur so, ja, alle furchtbar.

So kann man es auch umschreiben.

Oder sind 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 Vorbereitungsaufwand.

Man kann das Kanal, also wenn ihr einen Jochen mal sehen wollt, dann muss man mal reingucken.

Ja, 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 du sollst einen Didaktik kurz machen, Jochen, haben wir eine Empfehlung bekommen.

Ja, ja, genau, die ganzen Ass und ja, es stimmt nicht.

Ich bin eher für Didik, also ich bin nicht

so schlimm.

Ja, gut.

Eigentlich am besten alles austauschen.

Didaktik, Rhetorik.

Das Gesicht.

Ja, ich verstehe schon.

Der ein bisschen schminke hier und da.

Ja, also jetzt, ich komme sowieso nicht mehr so häufig zum Stream daher, oder hab das auch noch nicht geschafft, da irgendwie ein Schedule hinzukriegen, wo der irgendwie funktioniert.

Daher, vielleicht mache ich das einfach so.

Dann habe ich ja eine 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 und ja, muss man kommen.

Der kann auf die Gäste einladen wie mich.

Ja, gerne.

Aber everyday dann da, da bin ich raus, wenn du da irgendwie anfängst, deine Testsneuzuschreiben oder irgendwelche Pakete nachzuinstallieren.

Ja.

Ich meine, ist ja auch mal nett zu sehen.

Wir haben jetzt davon 100 Folgen oder was archiviert auf unserer Podcast-YouTube-Seite.

Ja, war schon einiges.

Ja, ja, schon einiges.

Ja, klar.

Genau.

Was hatte ich denn noch?

Ach genau, Websockets, genau.

Dafür hatte ich ja Websockets so ein bisschen verwendet.

Und ja, also ich dachte so, okay, wenn man das dann verwenden kann, das ist doch einfach voll cool, dann machen wir das doch einfach so.

Und in der Schule.

Das geht tatsächlich ganz gut mit Scratch-App.

Das geht auch sehr gut, ja.

Also wenn man so einen Anwendungsfall dafür hat.

Aber diesen Depp-Sockets ist prinzipiell auf die Nerven gegangen, habe ich gemerkt.

Nee, prinzipiell, 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, so, weia, das ist gar nicht so einfach.

Und also fängt halt schon, also 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 da wohl keine Gedanken hat.

Und benutzt halt einfach Websockets einfach so, dann kriegt man Probleme.

Mit Fast API 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.

Ist halt nicht so richtig einfach.

Weil was passiert zum Beispiel, wenn jetzt dein Server, die Serverseite sich neu startet?

Du musst eine neue Verbindung bekommen.

Ja, du musst halt retryen, weil ansonsten, wenn du einfach nichts machst, dann ist die Verwendung halt weg.

Und das bedeutet.

Weg tot ausgehen.

Aus dem Maus, danke, nein, das war's fühle.

Ja, das heißt, du musst reconnecten.

So, jetzt funktioniert der erste Reconnect vielleicht nicht.

Dann, okay, vielleicht noch einen zweiten.

Dann gibt es halt unterschiedliche Sachen, die auftreten können.

Auf die musst du irgendwie reagieren.

Dann wird es auch.

Die Quota exceedet.

Ja, dann ja, du 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.

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 das ist immer das Gleiche dann passiert.

Ach ja, aber so wirklich, äh, also so was dann wirklich so ein bisschen so Software-Architekturproblem wird, ist halt sowas wie, du kriegst jetzt die unterschiedlichen Informationen rein, halt einmal über ein 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 dem einen Fall holst du sie halt über irgendwie eine so eine HTTP-JSON-API und im anderen Fall kriegst du es halt über einen Websocket rein.

Und jetzt musst du es halt irgendwie synchronisieren.

Du darfst halt nicht Sachen doppelzellen 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 einem View, in so einem Pinya-Store oder sowas.

Musst du halt so ein bisschen.

Das ist 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 musst du halt schon eine Software-Stikur machen, so ein Frontend.

Oh nein.

Backend schon nicht so richtig hin.

Und wer macht das denn sauber?

Pinya war ein guter Side-Hitter, das hast du nämlich für einen Superstore.

Ich finde ihn auch sehr viel angenehmer zu schreiben als Vuex, den man für Vuejs nehmen kann, ja.

Ja, gefällt mir auch sehr gut, aber tatsächlich irgendwie, manchmal habe ich auch so Dinge, wo ich mich denke, so, oh, okay, dieser 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.

Und es ist schon nicht schon so ein bisschen hakelig.

Und man muss halt drüber nachdenken und das 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 tatsächlich ein Geld.

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

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, ist es halt.

Ja, Single Source of Tools Arter, wer weiß das denn überhaupt?

Manche Leute rennen ja irgendwas, obwohl es gar nicht stimmt.

Ja.

Was auch nicht immer falsch sein muss, vielleicht.

Also 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 das schon.

Und das stimmt ja vielleicht oft auch.

Vielleicht ja manchmal auch nicht.

Und das macht man denn dann und so.

Und ja, ja, ja.

Ja, aber es wird halt schnell, es wird halt schnell kompliziert.

Und um 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 HTMX zum Beispiel ist es halt super easy, irgendwie, weil, also was ich früher halt so gedacht hätte, so, oh, Pollen, oh mein Gott, also einmal machst viel das auf dem Server, weil du pollst ja die ganze Zeit.

Wenn jetzt viele Leute auf deiner Seite sind, dann pollen die die ganze Zeit, super, super toll, irgendwie habe ich irgendwie viel mehr Requests, die ich eigentlich bräuchte und so.

Da muss ich dafür sicherstellen, muss ich irgendwie sicherstellen, dass das JavaScript auch irgendwann aufhört zu Pollen.

In der letzten Unterhalten darüber sagt es, ah, Pollen, also will man überhaupt nicht machen, das ist furchtbar und so.

Ja, ja, ja, aber da habe ich jetzt inzwischen dann doch, glaube ich, meine Meinung erinnert, weil wenn man das halt so einfach hinschreiben kann wie in HTMX, man schreibt halt every two seconds oder so, schreibt man ein Attribut, das war's.

Mehr macht man gar nicht.

Und auf der Serverseite schickt man halt, wenn man, also man kontrolliert es von der Serverseite aus und nicht von der JavaScript-Seite aus.

Und von der Serverseite aus schickt man halt so einen Status-Code 286 zurück.

So irgendwie, ich weiß nicht, der heißt irgendwie auch sowas wie Stop-Polling oder sowas.

Und dann hört es einfach auf.

Und in dem Stop-Polling steht auch wie lange, glaube ich, sogar, ne?

Ja.

Kann man also irgendwie sätzen und man kann halt auch überhaupt nicht.

Ja, der warerweise, ich glaube, wenn, wenn du einen bestimmten Code machst, also ich glaube 419, kann das auch sein, dass man dann sagt, so, ey, hör auf jetzt, für sonst wie lange, sonst wirst du gebannt oder so.

4, wie hieß er, 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 Herr halt einfach so machen, dass man das Element, was halt Pollt oder so, einfach austauscht mit Auto im Auto-HTML und dann kann man einfach das Poll-Ding wegnehmen.

Also für 19 ist ja Authentication Timeout.

Und sobald jemand auf irgendwas anderes drauf drü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 man, das ist halt alles ganz furchtbar.

Und da würde ich jetzt sagen, eben ü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 dem ganzem Standardkram, 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 ist.

Vielleicht doch live, als man denkt.

Also 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 auch unter Kontrolle.

Wenn du sagst, okay, das ist mir jetzt, das sind mir jetzt zu viele, dann sagst du halt, okay, dann polle ich halt nicht jede Sekunde, sondern nur alle zwei Sekunden hast du schon die Last und die halt viel gesenkt.

Ja gut, aber ja, ist halt die Frage, wenn trotzdem eine Million Leute alle zwei Sekunden fragen, ist halt doof, weil es so viele auf einmal sind.

Du kannst ja dann irgendwann mehr Server kaufen, du kannst ja nicht überlegen,

was du machst.

Ja, okay, aber genau, aber das ist halt dann, man weiß dann, an welcher Linie des Problems und welcher Achse man sich dann abarbeiten kann.

Ja.

Also das war das war schon so ein bisschen, also wenn ich mit dem Wissen von jetzt würde ich das nicht nochmal mit wegsockern.

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, der ausmacht.

Ach, Picks, da machen wir jetzt Picks.

Ja, also mein Pick für diesmal wäre Honcho.

Honcho, ist das eine Insel?

Nee, das ist die Hauptinsel.

Ich weiß gar nicht, wo der Name herkommt, ehrlich gesagt, jetzt grübel ich da gerade.

Nee, das ist es gibt in Ruby, in der Ruby-Welt gibt es ein Ding, das nennt sich Formen.

Ist da relativ populär und Honcho ist das auch der Python, das ist eine Python-Nach-Implementation davon.

Und das benutzt man, um ein Prog-File zu lesen und dann Dinge, die darin stehen, zu starten und zu stoppen.

Also quasi, wenn man jetzt sowas, man kennt jetzt vielleicht mit Docker-Compose, ne?

Docker Compose, minus F, irgendein Config, Yammel, Config up und Down und so, dann passiert auch sowas, da werden alle die Dinge hochgefahren, alle wieder runtergefahren oder so.

Also alle Docker-Container, die in der Compose halt reinstehen, ja.

Jetzt möchte man aber vielleicht zum Beispiel, wenn man irgendwie so wie ich, Docker ganz so, naja, wie schläge ich das jetzt aus?

Weil nicht so gut findet, nicht so gut eher so ein Mittel findet.

Und das nicht verwenden möchte.

Und dann denke ich, ich hätte ja schon diese Funktion gerne, dass ich halt mein komplettes System, das ich zumindest entwickeln, so brauche ich einmal hochfahre und einmal runterfahren kann und so.

Dann kann man das halt in so ein POC-File reinschreiben, was man alles dafür hochfahren muss und runterfahren muss.

Und dann nimmt man Honschrue und sagt Honschul Start und dann passiert halt quasi genau das gleiche wie mit Docker-Kompost ab.

Okay, cool.

Und ja, nur dass es halt nicht Docker ist, sondern es sind einfach ganz normale Prozesse, die gestartet werden.

Und POC-File hat halt auch den Format diverse Hoster, kann das direkt lesen, Heroku kann das direkt lesen und so.

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, ist nicht isoliert.

Ja, ist halt, aber zum Beispiel ein Pattern, was ich halt in letzter Zeit, wenn ich meine Sachen mache, tatsächlich irgendwie viele Dinge, die ich halt so bezahlt tue.

Da ist eigentlich seit seit Jahren.

Es ist halt immer Docker.

Es ist besser geworden, ja.

Davor war es mal eine Zeit lang Vagrant.

Ja, ja.

Und VirtualBox und so, das war noch schrecklicher als Docker.

Aber Docker ist auch ziemlich schlimm.

Ist jetzt auch bezahlt, übrigens, ne?

For Corporates muss man jetzt richtig sagen.

Wobei die Grenzen sind halt so, dass da viele nicht mehr sehen.

Nur große Corporates müssen das

eigentlich machen.

Ja, und wenn du so groß bist, dass du da runterfällst, dann ist es nicht.

Genau, dann.

Ja, wenn die Leute halt sind nicht freiwillig für Open Source dann bereitstellen, dann ist das vielleicht schon ganz gut, dass sie dazu gezogen 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, dass ich irgendwie Dinge, also morgens, wenn ich mich dran setze, ne, dann so, irgendwie ist schon wieder einer von den Containern irgendwie gestorben oder so.

Also ich muss halt regelmäßig Docker-Desktop neu starten.

Ja, ich verstehe auch nicht, warum Docker ab und zu mal einfach mal der Container runterfällt.

Ja, oder ich versuche bei allen zu stoppen und es geht irgendwie nicht, es bleibt irgendwie hängen.

Dann kill ich das irgendwie weg und dann manchmal geht es, manchmal geht es nicht.

Dann irgendwie kriege ich ganz seltsame Fehlermeldungen aus den Tiefen von Docker.

Und dann liegt es aber daran, dass intern irgendwie irgendein Teil ist halt vollgelaufen.

Ja, damit war halt die Loks von vor drei Jahren immer noch ein und anstatt dass, oh DD, wenn es mal komplett rebuildet ist, das wieder von vorne an.

Ja, und wenn man darin debuggen will, ist halt, es geht schon, es ist aber alles irgendwie und alles ist langsam.

Ja, genau.

Und ein einzelnen Test ist halt alles lahm, es fühlt sich alles so an.

Es braucht relativ viel Ressourcen.

Ja, und genau, ich bin vielleicht besonders gestraft, weil ich halt Mac auf Mac-Plattformen bin und da ist es halt besonders langsam.

Aber es ist wirklich, es ist so ein bisschen, es ist wirklich aufwendig.

Also ich nicht, es kostet wirklich Zeit, irgendwie das halt zu verwenden.

Und es macht alles ein bisschen schwieriger und für meine eigen 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 ich habe halt auch ganz lange nicht Honshow verwendet, aber verwende jetzt dann halt vielleicht Honshow.

Und den Applikationsverwalt oder das Ding, an dem ich gerade entwickele, das starte ich dann halt in der IDE mit dem Debugger zum Beispiel.

Und kann

da halt dann schön drin drin debuggen.

Ich kann, wenn ich auf den Test ausführen klicke, dann ist es halt sofort, sofort ausgeführt, ja.

Und ich muss halt nicht erstmal zehn Sekunden warten, bis das irgendwie sich irgendwie in den Docker reingetunnelt hat und dann da irgendwie eine Tempel.

Ja, ja, weil es erstmal alles die Tanzwegung wiederbauen muss und so weiter.

Und das funktioniert tatsächlich ziemlich gut.

Ist halt eine sehr angenehme Erfahrung, aber ja, diesen, ja, weiß auch nicht.

Aber die Leute, also in Firmen ist es wohl aufzwischen irgendwie verpflichtend, da Docker zu nehmen.

Ja, das klingt gut.

Also Honshu.

Danke an Claudio für den Tipp, der hatte das.

Ja, also ich wollte ein Dango-Projekt picken.

Und zwar Hells-Checks heißt das.

Oh, ja, ja, ja.

Also das kann man selber hosten, einfach Health-Checks und da irgendwie seine Applikationen reinpacken.

Es ist natürlich ganz wichtig, dass der Hells-Check-Server auf dem gleichen Server läuft wie der Rest.

Ja, ich weiß es nicht.

Das ist doch innen-Dango-Server drin, ja.

Ja, es ist ein Dango-Projekt, Dango 4-Projekt, wo man halt relativ nett einfach seinen Server, den man so überwachen will, rein monitoren kann.

Über ein ganz nettes, kleines Frontend, alles relativ modern gebaut und Dango-Post-Gespeisen 3.8, glaube ich, und hochfahren, Web-Frontend benutzen, wie man das halt von anderen Tools kennt, aber es ist halt-postet 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 den Dingen, was man innerhalb von Django hat, wo man dann von außen fragen kann, ob da noch alles okay ist.

Einfach so ein normales Hashtag-Ding, dass du halt einfach guckst, sind die Server, die du halt haben würdest, sind die noch da oder nicht?

Und was macht das denn da?

Okay, also eher so ein Monitoring-Tool.

Ja, ja, genau.

Muss ich mal angucken, weiß ich nicht.

Ja, dann sind wir.

Ja, sind wir durch.

Dann vielen Dank, dass ihr wieder eingeschaltet habt.

Habt uns gewogen,

trotz Erwärmung.

Hört uns überall, wenn ihr uns hören wollt.

Sagt Bescheid, was euch stört, an hallo.pythonpodcast.de.

Ja, oder wenn es euch nicht stört und gut gefällt, dann könnt ihr auch gerne irgendwie meine Bewertung hinterlassen, irgendwie bei iTunes oder irgendwie Spotify geht es jetzt auch um 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 findest's gut, paar Leute findest du doof.

Ja, so ist es halt.

So kann man nichts gegen machen.

Ist auch völlig in Ordnung.

Also, wie gesagt,

der Feedback teilt uns das immer gerne mit und so und wir verwenden sich.

Wir dürfen jetzt eigentlich mal angeben.

Ich glaube, wir dürfen angeben, oder?

Wir waren letztes Jahr waren wir über 100 Tage, glaube ich, in Top 20 Tech-Podcast-Charts, kann das sein?

Top 50, glaube ich, eher.

Ne, Top 20, weiß ich nicht.

Top 50 ist immer das, was.

Top 21 oder so.

Ja, aber relativ lang.

Und jetzt, also dieses Jahr, ich weiß, ich guck mal, ich gehe gerade drauf, aber ja, dieses Jahr eigentlich schon die ganze Zeit.

Ja, vielleicht gibt es ja gar nicht mehr als 50, man weiß das nicht.

Ich komme mal gerade, aber auf Spotify sind es quasi jetzt gerade so 3000 Subscriber.

Ja, und wie viel sind wir?

Welcher Platz sind wir gerade bei Tech?

Wäre da schon drunter.

Dann haben sie, glaube ich, gerade wieder rausgefallen.

Ja, ich fand ich, ich weiß jetzt nicht, ob ich jetzt hier die Spotify-Plattform promoten möchte, weil ehrlich gesagt ist.

Nein, so ein bisschen.

Also die Spotify um Podcast ist jetzt irgendwie fleckert.

Ja, o je.

Ist ja völlig verpönt, okay.

Nein, nein, hast du das mitgekriegt, diese Joe Rogan-Geschichte?

Und diese unsägliche Mail, die da Spotify-CEO geschrieben hat?

Also 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 aha, okay, die Leute, der hat irgendwelchen Scheiß erzählt und irgendeinen Idioten einige Leute verlassen, dass die Plattform

ist, neben dir ein bisschen

aufschreiben, bla bla bla, ist mir ja 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 drauf muss.

Mir ist das Ding völlig egal.

Ich höre meine Musik tatsächlich auf anderen Quellen, also auf Vinyl, falls du genau wissen willst.

Aber.

Boah, ich meine, 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 meinen Vinyl schmeißen, wenn ich das muss.

Dann kann ich sogar auf dem Flap rumscratchen.

Das müsste ich nicht so mit einer Tonspur von dir ausprobieren.

Egal, aufdruck klicken.

Bleibt uns gewogen.

Bleibt wieder rein.

Bis dann.

Bis dann mal.

Tschüss.

Ciao.