Transcript: Python Async Teil 2

Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python-Podcast. Heute die 26. Episode, wir haben den 1. Dezember. Jochen, wir sind heute genau zwei Jahre, vor genau zwei Jahren haben wir die erste rausgebracht.

Oh, ja richtig, das stimmt.

2018, am 1. Dezember kam unsere erste Episode raus.

Ja.

Ja, nicht schlecht, oder? Zweiter Geburtstag.

Zwei Jahre, meine Güte, das ist schon wieder lange her.

Nicht so schlecht, wir haben sogar durchschnittlich mehr als eine Folge dann pro Monat aufgenommen. Und wenn wir die noch zählen, die wir weggeschmissen haben, sind wir sogar bei.

Ja, ich glaube, wir haben uns verzählt ab und zu. Ich weiß nicht, ob das wirklich genauso viele sind. Also 27 ist jetzt die Zahl, die aber es kann sein, dass wir irgendwie Dinge unterschlagen haben.

Ja, ich glaube, 26 ist offiziell jetzt.

Kann auch sein. Ich weiß es nicht genau.

Ja, hallo, hallo. Schön, dass ihr wieder eingeschaltet habt. Heute machen wir Async Teil 2.

Ja.

Und wir haben dabei den Johannes.

Hallo.

Hallo.

Ja, wir wollten auch wieder ein bisschen News machen und euch ein bisschen entschädigen für die ganzen Folgen, wo wir das so ein bisschen...

Ja, wir haben uns ja immer so viel vorgenommen, was wir eigentlich machen wollten.

Lagen haben.

Modul aus der Standardbibliothek vorstellen, Pics und so, das machen wir dann nie, weil irgendwie immer zu wenig Zeit ist und wir die ganze Zeit brauchen, um unser Audiosetup hinzukriegen.

Ja, genau, dann muss am Ende irgendwie jemand wieder ins Bett und dann müssen wir leider immer aufhören.

Ja, genau.

Genau, machen wir das diesmal.

Ja, also zum Beispiel eine Geschichte, die ich eigentlich erwähnen wollte.

Wir hatten ja vorletztes Mal, glaube ich, was zu Python 3.9 erzählt.

Und eine ganz wichtige Geschichte habe ich vergessen.

Und zwar ist in Python 3.9 Topological Thought schon mit in der Standardbibliothek.

Topological Thought.

Jetzt bin ich natürlich wieder der Blöde, der keine Ahnung hat, was das ist.

Also, was ist bitte Topological Thought?

Jochen weiß es auch nicht.

Das ist nur cool.

Ja, nee, das ist

wenn man jetzt einen Grafen

also wenn man zum Beispiel Abhängigkeiten hat

und die sortieren möchte, also wenn man sich zum Beispiel anzieht

und dann irgendwie

dran denken möchte, dass man irgendwie bevor man

weiß ich nicht

die Schuhe anzieht, die Socken angezogen haben muss

dann ist das Problem sozusagen

das allgemeine Problem dazu ist

topological Sort oder topologische Sortierung

keine Ahnung, gibt es auch

beim Projektmanagement, glaube ich

Gibt es überall, wo es Grafen gibt

Ja.

Zum Beispiel auch ganz wichtiger

Angelegenheit, da habe ich selber zum, da wusste ich

noch nicht, was das ist und

habe selber überlegt, was das für ein Problem sein könnte.

Nach ganz, ganz lange Überlegen bin ich dann drauf gekommen,

es könnte irgendwas mit Graphen zu tun haben und dann

sortieren und irgendwann hat mir

jemand gesagt, ja, das ist doch Topological Sort.

Dann habe ich mich ziemlich blöd gefühlt, aber

zwar wenn man

die Abhängigkeiten von Programmen

oder Paketen, die man

installieren möchte, sortieren möchte, da braucht man das dann auch.

Ja.

Genau.

Das ist jetzt mit drin, einfach so?

Das ist jetzt in der Standardbibliothek mit drin.

Batteries included, sage ich ja nur.

Ja.

Ja.

GraphLib heißt das Modul, oder?

Ja, ja.

Genau.

Heute ist übrigens auch Advent of Code, der Teil 1, rausgekommen.

Macht ihr das noch?

Worum geht es denn dieses Mal beim Advent of Code, Dominik?

Das habe ich noch nicht so ganz rausgefunden.

Ich glaube, irgendjemand möchte in Urlaub fahren auf eine Insel,

weil er schon fünf Jahre lang versucht hat, das hinzubekommen.

und dann muss er

irgendwie seine Abrechnung richtig machen, dass er da

hinkommt. Ich finde, die letzten Jahre fand ich auch sehr

interessant. Da ging es ja irgendwie um Weihnachtswichtel

und die Reise durchs Weltall mit dem Santa

und so. Ja, genau.

Okay. Mit dem Raumschiff,

was man Interprete braucht, den man dann selber programmieren

musste. Ja, genau. Da haben wir auch Codes und so, ne?

Mhm.

Ja, also er scheint auch cool. Das ist eine coole Sache.

Also, da kann man dann allen möglichen

Programmiersprachen machen, natürlich.

Und, äh, hallo.

und dann kannst du quasi überprüfen,

ob du die richtige Lösung gefunden hast.

Ah, okay, ja

Und das ist eigentlich immer ganz nett

Es ist sehr nett gemacht, es ist sehr aufwendig gestaltet

und wir haben immer schöne Story

Genau, man muss ja immer einen Stern sammeln pro Tag, pro Aufgabe

also zwei Sterne am Tag

für 48, 50 sogar, oder?

24, kriegt man 25 auch noch ein?

Nö

Also, ja, 2x24

24 oder 25

Ich glaube 48 dann

Achso, und es geht auch zurück, also man kann auch bis

2015 zurück gucken

und sich die ganzen alten Aufgaben ansehen.

Das ist sehr nett. Also selber ausprobieren

und dann halt gucken, ob man die Aufgaben lösen kann.

Am Anfang sind die noch etwas einfach.

Die gehen aber schnell wirklich in die Zeit.

Ich habe sogar einen Post gelesen von Peter Norweg, der sagt,

das wäre eigentlich schon sehr geil, aber so viel Zeit hat er dann auch nicht.

Das ist auch bei mir immer so das Problem.

Ich mache da gerne mit und dann irgendwann fühlt es sich an wie Arbeit

und dann höre ich es dann wieder auf.

Ja, aber es ist auf jeden Fall sehr zu empfehlen

für alle

Stufen ist was dabei

die ersten Aufgaben sind einfacher, die kriegt man schnell durch

und die, so ab dann 5

oder so oder 6 oder 10 oder 12

wird es dann schon richtig happig

Ja, man muss sich dann wirklich überlegen, wie man da rangeht und nicht einfach so hands-on drauflos

dann läuft man meistens gegen eine

kleine oder größere Wand

Und letztes Jahr war es auch so, dass die aufeinander

aufgebaut haben, das heißt man hat dann an einem Tag

seinen Interpreter gebaut und zwei Tage später hat man

wieder abgebaut, weil dann noch ein Feature

dazukam. Ja, oder man musste halt neue

Opcodes handeln oder sowas. Und wenn man am Anfang schludrig

gearbeitet hat und das so hingeworst hat,

dass das einfach so ging, dann hat man sich geärgert,

weil man die Implementierung sonst einfach hätte

erweitern können und so musste man sie ganz neu bauen.

Naja, ich bin gespannt, wie es dieses Jahr

draus wird.

Ich habe nicht immer so viel Zeit, aber ich glaube, so eine Stunde morgens

würde ich mir schon dafür nehmen. Ich mag das nämlich.

Ja, es lohnt sich auf jeden Fall auch. Sehr gute

Übung.

Ja, ich habe da auch mal sehr viel gelernt. Also wirklich auch

über Konzepte von anderen Lösungen angucken, verschiedene

Sprachen. Ein Kollege von mir macht das in Go,

kann man es immer schon vergleichen.

Er hat heute direkt eine rekursive Lösung implementiert.

Ich war direkt ein bisschen neidisch.

Ich hatte nicht an Binary Research gedacht, ich wusste auch gar nicht, wie das

in Python richtig geht.

Und habe einfach Iter-Tools genommen,

was auch funktionierte, aber weil

BruteForce.

Aber wir waren bei News, dass

der Stene stehen geblieben ist.

Ja, genau.

Eine ganz interessante

Geschichte, Python läuft jetzt auf .NET

auf der Runtime da.

Das hast du gerade so ein bisschen leise vor dich hin

genuschelt, als wäre es eine

Meinung. Das ist mir auch peinlich.

Das ist peinlich, dass das so nicht läuft.

Was ist der Unterschied zu IronPython?

Weil IronPython gab es ja schon lange.

Ja, aber ich glaube, das war schon lange nicht mehr so richtig

aktiv. Das ist so wie Json.

Da gibt es sicherlich einen 2.7

Port für.

Ja, es ist irgendwie, es gibt einen

Pep, der

beschreibt, wie man sich quasi einklinken kann,

wenn man jetzt ein JIT

Compiler ist und

Diese Variante jetzt benutzt es auch.

Das ist irgendwie von

Anthony Shaw oder so hat es gebaut.

Was genau meinst du mit einklinken,

wenn man ein Compiler, also das ist ein Just-in-Time-Compiler,

das heißt sowas wie

Python, die halt zur Laufzeit dann irgendwie

evaluiert werden oder wie ist das?

Das ist halt dann zu Maschinencode

runterkompiliert wird quasi.

Aha.

Während das Programm läuft.

Also die Teile, die gerade notwendig sind,

werden dann während das Programm läuft

zu Maschinencode kompiliert oder zu dem

Code der VM,

die da drunter liegt und sind dann natürlich

schneller.

Das macht PyPy zum Beispiel auch.

PyPy hat auch so einen JIT-Modus,

der dann halt

die Sachen,

die jetzt gerade in der

Schleife sind und 100.000 Mal durchgeführt werden,

die kompiliert er dann halt so vor, dass diese

Varianten schneller sind. Das ist einer

der großen Vorteile von

PyPy, dass die das machen können. Das macht

C-Python nicht, C-Python hat keinen JIT.

drin. Der hat einfach seine

Stack-Maschinen und die arbeitet das alles ab und fertig.

Aber

wie ist denn dann die Runtime? Das ist ja dann nicht

Zip-Python, sondern das ist dann irgendeine andere Runtime,

die auf .NET läuft, oder wie?

Ja, nee, das ist

schon hauptsächlich Zip-Python.

Es ist nur so, dass man das irgendwie

also

keine Ahnung.

Es ist schon

Zip-Python, aber

es funktioniert

jetzt so halbwegs noch nicht schneller, aber

Leute könnten jetzt Optimierungen machen,

indem sie halt das irgendwie auf die

.NET Runtime irgendwie optimieren.

Rübergit.

Ja, war auf jeden Fall irgendwie so.

Kann man sich mal angucken.

Ich hätte mal den Artikel dazu in den Shownotes packen.

Ja, was hatten wir noch?

Genau, noch so Dinge wie

PEP 621

irgendwie mehr dazu

gekommen, was man jetzt alles so in PyProject

Tommel irgendwie reinschreiben kann an Metadaten.

Oh, cool. Was denn?

Ja,

ich glaube, so ziemlich alles,

was halt vorher so ein Setup

Flag 8 auch?

Ich glaube, Flag 8 wehrt sich noch

so ein bisschen.

Ja.

Was ist das? PyTest?

Geht fast. Also PyTest ist im Moment noch so mit

PyTest-E-Options, so ein Workaround.

Das wäre cool, wenn das normal wäre.

Und ich glaube, Flag 8 hat es noch nicht so wirklich

geschafft. Und habe ich noch was vergessen,

was fehlt?

Ja, ich glaube, das sind eher so Dinge wie, was ist der Autor von dem Ding und was sind die Abhängigkeiten und diese ganzen Geschichten.

Ja, aber so Black-Konfigurationen geht zum Beispiel schon rein und...

Ja, ja, gut, aber das ist ja jetzt ein Third-Party.

Ja, aber das ist ja nett, wenn man das alles da in die PyProjekt-Tummel packen kann, weil ich bin ein Freund von monolithischen Konflikten und nicht so ganz vielen kleinen, die irgendwo rumfliegen.

Ansonsten, was auch noch

ganz

witzig fand, ist,

da sind ja irgendwie neue Chips aus Apple rausgefallen.

Hat man gehört?

Ja.

Hat man schon

so Geräte gesehen?

Ja.

Also du hast schon so eine?

Ich habe jetzt keinen, aber ich habe schon

irgendwie Ergebnisse von

den Karten gesehen für Dinge, die ich

interessant fand. Und insofern,

wenn ich jetzt schwer überlege, ob ich da nicht vielleicht auch mal

zuschlagen soll, weil

es ist schon sendet.

Auf dem Papier jedenfalls und so, was man hört.

Wenn man in diesem

Ökosystem drin ist,

dann ist das, glaube ich, eine nette Sache.

Das ist ja so eine Sache, die ich gar nicht verstehen kann.

Sonst finde ich ja alles, was Mochen macht,

total bewundernswert und super. Aber dieses

Mekophilie, wie sagt man?

Ich weiß nicht.

Ja, Fankomolika.

Fanboytum.

Naja, also

das Schicke daran ist halt,

dass da sind jetzt

gar keine, zum Beispiel bei dem MacBook Air

sind halt keine Lüfter mehr drin.

Juhu, im Sommer, yay!

Ja, aber also die Leute

haben das ja schon benutzt und das

scheint halt...

Da sind auch keine Lüfter drin.

Der schönste Hack,

den ich gesehen habe übrigens,

der schönste Hack, den ich gesehen habe,

und Jochen unterhalten sich über die Programmiersprache Python

in Tesla innerhalb von 10 Minuten leer oder so.

Was es da

jetzt halt auch gab, ist schon so eine

irgendwie Preview-Variante

von einer

TensorFlow-Version,

die halt

gegen die

entsprechenden Bibliotheken gelinkt ist und

dann halt schnell ist halt auch

auf Metal und halt

auf der Apple-Hardware.

Und

das war

tatsächlich auch ganz nett. Also ich habe das dann auch mal, ich meine,

Das ist ja immer so ein Problem, man hat halt keine Nvidia-Karten auf Apple

und es gibt da einmal so eine Geschichte über PlateML,

das ist so eine Intel-Geschichte, die man sich installieren kann,

damit wird es dann halt schon mal ein bisschen schneller,

also da geht dann schon so ein bisschen was GPU-mäßiges,

halt auch mit den AMD-Karten, die da halt drin sind.

Aber ist halt nicht so schnell wie Nvidia

und ist halt auch nicht so schnell,

also die CUDA und diese ganzen Geschichten, das ist damit nicht so richtig vergleichbar,

aber so ein bisschen was kriegt man da schon hin.

Also zumindest so weit, dass halt so Maschinenlöhnengeschichten halt auf der GPU in so einem MacBook

sind halt genauso schnell wie halt mit den 8 CPUs sonst.

Ja, weil dann hat Nvidia 3090 oder sowas, da ist ja...

Ja, genau, die ist halt schneller.

Die passt in den Mac nicht rein, habe ich gehört.

Ja, nee, das geht halt irgendwie nicht.

In diese Mac Pros gehen die nicht da rein?

nicht?

Dachtest du, die hätten sogar Nvidia-Karten drin?

Das kann sein, dass das da geht, das weiß ich nicht genau.

Das sind wahrscheinlich 5000 Euro für eine Karte oder so.

Ja, ist ja egal.

Wenn der

Standfluss von dem Monitor schon 1000 Euro kostet,

dann ist das nicht so wichtig.

Aber der ist aus einem

massiven Block Aluminium rausgefräst.

Ja.

Ja, das ist auch

aus dem Bereich hätte ich auch News.

Jochen, was sagst du denn zu dem Durchbruch, was das Proteinfalten angeht?

Ja, das klingt auch sehr gut tatsächlich.

Das wurde so beschrieben als der erste richtige Anwendungsfall für AI,

der erste richtige Durchbruch von AI-Anwendungen.

Mit den Proteinfalten?

Wo eine amerikanische Firma DeepMind, die haben einen Algorithmus vorgestellt,

also Algorithmus kann man ja fast nicht sagen, aber die haben eine Technologie vorgestellt,

die aus einer Sequenzbeschreibung, also die Aminosäuren, die aneinandergereiht werden,

genau, die zum Beispiel durch Gene kodiert werden können, das fertig gefaltete Protein berechnet.

Und das Problem ist halt, dass diese Proteine zwar linear hergestellt werden,

aber sich dann eben zu einer dreidimensionalen Struktur zusammenfalten.

und weil die eben sehr viele Proteine

drin haben, die sich in sehr viele Richtungen falten können,

ist die Anzahl der Freiheitsgrade sehr hoch.

Und die haben jetzt eben eine

Technik vorgestellt, wie man innerhalb von wenigen

Tagen

so eine Faltung berechnen kann.

Also quasi ein Strang

aus einer RNA.

Was du reinkriegst ist

oder was du gegeben kriegst ist eine Abfolge

von Aminosäuren. Das ist ja fast wie eine RNA,

oder? Genau, das ist RNA.

Das ist so ein Problem aus der Biologie.

das 1973 auf irgendeiner Konferenz vorgestellt wurde.

Also seit 50 Jahren arbeitet man daran im Wesentlichen.

Und die Frage ist halt, wie dieses Protein dann dreidimensional ausschaut,

weil das bestimmt ganz viele der Eigenschaften dieses Proteins.

Und das kannst du nicht blutfaustrechnen, weil der Lösungsraum halt irgendwie 10 hoch 1000 ist.

Und die haben jetzt eben so eine Technologie vorgestellt, wo man in, ich glaube, vier Tagen Rechenzeit reingesteckt hat.

und dann haben sie im Schnitt,

da gibt es dann so einen Benchmark und so einen Wettbewerb,

wo sie im Schnitt

92% Übereinstimmung

hatten, wobei 92%

Übereinstimmung, das hört sich niedrig an,

aber ist wohl extrem hoch, weil

die Messwerte, die man so rauskriegt, sind

auch immer nur im Bereich zwischen 90% und 100%

Übereinstimmung. Also es ist im Wesentlichen wie

ein Messwert, den man da rauskriegt.

Und das ist eben tatsächlich eine Sache, die man

vorher nicht konnte und die es einfach nicht gab.

Und

die auch in der Medizin sehr, sehr, sehr, sehr, sehr nützlich ist, weil du dann eben nicht

die Moleküle synthetisieren und untersuchen musst, was sehr aufwendig und sehr teuer und sehr schwierig ist,

sondern du kannst halt sagen, hier, wir haben so eine Gensequenz gefunden, wie sieht denn das Ding aus?

Und das ist so, also es wurde wie gesagt beschrieben als so eine der ersten richtigen Durchbrüche von AI-Technologie,

von Machine Learning-Technologie, wo jetzt was möglich ist, was vorher einfach nicht möglich war.

Das heißt, man kann tatsächlich irgendwann

den ganzen Körper brechen irgendwann mal vielleicht so.

Ja, aber

das wurde halt dann

sozusagen so vorgestellt als,

ich habe dann halt den

Fortschritt gesehen als so ein Graph

und dann die letzten

beiden Geschichten waren halt deutlich besser und

jetzt halt das letzte so gut wie

fast ein Experiment oder quasi genauso gut

und jemand hat beschrieben das dann halt so, dass

der Image-Net-Moment für Proteinfaltung

also wo man halt sieht so,

okay, jetzt ist es so gut, dass man tatsächlich was damit machen

kann und der ImageNet war es ja auch so,

also bevor

Deep Learning da irgendwie, man da mit

reingegangen ist, waren die Ergebnisse einfach

man konnte es nicht verwenden und das war

halt bei diesen Proteinfaltungsgeschichten auch immer so,

weil die Genauigkeit war 40%, 50% oder so,

ja schon, es geht so ein bisschen was, aber es hat

halt nicht, man konnte es nicht verwenden

und jetzt ist es halt so weit, dass man es tatsächlich verwenden kann

und ja,

das ist natürlich schon beeindruckend. Ja, DeepMind, auch

interessant, ist von Google gekauft

worden,

die hatten doch auch schon AlphaGo

AlphaGo haben die gemacht, genau, AlphaGo Zero.

Ja, spannende Sache.

Aber hat nichts mit Python zu tun, also zurück zum Thema.

Hunde wollt ihr ewig leben, ja.

Ja.

Ja, das ist doch gar nicht so schlecht, also so ein Protein-Fighting,

da kann man auch bestimmt einige Sachen machen,

die den Körper verjüngen oder sowas. Das ist bestimmt ein gutes

Geschäftsmodell, wenn man da relativ weit vorne ist.

Ja, jetzt gerade ist es vor allem spannend,

weil man da halt auch mRNA-Sequenzen

mit brechen kann und hat welche, die richtig ist.

Gut, gut.

Ja, da geht einiges.

Genau, ansonsten

eine Geschichte und da,

das ist ja schon fast eine Überleitung

zu dem

Thema, es ist eine neue Release rausgekommen

von Phoenix

Live View

vor kurzem. Ich gucke da ab und zu

auch mal so ein bisschen jetzt rein, weil ich mir

dieses ganze Elixier-Erlangen-Ding halt auch so ein bisschen

angucke

und das

hat jetzt zum Beispiel auch File-Uploads drin.

Oh, das hört sich

total nach Jagni an

Ah, File Uploads, das machen wir in Release 12

das braucht kein Mensch

Ja, das hat mich jetzt auch gewundert, ehrlich gesagt

dass das noch nicht drin war

Ja, jetzt ist es drin und das ist auch

tatsächlich sehr schick

Ja, aber genau

da hat sich auch noch ein bisschen was getan

Ja, vielleicht musst du nochmal kurz sagen, was Phoenix überhaupt ist

Ja, das ist halt sozusagen das

Standard, oder ich weiß es nicht genau

Plus nichts Falsches sagen.

Ich kenne mich ja jetzt mit Elixir nicht so aus,

aber es ist halt so das Web-Framework.

Also Elixir ist halt

ein Dialekt oder

so eine etwas anders

aufgemachte Sprache,

die aber auch auf dieser Erlangen vor allem läuft

und

zu Erlangen runterkompiliert.

Und

Phoenix ist halt sozusagen das

Standard-Web-Framework dafür.

Was ist Erlangen? Kann man das essen?

Ja, Erlangen ist halt auch so eine Sprache.

Ericsson Language. Genau.

Wer oder was ist Ericsson?

Ericsson ist der große Telefonhersteller.

Der große Telefonhersteller

aus Norwegen, glaube ich.

Ja. Woher kommt Ericsson?

Und das, ich weiß nicht genau,

wann das entwickelt wird. Die heißen natürlich Sony Ericsson.

Ach.

Sind nicht mehr alleine.

Ja, und ich glaube,

das ist schon

ziemlich lange her, Anfang der 80er,

irgendwann dann so.

Das ist ein ganz, ganz, ganz geniales

Video aus den 80ern, wo sie das demonstrieren,

das ist R-Lang-System.

Mit der Ästhetik der 80er, aber

mit der Technologie, die heute...

Also, wenn ich das programmieren müsste, was die

damals zeigen, wüsste ich nicht genau, wie ich es machen würde.

Ja.

Ja, ja, ist schon mal ein...

Also halt R-Lang nehmen.

Ja. Und das ist halt

auch heute noch immer noch, es ist gerade

sehr hip im ganzen Web-Umfeld,

so für Backend-Geschichten, deswegen war das halt,

weil man quasi,

naja, so sehr, sehr robuste

Concurrency-Geschichten halt

geschenkt kriegt.

Ich meine zum Beispiel,

WhatsApp ist da drauf halt gebaut und so.

Das wurde doch für,

also das hat Ericsson doch für

seine Telefonsystem-Backends

Für die Telefonswitches ist das eigentlich gebaut worden.

Genau, und die dürfen halt nicht abstützen.

Also ich meine, wenn die abstützen, dann ist es halt echt blöd.

Deshalb ist das so robust.

Es gibt auch einige

Multiplayer-Gaming-Systeme, wo die

Backends in Erlang geschrieben sind.

einfach, weil die nicht abstürzen dürfen und

skalierbar sein müssen.

Man sieht die ja nicht. Das sagen immer nur Firmen

wieder hier, wir benutzen Erlang, um unsere Backends zu

programmieren, aber die siehst du ja nie.

Na gut.

Ich habe gerade mal bei Wikipedia geschaut

und da steht auf der Übersicht

Environment

.ccc

Auch interessant.

Crackers Competitors Costumers wollten die wohl sagen, aber

naja, das muss am Rande.

Kleiner Joke.

Aber Jochen kompiliert das wirklich zu Erlang

runter oder kombiniert das direkt zu Beam,

weil die VM heißt ja Beam VM.

Ja, ich meine,

ich meine,

es kombiniert erst nochmal zu Erlang

und dann,

aber, ja genau,

ich gucke dann immer nur so drauf.

Zu Beam, Beam me up, Scotty, was ist denn

jetzt wieder Beam? Ja, das ist eine VM,

die Erlang ausführt.

Das ist so wie C-Python.

Niemand interagiert je mit C-Python,

obwohl wir alle immer mit C-Python interagieren,

aber das ist das eigentliche Programm,

was das ausführt. Bei Erlang und Beam ist es genauso. Bei Erlang heißt es halt nicht

CRlang, sondern es heißt halt Beam. Und dann laufen Dinge wie Elixir

auf Erlang. Genau.

Und Elixir ist das Dango für Erlang. Nee, für Nix.

Das Phoenix ist das Dango für Elixir.

Elixir wird auf Erlang und das läuft dann auf Beam.

Und Beam läuft auf? Ich glaube da gibt es auch irgendwo OTP oder sowas darunter.

Prozessoren. Ja, ich glaube, dass das die Bibliothek ist. OTP ist die Bibliothek. Wenn ich das recht weiß. Aber ich lasse mich gerne in den Kommentaren.

Genau, jetzt müssen wir uns alle dafür schlagen.

Das ist wieder so ein neuer Namespace. Ich habe überhaupt keine Ahnung, wofür ihr gerade redet. Ich fühle mich etwas abgehängt.

Ja, das macht nichts. Dann fühlen wir uns besser.

Ja, ist klar.

Podcast-Software-Thema,

weil es gab

schon mal einen Versuch, also

nochmal eine Ecke

ausholen, so eine der

populäreren Geschichten, wie man Podcasts hostet,

ist ja irgendwie

der

Podlove-Publisher, oder es gibt ja natürlich

unterschiedliche Teile, was dieses Hosting betrifft, aber

so das Ding, was sozusagen

die Feeds generiert und

ja,

irgendwie auch den ganzen Website-Teil

so zum Großteil macht,

und das ist halt so ein WordPress-Plugin.

Vielleicht habe ich schon mal gehört, dass von Tim Püttlach, der mit Cars Radio existiert ist.

Ja gut, der hat das Projekt mal initiiert, da haben natürlich eine Menge Leute dran geschrieben.

Und man kriegt halt so Probleme, wenn man jetzt irgendwie WordPress und dann Plugin hat.

Also dazu gibt es jetzt auch einen ganz interessanten Podcast.

Padlovers Podcast

heißt der irgendwie und da wurde

über die Geschichte auch schon so einiges erzählt

und ich habe mir das halt mal angehört, weil ich

dachte, für mich ganz interessant, weil ich

diesen ganzen Hosting-Teil, den Publisher-Teil

ja sozusagen in Django

irgendwie gebaut

habe, halt natürlich nicht das, was das Ding

macht, aber halt so rudimentär, dass man damit halt

irgendwie für die Anforderungen,

die wir haben, das halt so halbwegs hinbekommt

und

ja, dachte,

vielleicht kann ich da so ein paar interessante Anregungen mitnehmen,

was man da eigentlich alles noch so tun kann und worauf man

aufpassen muss und so und ich fand

es sehr unterhaltsam und ich fand es auch

interessant in welche Probleme sie dabei reingelaufen

sind

zum Beispiel einfach mal so

ein bisschen so, ich meine, oder könnt ihr euch das

schon vorstellen, was man so für Probleme kriegt, wenn man

WordPress als Hosting-Plattform nimmt und dann

ein Plugin hat?

Nö, ich glaube da gibt es keine

keine Sicherheit-Probleme

und auch keine

Interabhängigkeiten und auch

keine Dependency-Hell, gar nichts. Ich glaube nicht, dass

ist nötig. Das ist ja klick, klick und funktioniert.

Ja, also das ist halt, ich meine, das ist halt so

eine, das ist natürlich super zugänglich und

das funktioniert überall und

insofern kann ich das natürlich in gewisser

Weise verstehen, dass man das macht, weil man halt

sozusagen, wenn man nicht benutzt

wird, dann hilft einem das natürlich auch alles nicht.

Aber wenn man es,

wenn es dann benutzt wird und es ist halt ein WordPress

Plugin, dann hat man halt auch einen Haufen Probleme,

die man sonst nicht hätte. Unter anderem

also der arme Mensch, der das dann erzählt

hatte, ich hätte leider den Namen auch gerade nicht

verraten, der da schon ganz lange dran rum

entwickelt,

erzählte dann so, ja, also wir

haben das, also irgendwann

wollten Leute dann so Statistik haben auch und dann

hm,

dann liefen aber die Statistikjobs irgendwie

so ein bisschen länger und

naja, normalerweise so

WordPress, das läuft dann halt auf

Hostern irgendwo und die

beenden die Prozesse halt immer

so nach einer Minute ungefähr.

Weil

normalerweise ist das kein gutes Zeichen, wenn dein

Web-Request länger als eine Minute läuft

und dann schießt man den lieber weg,

weil wahrscheinlich ist der eh kaputt

und

naja, du blockierst ja auch einen

Worker komplett sozusagen und das sind ja

Shared-Hoster und da gibt es ja ganz viele Leute

und dann blockierst du ja deren Ressourcen,

das heißt, ja, nicht so gut

und jetzt musst du halt aber

irgendwie um diese

Beschränkungen drumherum programmieren,

weil sowas wie

Background Tasks oder irgendwie Task Queue System oder so, hast du halt nicht.

Du hast halt auch nicht irgendwelche Maschinen mit Workern, die dann halt Sachen abarbeiten oder so.

Das gibt es halt einfach alles nicht. Und du musst halt alles in Requests abhandeln.

Das heißt, du musst darauf warten, dass ein Request vorbeikommt und dann guckst du halt in eine Kontaktverwaltung

und guckst halt, ob jetzt gerade irgendwas laufen muss und wenn ja, dann läuft das halt in deinem Request.

Und derjenige, der die Webseite aufgerufen hat, der hat halt ein bisschen Pech gehabt und der muss halt länger warten.

Aber du musst halt aufpassen. Wenn es länger dauert als eine Minute oder wenn du dich diesem Bereich näherst,

und Jochen unterhalten sich über die Programmiersprache Python

Sie wollten irgendwann die Podcast-Logos anzeigen

und

da gibt es ja die von iTunes

geforderten Größen, also so 3000x3000

Pixel, das ist ein bisschen groß.

Dann haben sie gesagt, okay, das rechnen wir einfach

ein bisschen runter und dann, ah, oh Mist,

so einfach kann man das aber nicht machen.

Man muss ja irgendwie berücksichtigen, dass auf unterschiedlichen

Monitorgrößen die Dinge

unterschiedliche viele Pixel haben müssen und so.

Und wie macht man denn das und was sind die Standardlösungen

von WordPress? Und dann haben sie gesehen, so, oh,

es gibt keine. Und

Das Problem hat mich ja auch schon

das ist auch etwas, wo ich bei Django etwas überrascht war,

dass es da einfach nichts gab.

Und ja,

dann mussten wir das halt auch irgendwie selber

bauen, wo man sich denkt, ja, das Problem hatte ich

halt auch schon, das muss ich dann auch selber bauen.

Aber, was

das Ganze halt deutlich schwerer macht, ist halt, wenn du

nicht selber das alles installiert hast und deine

Abhängigkeiten definiert hast, dann hast du halt

machst du das vielleicht mit ImageMagick oder so

auf

in zehn unterschiedlichen Variationen

über alle möglichen Hoster, die halt alle möglichen

unterschiedlichen Versionen

davon installiert haben.

Und dann musst du halt

Code schreiben, der mit 10 unterschiedlichen

Versionen von irgendeiner Bildbearbeitungsgeschichte

klarkommt, was natürlich totaler

das ist natürlich gruselig alles.

Ja.

Ja, und

genau all diese

Dinge und ja, ich meine,

kann man sich ja auch mal selber anhören,

also es war schon

interessant und ich fand das auch total cool, was sie da

alles irgendwie mit hingekriegt haben und

rausgeholt haben. Auf der anderen Seite würde ich

jetzt sagen, wenn man jetzt nochmal anfängt mit

sowas, dann nimmt man doch vielleicht lieber

irgendwie ein richtiges Framework zum Entwickeln von Webseiten und nicht irgendwie ein WordPress Naja das Problem ist was du jetzt gerade gesagt hast nimmt man vielleicht lieber ist nat nett

wenn man dann weiß, wie es geht.

Nee, ich glaube, das war tatsächlich Absicht,

dass das so, weil

die Frage war,

wie kommt man halt zu einer User-Basis?

Und das

geht halt nur, wenn man dahin geht, wo die Leute sind

und die sind halt bei WordPress, oder waren sie

auf jeden Fall zumindest damals

zu mehr oder weniger 100%.

Ich weiß nicht, ob sich das groß geändert hat.

Ja doch, es gibt mittlerweile Hoster.

Es gibt zum Beispiel Podijay

als Podcast-Hoster,

der inzwischen auch relativ groß ist

und

einer der Gründer davon

war halt auch bei einem von diesen

Podcast-Episoden zu Gast

und der erzählt dann so,

wir haben das dann auch gemacht,

irgendwie so Podcast-Hosting gebaut,

aber wir haben dann Ruby und Rails genommen.

Ja, okay.

Das ist schon mal eine deutlich bessere Wahl.

Also ich würde auch, wenn ich

so spontan sagen müsste, so Ruby on Rails ist wahrscheinlich

eine gute Wahl oder eben Django wahrscheinlich

auch, um sowas zu bauen, weil

da hat man halt einen Großteil von dem ganzen Kram,

den man braucht, der ist da halt schon einfach drin.

Oder

nachladbar zumindest.

Und man hat halt Wege

damit umzugehen

und das macht es halt dann natürlich schon mal deutlich

einfacher. Auf der anderen Seite ist es

dann halt so, wenn du jetzt aber

eigentlich

die ganzen

Podcasts, Blogs, die es da draußen gibt,

unterstützen möchtest in dem, was sie tun.

Ja, ist halt schwierig. Da musst du halt dann irgendwas für

WordPress entwickeln. Das ist natürlich nicht so

einfach. Also ich weiß es nicht. Ich habe keine Antwort darauf.

Ja.

Aber ich fand es halt interessant, dass das halt

sich da so entwickelt hat.

Und deswegen kam ich eigentlich drauf.

Die haben dann nochmal versucht,

das alles komplett neu zu bauen und zwar in

Elixir.

Aha

Die Katze beißt sich in den Schwanz

Genau und eigentlich eine ganz gute Idee

aber das ist dann

irgendwie auch nicht so richtig

dann fertig geworden

aber im Prinzip würde ich auch sagen

ja so Elixir klingt schon mal deutlich besser

Ja

Und das hat nicht gemacht, weil man das

mit Asim so toll machen kann bei Elixir

Ja, weil du damit halt auch

die harten Probleme lösen kannst

und du querst dich mehr, kannst du mit dem Maus hinterher spielen.

Ja, nee, das ist gut, aber

das ist nochmal eher solche Sachen

wie, du willst ja auch zum Beispiel die Files

irgendwie

distributieren, zum Beispiel.

Und du kannst

natürlich ein CDN nehmen, aber ich merke das jetzt auch

irgendwie, so CDN ist halt

einmal teuer und

ja, also weiß nicht,

wäre eigentlich schon cooler, das selber

machen zu können, aber dann ist halt wieder blöd.

Also das kannst du dann nicht irgendwie mit einem WordPress-Plugin

machen, da kannst du keine Files haben.

oder jedenfalls, kann man schon, aber

das...

Was ist mit einem selbst gehochten Minio oder sowas?

Äh, ja,

ja, ja, gut, aber...

Ist halt auch kein CDN, hast ja auch keine...

Wenn du globale Infrastruktur

haben willst... Also du meinst, die

Verteilung über mehrere Länder hinweg ist sonst kompliziert?

Ja, auch

generell die schnelle Anbindung, wenn du halt sehr

viele große Dateien hosten willst,

ist nicht ganz

simpel, das performant hinzukriegen.

Der Vorteil bei Elixir wäre, du kannst halt

alles damit machen. Du kannst

halt da dein File-Verwaltungs-

Dings mitmachen, genauso wie dein

Backend für irgendwie

dein Frontend und

du musst eigentlich nie

diese Umgebung verlassen und

kannst da drin halt alles bauen.

Warum ist das denn für alles geeignet?

Das hört sich an, als würdest du den Podcast umbenennen wollen.

Noch nicht, nein.

Lernst du denn Elixier

oder ist es nur ein Knight, der aus dir spricht?

Ja, es ist schon ein Knight

auch, ja.

Ich habe tatsächlich auch hier so

Alexir in Action oder sowas Buch rumliegen

Ich habe auch schon mal reingeguckt, aber ich habe es noch nicht

Das diffundiert jetzt durch dein Kopfkissen

durch in deinen Kopf

Genau, das hoffe ich mir davon

Mal schauen, was ist die beste Methode

Ich habe auch noch so ein, zwei Bücher unter dem Kopfkissen

Bei Alexir

habe ich auch immer das Gefühl, ich hätte gerne

die Zeit schon reingesteckt, das mal gelernt zu haben

Aber jetzt habe ich doch auch keine Lust

das gerade jetzt zu machen

Ja, aber Jochen, erklär mal

Warum ist das so?

Ja, Kekse sind ein großes Thema.

Also was halt auch

eben, weshalb ich das jetzt auch so betont habe,

man kann damit halt alles machen, du kannst damit halt auch

Files serven und kriegst halt, also zum Beispiel,

irgendwie nehmen wir dieses Problem von Hand,

in dem Django-Channel ja auch schon ein paar Mal

private Files serven

oder sowas.

Wenn du das jetzt irgendwie,

nehmen wir an, du nimmst jetzt mal Django als

deine Podcast-Hosting-Plattform

und jetzt willst du aber sowas auch

haben, vielleicht wie private Podcasts

keine Ahnung, wenn es was gibt, keine Ahnung, ich weiß es nicht,

aber du willst irgendwie den Zugriff beschränken.

Oder Bilder oder so von der Familie.

Deine geheimen Vertragsdaten.

Ja, irgendwie sowas. Dann

ist das halt nicht mehr so ganz einfach,

weil die Files kannst du ja

auch nicht mit Django direkt ausliefern, wenn du

das jetzt mal so die Folgen erst abgreifst.

Kannst du schon, ist halt aber dann

nicht so gut, wenn da viele Leute gleichzeitig

drauf zugreifen, geht das nicht so gut.

Auf der anderen Seite kann eigentlich nur

Django bzw. der Applikationsserver

entscheiden, ob jetzt...

Ob ein Request autorisiert ist oder nicht.

Der Dominik bezweifelt

unseren Erfolg.

Wieso?

Privat und viele Leute gleichzeitig.

Natürlich, in unserer coolen Gang

laden viele Leute...

Das passiert relativ schnell. Das passiert möglicherweise schon mit einem Browser.

Kriegst du das halt schon hin.

Also wenn du halt irgendwie da...

Wenn du mittlere Maus hast, dann mach dir einen neuen Tab auf.

Ja, wenn du einen neuen Tab aufmachst.

Wenn du zehn Bilder auf einer Seite hast,

dann ist es schon vorbei.

Das heißt, du kriegst das schon mit einem Browser hin

Also, wenn du jetzt

ich weiß nicht, wie viel Work hat du normalerweise

wenn du jetzt eine billige VM hast

auf Hexner oder weiß nicht

dann ist halt, wenn du da nur ein paar Prozesse

laufen hast, dann sind die halt schon mit einem

Request ausgelastet

Was ist jetzt mit Xcent-File?

Genau, das wäre dann halt

sozusagen eine Möglichkeit, das Problem zu lösen

dass man halt, dass der Request

an den Applikationsverfahrer geht, der

überprüft, ob der autorisiert ist

oder nicht und schickt dann halt ein Header

zurück in der Response. Ja,

also dieser Request sah gut aus

und dann geht jetzt irgendwas in der

Proxy-Pipeline in Nginx oder so hin,

sieht diesen Header in der Response

und sagt, ah, das war

eigentlich eine File-Response, aber

der Applikations-Server kann ja jetzt keine Files zurückschicken,

das wäre ja blöd, dann bleibt

ja die ganze Zeit die Verbindung offen und es gibt nicht so viele

Applikations-Server, daher nehme ich

jetzt mal diesen Request, diese Response

und tausche die aus durch eine File-Response

mit dem echten File, auf das ich Zugriff habe

und schickt das zurück.

Ja, da ist die Konfiguration dann doch wieder eigentlich

relativ plippal, weil in den X einen Eintrag

macht, der dann dieses X-File

Response send.

Ja, aber auf jeden Fall Nginx benutzen.

Genau.

Aber Jochen, warum ist denn das jetzt besser?

Warum ist denn das besser, wenn der

Nginx das macht, anstatt dass unser

Django, unser Gyrdokon oder so was...

Bei dem Nginx ist das halt egal, wenn da

tausend Requests reinkommen.

Aber warum? Warum ist das dem egal und warum ist es uns nicht egal?

Ja, deswegen

weil halt sozusagen eine Verbindung

den Nginx nicht blockiert

Also selbst wenn er da Daten zurücksendet, dann

kann er das auf tausend

Verbindungen gleichzeitig tun, das geht aber

jetzt bei einem normalen Django-Applikations-

Server so nicht, sondern da ist der

Prozess komplett geblockt, weil der halt

synchron Sachen rausschreibt

Das heißt, das müsste man an ASCII-Django nehmen

Der ist quasi

besser parallel als

Ja

ja, also der macht halt

parallel I.O.

Und das geht mit Django

erstmal so nicht, das geht jetzt inzwischen

auch so ein bisschen, aber erstmal

nicht so einfach.

Das Problem, was ich damit habe,

sozusagen aus der Systemperspektive, ist halt,

du musst halt einfach nur,

um diese Konfiguration dann testen zu können,

wenn du das jetzt lokal überprüfen willst,

funktioniert das denn alles so, wie ich das gedacht habe,

dann musst du dann Nginx hochfahren

und eine Datenbank und

und deinen Applikationsserver.

Du kannst es wesentlich nur in der Staging-Umgebung

testen, oder? Also in der

Develop-Umgebung hast du die ganzen

Bauteile ja normalerweise nicht.

Du kannst schon, dann fährst du halt einen Haufen

Docker-Container hoch, geht schon.

Aber das machst du ja nicht zum Entwickeln, sondern das machst du ja wirklich nur

zum Überprüfen.

Ja, naja, also

kann man

Also gut, ich mach das nicht.

Dann ist die ganze Liste, die in der Jammer drin ist,

die wird dann einfach mal hochgefahren.

Ja, der Punkt ist nur,

Es ist halt ein Haufen

Wenn 3 oder 4 so Dinge laufen hat, dann ist schon der Speicher voll

Jaja, also es ist halt

aufwendig und es ist halt auch

irgendwie eine komplizierte Konfiguration und es ist halt

fehleranfällig und wenn du

jetzt Elixir verwendest

dann ist

das halt alles, dann kannst du das

lokal testen, du kannst lokal das entwickeln

und du kannst, deployst es so

produktiv, natürlich vielleicht mit einer etwas anderen

Konfiguration, aber mehr oder weniger genauso wie du es

lokal getestet hast und wenn das dann lokal

funktioniert, dann funktioniert das dann auch. Und du brauchst keine komplizierte

Architektur mit irgendwie noch drei anderen

Teilen, die halt zusammen

funktionieren müssen, damit es klappt

insgesamt. Und das hat natürlich einen gewissen

Reiz. Also ich meine,

ich entwickle auch viel mit Docker, weil

das halt, ja,

bei ganz vielen Leuten wahrscheinlich so das Mittel der Wahl ist,

um halt die Entwicklungsumgebung zu vereinheitlichen.

Und bei mir ist das so, also

das lüftet, also mein Laptop lüftet

einfach die ganze Zeit.

Achso, stimmt, das war noch mal.

Und wenn ich das vom Strom abstecke, dann dauert das eine Stunde und dann ist

Akku leer und das ist halt irgendwie eigentlich kein schöner Zustand, aber so ist es halt.

Also das ist bei mir nicht so, Jochen.

Ja, wenn man jetzt nicht Docker...

Das ist eine andere Konfiguration.

Ich versuche auch gerade so ein bisschen wieder von dem Docker-Satz runterzukommen, weil das ist halt echt das...

Ach ja, und jetzt bei den neuen Macs geht das ja auch gar nicht mehr.

Die haben keine Virtualisierungsunterstützung.

Okay, cool. Wie war der Fortschritt?

Es gibt keine Virtualisierungsunterstützung, also kein Parallels oder was?

oder?

What? Wegen ARM? Warum?

Ja, ich weiß nicht,

ob das noch kommt oder so, aber einen Tag

gibt es das auf jeden Fall nicht. Ach cool, dann muss man sich

endlich eine Hand schaffen.

Wirklich nicht.

Ich brauche dann zwei

für Windows

und einen für Microsoft.

Ja gut, aber

ich meine, wie man seine

Entwicklungsumgebung betreibt und

warum man das wie macht, das ist ja so ein bisschen

freigestellt. Aber der

eigentliche Hintergrund

ist doch halt wirklich der, dass man in Python

einfach daran gebunden ist,

dass jeder

Worker einen Request bearbeiten kann, weil

die halt nicht parallel arbeiten können.

Und in Delixia ist es halt nicht so, weil

die VM, auf der

es läuft, halt super parallel ist, weil die alles

gleichzeitig machen können.

Auch hier wieder

mit dem Hintergrund halt, dass das aus einem

Telekommunikations-Background

kommt und wenn die Hardware nur

ein Telefonat gleichzeitig machen kann,

dann ist das halt ziemlich blöd und

und es ist besser, wenn man tausend Telefonate gleichzeitig macht.

Das erinnert mich an die 90er, wo mein Dad mich die ganze Zeit angeschrien hat,

geh aus dem Internet, ich will telefonieren.

Und wenn ihr da halt so einen Knotenpunkt gehabt hättet, dann hättet ihr vielleicht mehrere Sachen.

Aber so Telefonate haben ja auch üblicherweise sehr strenge Real-Time-Anforderungen.

Das heißt, es reicht ja nicht, tausend Sachen gleichzeitig zu machen,

sondern du musst ja tausend Real-Time-Sachen gleichzeitig machen.

Und dann ist dieses sowieso schon schwierige Problem nochmal direkt ein kleines bisschen,

noch viel schwieriger geworden.

Und

das ist so ein bisschen für mich das

Coole an dieser ganzen Erlangen und

Elixir-Sache, weil die halt einfach eine

Basis haben, eine VM haben,

die knallhart darauf

ausgerichtet ist, tausend Sachen gleichzeitig

in Realtime zu machen.

Und wenn man das braucht, dann ist das

eine absolut geniale Sache. Und das ist, glaube ich, eben

in so einem Web-Umfeld kann das wirklich was sein, wo man das

einfach ausnutzen kann, wo du halt wirklich sagen kannst,

okay, da kommen Dateien rüber, da

kommen Authentifizierungen rüber, da

kommt alles drüber.

Und

ja, das ist auch so ein bisschen

die Faszination, das ist der Grund,

warum ich das gerne mal gelernt gehabt hätte.

Ja, oder

noch ein Beispiel, wo das vielleicht ein bisschen deutlicher

wird. Ich habe jetzt gerade nochmal kurz

drüber nachgedacht. Also wenn man jetzt zum Beispiel

etwas, was man

häufig nicht hinkriegt,

es gibt so eigentlich,

was man gerne hätte eigentlich,

ist dieses HLS,

also HTTP,

Live Streaming.

Sozusagen,

das ist ein Standard.

Im Grunde, das zahkt halt große Dateien

in viele kleine.

Aber du brauchst halt Server-Unterstützung dafür.

Wenn du das jetzt gerne anbieten würdest,

sodass Podcast-Clients das sozusagen

nutzen können, um halt

auch auf schlechten Verbindungen und halt auch

irgendwie Online-Sachen zu streamen,

dann hast du halt, wenn du jetzt ein normales System baust,

sag ich jetzt mal, so eben mit Ruby und Rails und keine Ahnung,

Nginx und so und weißer Teufel,

hinzukriegen, wird ein echter

Stunt.

Während, wenn du das halt alles in Elixir machst,

dann ist das halt bloß Code, den du schreibst.

Du musst auch den Standort unterstützen

und du musst es halt irgendwie hinkriegen.

Aber das ist halt auch nur dein Applikationscode und nicht

irgendwie ein großes System, was du da irgendwie

drumherum konfigurieren musst.

Und du kannst alle diese Anforderungen

damit in den Griff kriegen.

Das hat schon einen gewissen Charme.

Ja, wir sind einfach tief

im Web-Server drin.

Du hast einfach

die Fähigkeiten, die du

in dem Nginx hättest.

Im Prinzip kannst du das ja alles mit Nginx-Modulen machen.

Kannst du ja Module schreiben.

Nur, dass

die Zuhörer haben gerade eben abgeschaltet.

Die sind schon lange weg.

Dann muss man das halt möglicherweise auch tun und das will eigentlich keiner.

Ja, also okay.

Das kann man mit Caddy und Traffic oder sowas nicht

einfach machen. Was kann man bei alterer Alternative noch?

Nein, leider alles nicht.

Nein.

also kannst du auch

kannst du auch in Traffic reinbauen

musst dann halt in Go programmieren

kennst du das auch Go oder?

ja genau kannst halt auch in Go schreiben

können die beide Module

die nachleitbare Module

ja so

Mittelware

ja also

ist auf jeden Fall dann nicht mehr so richtig einfach

und es ist halt ganz was anderes als die Applikation

die du dann normalerweise so schreibst

aber genau

Genau, also wie kriegt Erlang das denn jetzt eigentlich hin?

Es verwendet halt das sogenannte

Actor-Model.

Uh, das muss ich gleich noch,

wenn du noch besser klingen willst, musst du sagen,

Shared Nothing Concurred Programming via Message Parsing.

Okay.

Schön, wissen alle Bescheid, oder?

Fertig für heute.

Nee, ich bin gerade abgeschlossen.

Das ist was, was man sehr schnell,

Ich habe ja mal versucht Erlang zu lernen

Habe es dann wieder

aufgegeben, aber das ist so was

das ist so was konzeptuelles

was man sehr schnell lernt, wo man sich aber

ungeheuer schwer nur dran gewöhnen kann

Also in dem Modell, in dem ich

üblicherweise so lebe und programmiere

in Python

da schreibt man halt Programm und es wird von oben nach unten abgearbeitet

und wenn ich eine Funktion aufrufe, dann ist das so

wie wenn ich die Funktion da eben an die Stelle hin

kopiert hätte

im Wesentlichen

so, bis auf so ein paar Ausnahmen mit

Rekursionen und Scopes und so, ist das

das Modell, was ich im Kopf habe.

Wenn ich eine Funktion aufrufe, dann ist das so, wie wenn die

da jetzt steht.

Und in Erlang ist das aber nicht so.

In Erlang ist das Modell

so ein bisschen anders. Da

schreibt man ein Programm und es besteht aus ganz vielen

Prozessen

und auch, was ein Prozess ist, ist da auch

erstmal, es wird so ein bisschen, ja,

ein Prozess ist, stell dir einfach ein Prozess

vor. Und die können

sich dann Nachrichten schicken und zwar in ihre Mailboxes.

Also jeder Prozess hat eine Mailbox

und da kann man sich Nachrichten hinschicken.

Und das Einzige, was diese Prozesse machen, ist

im Wesentlichen Nachrichten

aus ihren Mailbox abrufen und die

bearbeiten und anderen Prozessen

Nachrichten in ihre Mailbox reinschicken.

Und das ist von der

Vorstellung her was total

verrücktes, was total absurdes,

weil wie kann man denn daraus ein

funktionierendes Programm machen?

Das könnte man ja in Dango auch machen, indem man irgendwie so einen Cache

und Jochen unterhalten sich über die Programmiersprache Python

und Jochen unterhalten sich über die Programmiersprache Python

Das heißt, wenn ich entschieden habe, ich als Anwendungslogik habe entschieden, da muss jetzt diese Datei ausgeliefert werden, dann ist meine Arbeit beendet, indem ich eine korrekt formantierte Nachricht an die Mailbox Dateien ausliefern schicke. Dann bin ich fertig.

und auf der anderen Seite dieser Mailbox ist halt irgendein

weiterer Prozess, der macht nichts anderes als, da kommt eine Nachricht,

ich soll eine Datei ausliefern an folgende Verbindung oder an folgende IP oder sonst was,

also mache ich das und dieser Prozess macht nichts anderes. Das heißt, es gibt

einen Prozess, der ist zuständig für, oder eine Mailbox, einen Actor,

der ist zuständig für Dateien ausliefern, es gibt einen Actor, der ist zuständig für Authentifizierung,

es gibt einen Actor, der ist zuständig für die Datenbank, es gibt einen Actor, der ist zuständig für

oder was weiß ich, SSL Termination, was auch immer man haben möchte.

Bühne frei.

Jeder Actor macht eine Sache und ist für eine Sache zuständig.

Und wenn jemand anders was machen soll, dann ist es einfach nur eine Nachricht.

So, jetzt könnte man sagen, okay, das ist ja in einem objektorientierten System nicht anders.

Da schickt man Nachrichten von Klassen zu Klassen.

Der Unterschied ist, dass diese Actors selbst laufende Prozesse sind.

Das heißt, wenn ich eine Nachricht schicke, dann wird die halt

gleichzeitig, die wird jetzt sofort bearbeitet.

Ich muss nicht warten, bis die Nachricht abgearbeitet ist von der Klasse und das kann ja

sehr lange dauern. Wenn meine View-Klasse aufgerufen wird und ich eine Datei ausliefern muss,

dann dauert es halt so lange, wie es dauert, die Datei auszuliefern und dann ist die Nachricht

bearbeitet. Sondern das sind wirklich einfach nur kurze Nachrichten. Mach das.

Mach das. Tu das. Hier ist was passiert. Also Events.

Das sind einfach nur Dinge, die passieren sollen oder Nachrichten, die in dem System relevant sind und die werden dann sofort weiter bearbeitet. Und derjenige, der für die Authentifizierung zuständig ist, der kann sofort den nächsten Request authentifizieren.

So, das ist die eine Sache. Die andere Sache ist

in Klassen ist es, wenn man eine objektorientierte

Architektur hat, dann ist es sehr leicht Daten zu verteilen. Da gibt es

diese, wir haben ja schon drüber gesprochen, es gibt diese Sachen, wie man Klassen aufbauen sollte und

dass die abgeschlossen sein sollten und dass die ihre privaten

Daten privat halten sollen und das Null-Interface und so weiter. Aber im Endeffekt ist es

ja doch irgendwie so, dass man schon ungefähr weiß, was diese Klasse wie macht.

und auch was die für Daten enthält.

Und dann manchmal ist es halt auch so, dass man

auf Daten zugreifen muss, die

halt da drin sind und die da draußen sind. Das geht

in diesem Ektormodell überhaupt nicht. In dem Ektormodell

gibt es nur eine Möglichkeit

mit einem anderen

Ektor zu kommunizieren und das ist über eine Nachricht.

Das heißt, alles was in diesem

Ektormodell passiert ist, du schickst Nachrichten.

Aber

die Ektormodelle kann man dann klonen oder was? Oder dass

die doch gleichzeitig irgendwas machen können?

An der einen Mailbox?

gesagt hast, oder?

Die Mailbox ist der Endpoint.

Du schreibst eine Nachricht und du schreibst die

in den Briefkasten rein und dann bist du

nicht mehr dafür verantwortlich.

Dass da zehn Leute gleichzeitig

diese Mailbox bearbeiten, das kann dir

völlig egal sein.

Dann hast du so ein

Niko oder Fifo oder sowas,

kannst halt einfach Dinge da rausnehmen

aus der Mailbox.

Da gibt es dann sehr, sehr viele.

Das ist halt so, dass

Tausende,

gar kein Problem, auch Millionen kein Problem.

Und das ist

das kannst du quasi beliebig

hochskalieren, sagen wir mal so.

Man kann die auch dynamisch neu starten.

Die werden auch dynamisch neu gestartet.

Und wenn so einer abbricht, wenn einer kaputt geht,

weil er irgendeine Nachricht nicht verstanden hat,

dann wird der halt gelöscht und einfach ein neuer gestartet.

Zack, der ist jetzt weg.

Was ja kein Problem ist,

wenn sozusagen

also was man dazu noch sagen muss, genau

eine schöne Eigenschaft

sozusagen für dieses Modell

die halt Erlang da auch direkt mitbringt

ist, dass da das ja so eine funktionale

Programmiersprache ist, ist halt sowas wie

Daten verändern, das geht

halt einfach nicht

das ist prinzipiell nicht

möglich, du kannst

halt bloß Daten kopieren, aber das heißt

du kannst Sachen auch mal perfekt cachen und so

und es ist auch

egal wer da was macht, weil

ist ja sowieso immer nur das Gleiche.

Es ist halt nie, du kannst,

es ist nicht möglich, dass jemand hinterher irgendwie Daten

verändert hat und das in einem anderen State

ist oder so, sondern

ja, wenn der

State irgendwie kopiert wird

und dann macht das halt ein anderer Actor, ist das halt völlig

egal, wer das jetzt war.

Ja, oder auch wenn der abstürzt und andere übernimmt

das, ist egal. Das ist völlig wurscht.

Die sind alle gleich. Du hast eine Armee von

identisch ausschauenden Schauspielern.

Ja, und

man kann das halt auch nicht umgehen, weil

ja, das verbietet einem die Sprache.

Es gibt ja auch sozusagen ein Acta-Implementierung

in anderen Sprachen. Es gibt diverse

in C++ zum Beispiel, aber...

Python gibt es auch? Acker? PyAcker, ja.

Super Sache übrigens, sollte jeder

verwenden. Okay.

Ich habe nur gehört, dass es das gibt. Ich weiß aber nicht.

Ich wundere, dass es sich an der Scala-Acker-

Geschichte orientiert. Ja, genau, das kommt von Scala.

Wann, wie, wo benutzt man das dann?

Wobei Scala ist ja quasi

Erlangen für... Ja, für die...

Ja, genau.

mit.

Wie benutzt man das dann?

Dieses PyAK?

Ja, wenn du halt

synchrone Sachen haben willst.

Das Problem an PyAK ist halt,

dass das immer noch den Gil beachten muss.

Das heißt, du gewinnst nicht so ungeheuer viel,

weil du immer noch in dieser

mehr oder weniger Single-Trailed-Python-Welt

festhängst, aber das macht

die Struktur einfacher. Es löst

dich davon ab, alles in einem

Ablauf machen zu müssen, sondern du kannst sagen,

dieses Ding ist jetzt verantwortlich für

und das hat folgende Ressourcen

fest in der Hand und zack.

Aber was du halt nicht hinkriegen

kannst und was das halt so ein bisschen

also ich meine klar, du kannst natürlich dann sagen, okay

ich weiß, ich darf hier nur

immutable Datenstrukturen verwenden und so

aber du kannst natürlich Sachen schon ändern

wenn du böse bist und

das geht halt

in Erlangen nicht.

Ich habe gerade auch eine andere Bibliothek gefunden, die heißt

Tespian. Habe ich auch nicht reingeguckt.

Keine Ahnung.

und die Theater-Schauspieler.

Ja, genau.

Also ich meine, man zahlt da natürlich einen Preis für.

Also man zahlt den Preis vor allen Dingen

in Hauptspeicher.

Man muss halt alles kopieren, wenn man irgendwas verändern will.

Das ist halt auch das, was einen im Wesentlichen

begrenzt, dass die Anzahl der

Actor-Dinger

halt angeht.

Wenn der Hauptspeicher voll ist, dann ist halt Schluss.

Und es ist halt

auch ein bisschen langsamer. Also wenn man jetzt sagen würde,

okay, man macht das Ganze

handoptimiert irgendwie mit

Threads oder so, dann ist das wahrscheinlich schneller.

Aber sagen wir mal so, es ist halt

ein sehr, sehr guter Kompromiss eigentlich,

wenn es um

Dinge

parallel, concurrent

und in zuverlässig machen geht.

Und so diese

letztes Sequenzchen Performance brauchen

die meisten Leute ja dann eh nicht.

Ja, und selbst

dann bist du ja oft

in so einer Situation, wo Stabilität einfach

wichtiger ist.

Und die kriegst du da halt

für umsonst mit dazu, weil es

sehr schwierig ist, da diese

VM zu crashen.

Und selbst wenn du irgendwas machst, was crasht,

dann hast du halt diesen einen Request

gecrashed.

Aber der Rest läuft weiter.

Es ist quasi nicht möglich, diese Maschine abzuschießen.

Und das ist

schon was, wo

man auch mit Neid draufschauen

kann, weil das ja in anderen Systemen

relativ leicht ist.

Es ist eher so

schwer, das Ding irgendwie am Laufen zu halten.

Da muss man immer irgendwie

die ganze Zeit

irgendwie Fünfteller jonglieren

auf einem

Einrad herum, auf einem Seil

herumfährt oder so.

Das ist da ganz angenehm.

Aber es ist natürlich auch ganz klar

ausgerichtet auf so Workloads, die parallel

sind. Also eben

genau aus dem

aus dem Telefonieumfeld her.

Jedes Telefonat selber braucht

nicht ungefähr euer viel.

Du musst halt dann irgendwie deine

16 Kilobit musst du durchkriegen

oder deine, wie auch immer sie gerade runter

haben, aber das ist

ja nicht viel. Aber du hast halt

1000 Stück davon gleichzeitig in der Hand.

Und in anderen Workloads hast du ja andere

Anforderungen.

Zum Beispiel Machine Learning.

Da brauchst du halt eine Sache,

die du 100.000 Mal ausführen musst

und da ist es besser,

Prozessoren zu haben, die das schnell machen können.

Deshalb hat sich das ja auch so ein bisschen anders entwickelt.

Und ich glaube auch, dass da der Hintergrund so ein bisschen

anders ist. Python kommt ja wirklich

aus dieser

ein Programm tut eine Sache

Welt und

da ist es dann halt einfacher zu sagen,

okay, die Programme werden schneller, weil die

Prozessoren schneller werden, weil die Single-Field-Performance

schneller wird. Aber jetzt sind wir

nun mal genau in so einem Umbruch,

wo es tatsächlich so ist, dass eben Single-Field-Performance

nicht mehr schneller wird.

Aber dafür kannst du jetzt einen Computer kaufen, der

64 Cores hat. Oder gibt es nicht von AMD sogar schon die mit 128?

Kann gut sein, ja.

Das hat man ja in der ersten Sendung schon

und ich würde da tatsächlich, ehrlich gesagt, bei bleiben

dass man das selten hat, dass man beides braucht. Also du kannst ja

problemlos 128 Python-Interpreter starten. Also wenn du 128 Cores

hast, dann hast du wahrscheinlich auch genug Hauptspeicher, um

128 Prozesse zu haben.

Aber da hast du halt nur 128.

Kannst du 128 gleichzeitig

beantworten.

Nicht 12.800.

Aber wenn CPU dein Problem ist

und dann

brauchst du...

Also wenn I.O. dein Problem ist, gut,

aber dann brauchst du die ganzen Prozessoren eigentlich nicht.

Dann kannst du das auch auf einer CPU...

Also naja, ich weiß es nicht so genau.

Ja, also ich meine,

man hat es selten, dass man beides braucht

und für beide

Extremfälle gibt es halt sehr gute Lösungen.

Den

Data Science CPU

verbrennen Use Case,

da gibt es super Lösungen für.

Den kann man jetzt nicht zum Websurfen verwenden, aber

das funktioniert super.

Sehr schöne Computer von Nvidia

für mehrere hunderttausend Dollar.

Ja.

Würde ich nicht als Web-Server einsetzen.

Ne, genau, das macht da nicht so viel Sinn.

Und auf der anderen Seite ist halt

irgendwie, weiß ich nicht, eben

Lib,

kriegen wir den Übergang zu

Python wieder hin oder halt

auch eben Node.js, LibUV ist

halt auch auf einem Prozessor, macht das schon

irgendwie ordentlich I.O.

LibUV.

Das ist sozusagen die

Event-Loop, die unter Node.js und halt

auch bei Python, also normalerweise

in Produktivgeschichten nimmt man halt immer LibUV

statt der AsyncIO

Standard Event Loop.

Aha, kein AsyncIO?

Das ist AsyncIO.

Würdest du Ubicorn verwenden

statt... Also kann man

auf jeden Fall, ja.

Und

ja, man kann halt

bei AsyncIO ist es so, du kannst die Implementierung

deiner Event Loop kannst du halt austauschen

und du kannst halt entweder die Standard

Implementierung nehmen

oder du nimmst halt libUV zum Beispiel

und libUV ist dann halt deutlich schneller.

und

ja, also zu der

Historie, ich weiß jetzt ehrlich gesagt nicht so ganz genau, ich glaube

es gab einmal LibEV,

das Ding ist auch schon ziemlich alt

und... Aber das ist

doch eine C-Bibliothek, oder? Ja, ja,

LibEV auch. Die einfach nur Event

in EVE und LM anfängt.

Genau, das ist, die implementieren

das sogenannte Reactor-Pattern

irgendwie und benutzen

unten drunter Syscrolls. Da mal ein Podcast

dazu geben, so Pattern. Ja,

und Ich glaube da m wir auch noch ein paar Teile irgendwie machen Also das Ja aber vielleicht tats nochmal genau das erkl was das Reactor vielleicht ist Und dann vielleicht auch nochmal was halt Event sind Genau das haben wir das letzte Mal da haben wir da aufgeh

Ja, also

Reactor-Pattern...

Seit dem genagten

Leser zu überlassen.

Du hast halt so Syscalls

in Unix.

Da gibt es auch unterschiedliche, je nachdem, welche

der Unix-Art man verwendet.

E-Poll unter Linux.

Vielleicht nochmal, wir müssen doch ein bisschen nur den Anfang.

Was ist ein Syscall? Oh nein, oh mein Gott.

Jetzt muss man tief reinsteigen.

Also sozusagen,

das ist die Art, wie

mit dem

Betriebssystem kommunizieren.

Also das, was jeder kennt,

vielleicht ist sowas wie, du machst einen Pfeil auf.

Du musst jetzt irgendwie an die Bits

auf der Platte tatsächlich rankommen und

der tatsächlich bei Unix

ist so der Syscall für alles,

ist halt open. Das ist ja auch der Trick

bei Unix, dass man sagt so,

es gibt nur einen syscall.

Eigentlich ist

alles ein Pfeil, genau.

Es ist völlig egal, was es wirklich ist.

Pfeil ist unsere Abstraktion

für einfach

alles.

Also wenn man das annimmt, dann kommt man

bei Unix ziemlich gut raus.

Ja,

genau, das ist halt

die Art, wie man dem Kernel sagt, ich hätte jetzt gern

da zum Beispiel irgendwie Zugriff drauf.

und dann sagt man halt Open.

Und das kann man eben

nicht nur mit Files machen, sondern auch mit Netzwerkverbindungen,

die ja dann in Unix auch nur Files sind

oder Hauptsprecher ist auch nur Files oder halt

irgendwie Pipes, Kommunikation

und so, das ist auch alles immer nur ein File.

Also man kommt ja sehr weit.

Der Bildschirm ist auch ein File, oder?

Ja.

Und die Terminals sind auch Files.

Ja.

Jetzt muss man nur noch wissen, was Files sind.

Ja.

Das ist das Abstrack.

Das können wir in dieser Vorlesung nicht machen.

Es ist ein sehr, sehr, sehr, sehr, sehr

simples Interface. Es ist einfach unstrukturierte

Daten und du kannst darauf zugreifen,

indem du halt

daraus liest und reinschreibst.

Aber sortiert. Das ist das Wichtige, oder?

Du hast eine Abfolge von Bytes.

Ich kann hin und her springen, ja. Ich habe so einen Zeiger, der

Interface. Ah, nicht jedes File kann hin und her springen.

Files können sagen, sie dürfen hin und her

springen oder auch nicht.

Okay, dann

habe ich jetzt ein Cisco, das macht ein Open.

Okay. Genau.

also insofern auch alles

schick, das Problem ist jetzt natürlich

und das ist auch gar kein Problem, oder Jochen?

also ich meine, da brauchst du noch keine Lib dafür, sondern

du brauchst halt nur wissen, wie du das

aufrufst und das ist super

und nett und easy und wenn du jetzt gegen deine

was weiß ich, Bibliothek, gegen deine

Kernel-Bibliothek

kompiliert hast, gegen deinen Kernel-Header

dann kannst du die Sachen aufrufen

warum brauchen wir jetzt Lib-EV?

warum brauchen wir Lib-Event oder Lib?

Ja, das ist sozusagen eine Abstraktionsschicht

Schicht über den

Syscalls, weil das Problem ist, du hast jetzt

unterschiedliche Syscalls, je nachdem welches

Betriebssystem du hast, die eben so

etwas machen wie, naja,

du machst jetzt nicht einfach nur einen Pfeil auf und schickst da irgendwas,

das kannst du auch, dann ist es aber

blockierend und synchron. Du willst

jetzt aber nicht blockierend irgendwie lesen

und schreiben, weil du möchtest ja gleichzeitig

parallel irgendwie

Datenströme in der Gegend herumschicken.

Weil wenn du blockierst, dann kannst du immer nur

eins nach dem anderen machen und das ist ja, wenn du

jetzt tausend Leuten gleichzeitig einen Pfeil schicken möchtest,

geht das halt nicht so gut. Und

dafür gibt es dann halt

andere Interfaces, die das möglich

machen. Und

da gibt es dann halt so die uralten

Geschichten in Unix

sind halt so Select, der Select-Discall

und Poll.

Und

im Wesentlichen gibt man den...

Jetzt musst du trotzdem kurz sagen, was Select ist und was Poll ist.

Jaja, also ich fange mal mit

Poll an. Du gibst Poll

einfach eine Liste von

Pfeildeskriptoren sozusagen, also offenen Files

eigentlich mehr oder weniger.

Und dann wirst du irgendwie benachrichtigt, wenn

da irgendwas passiert ist vom Kernel.

Und das Problem

dabei ist halt, dass, also bei Paul kannst du

halt irgendwie, ach Gott, das muss ich

tief in Erinnerung kramen. Also der

Vorteil ist, du kannst halt beliebig viele Files da

reintun, also beliebig viele Netzwerkverbindungen haben.

Der Nachteil ist irgendwie, ist es halt O von N

oder sowas. Also deine

Zeit,

die das im Kernel verbringt, wird halt immer mehr,

je mehr du da reinsteckst. Und bei Select

war es so, dass

dass das schnell ist, das ist ja irgendwie O von 1, aber du kannst irgendwie nur 1024

Pfeildeskriptoren oder so irgendwie da reinstellen. Was ist denn ein Select jetzt, also ein Unterschied?

Also im Wesentlichen geht es doch darum, dass du auf Daten wartest.

Das heißt, der Syscall heißt, du kannst sagen,

ich möchte jetzt die Datei lesen und dann gibt es einen Syscall,

der heißt ReadData oder wie auch immer der heißen mag und

der blockiert dann halt, da musst du so lange warten, bis die Daten da sind.

und das ist bei einer Netzwerkverbindung

echt blöd. Das willst du nicht, genau.

Dann kannst du sagen, okay,

wir modifizieren den und sagen,

wir machen Readdata, aber nicht blockierend,

das heißt, wenn was da ist, dann kriegen wir das

und wenn nichts da ist, dann kriegen wir halt zurück,

es gibt gerade nichts.

Und damit kannst du das ja umsetzen,

damit kannst du Polling machen, damit kannst du sagen, hier,

alle meine Netzwerkverbindungen, was gibt's denn jetzt hier?

Aber Polling ist halt schlecht,

weil dann, das ist aktives Warten.

Busy Waiting, genau,

und das verbraucht halt CPU.

Ja, und vor allem, während du auf eins wartest,

kann ja bei einem anderen was passieren und das

bemerkst du dann halt erst, wenn du soweit bist, dass du da bist.

Das steht die ganze Zeit nach.

Bist du schon da? Bist du schon da? Bist du schon da?

Bist du schon da? Bist du schon da?

Genau, aber wenn du jetzt bei

zehn Türen immer anklopfst und sagst,

bist du schon da? Bist du schon da? Dann kann es ja sein,

dass du bei der zehnten Tür bist und bei der,

du bist bei der ersten Tür und bei der zehnten Tür passiert

jetzt gerade was und du merkst es aber

erst, wenn du die anderen neun alle durchgefragt hast.

Das heißt, du hast nicht nur

viel CPU verbraucht, für was, was eigentlich

nichts bringt, sondern du hast auch noch hohe Latenz

drin.

Du kriegst die Nachrichten, du kriegst nicht sofort mit,

dass irgendwas passiert, sondern du kriegst erst mit,

wenn du dazukommst, danach zu fragen.

Und das ist natürlich schlecht, weil

du dann eben eine unnötige

Latenz hast. Du hast unnötige Wartezeiten, die du nicht

brauchst. Und jetzt wird es noch schlimmer,

wenn du das nämlich naiv machst, dann kannst du so

ein Problem haben, das Starvation heißt.

Wenn du sagst, wenn irgendwas passiert, dann fange ich

wieder bei Tür 1 an nachzufragen.

Und dann passiert das nicht.

und doch, doch, dann hast du nämlich Starvation, weil wenn bei Tür 10 irgendwas ist,

da kommst du ja nie hin, weil wenn davor irgendwas passiert, dann kommst du nie dazu,

Tür 10 nachzufragen. Das heißt, du musst dann auch noch aufpassen, dass du die in einer

gewissen Reihenfolge abfragst, die nicht dazu führt, dass einer hier

liegen gelassen wird. Also Polling ist was ganz Schlechtes, wenn du auf

Daten wartest in einer aktiven Verbindung. Und deshalb gibt es

diesen Select

Syscall, wo du eben sagst,

benachrichtige mich, wenn irgendwas

von diesen

1024 oder eben jetzt, wie Jochen sagt,

beliebig vielen

irgendwo was passiert.

Wenn irgendwo was passiert, dann gib mir Bescheid.

Dann kriegst du quasi einen Interrupt.

Ah.

Genau.

Das gab es doch früher immer. Das war noch relativ

nativ oder schneller ansprechbar.

Das musste man doch früher einmal selber konfigurieren.

Die Interrupt.

für die Soundfarbe gab es das, weil die müssen halt ihre Daten holen und die sagen so,

jetzt, ich brauche Daten und dann musst du dich drum kümmern. Da kannst du nicht sagen, ja, ich bin jetzt gerade beschäftigt

mit...

Genau, und

also der Syscall, den man unter den Jungs dafür jetzt verwendet, der nennt sich ePoll, der halt

irgendwie, ja, ist halt irgendwie Anfang der Nuller Jahre, ich weiß nicht, seit wann das

drin ist, ein Körner, müsste ja irgendwie schon sehr lang, und

das Ding macht das quasi für beliebig viele Falldiskretoren und halt schnell.

Also das Ding ist richtig,

macht Laune, funktioniert

dann alles super und

FreeBSD,

BSD-basierte Unix, die nehmen dann eher sowas wie

KQ, also FreeBSD,

macOS und so.

Macht praktisch

das Gleiche. Wie was? Entschuldigung, ich wollte das nicht nochmal

aufklären. Der Syscall heißt einfach anders und

der heißt KQ.

KQ heißt der, oder?

Oder KQ, ja, genau.

Ja, KQ.

Die Leute mitschreiben, kleiner, schmutziger

und genau, aber

es gibt ja subtile Unterschiede, bei Solaris hast du halt noch sowas wie DevPol und so

also unterschiedliche Unix-Geschmacksrichtungen machen das halt irgendwie so leicht anders

alles und das willst du ja jetzt nicht, wenn du ein Anwendungsprogramm schreibst, alles nochmal

machen müssen, damit du halt irgendwie alle Unix-Varianten unterstützen kannst

und dann brauchst du halt eine Abstraktionsschicht darüber, die halt dann unten drunter

mit den betriebssystemspezifischen

Syscalls oder Interfaces redet,

aber mit der du dann

reden kannst, ohne das alles wissen zu müssen.

Und genau, das ist halt LibEV.

Und

genau,

das

war LibUV,

also das, was dann,

das Ding ist, glaube ich, gestartet, irgendwann

2011 oder so, das Projekt, und hat

für Unix

hat es halt LibEV benutzt, einfach.

Das hat es einfach nur gerappt.

Hat aber auch noch eine Windows-Geschichte

mit dazu genommen, weil

Windows macht das alles irgendwie anders.

Das implementiert halt nicht

dieses Reaktor-Pattern,

wo du halt benachrichtigt wirst,

wenn halt irgendwas passiert, sondern

das ist ein Pro-Reactor.

Also der Select ist

ein Reaktor-Pattern?

Ja, genau. Das sind die alle.

Bei Unix ist das immer so.

Was ist nochmal ein Reaktor-Trimmer?

Du kriegst halt benachrichtigt, wenn irgendwas

passiert und dann kannst du irgendwas machen.

Warum heißt das Reaktor-Pattern?

weil du darauf reagierst, wenn irgendwas passiert

du bist in dem Moment nicht der

Aktor, der aktiv

wartet, sondern du bist der Reaktor, du sagst

weck mich auf, wenn irgendwas ist

ich hatte irgendwie gerade eine Negrile

entdeckt, der Reaktor, wir abgeben

und Windows macht es halt anders

da gibt es diese

Iocompletion Ports

da ist auch alles nicht eine Datei

sondern ein Handle

und da

ist es halt so, man

passiert dann Dinge und der Kernel

macht dann schon zum Beispiel, der lest dann schon, also

bei dem React-Python

ist es halt so, da musst du dann schon noch selber lesen, du kriegst

bloß benachrichtigt, also du könntest jetzt, wenn du

wolltest, dann könntest du erst was lesen und dann kannst du das halt

machen oder nicht.

Und

bei Windows ist es halt so, der Kernel macht das dann halt

und dann

sagt er dir halt, wenn irgendwas completed ist,

was damit passiert ist und wo es liegt

oder so. Ich weiß nicht so genau, keine Ahnung.

Wenn du das herrschst. Ja.

Aber es ist halt grundsätzlich

andere Art damit umzugehen.

Und da gab es glaube ich tatsächlich auch,

Microsoft selber hat da irgendwie

Code beigesteuert zu LibUV,

meine ich, und hat den Teil

halt geschrieben und dann haben sie das

halt unter einem Interface

sozusagen

verfügbar gemacht

und halt LibUV verwendet für

Unix und dann den Microsoft-Teil

für Windows.

Und sieht dann aber von der

Anwendung gleich aus.

und später haben sie dann aber

LibEV wieder rausgeschmissen, glaube ich, und das dann selber nochmal

alles geschrieben. Naja, also

wie auch immer, aber

es funktioniert. Inzwischen ist es gut getestet.

Es gibt ja genug Node.js da draußen

und so. Und

es funktioniert gut.

Und es ist halt auch richtig

schnell. Und

was diese Event-Club tatsächlich eigentlich

macht, ist

eben diese

ganzen

dieses I.O. Zeugs verwalten,

aber halt auch Callbacks aufrufen.

Also du kannst zum Beispiel bei deinem Event-Loop

jetzt Callbacks registrieren für halt...

Also ein Event-Loop ist ein eigener Prozess,

der läuft und der die ganze Zeit guckt, was für Events da

registriert sind und die dann aufrufen, wenn irgendwas passiert, oder?

Nee, das Ding

läuft immer...

Es kann nur eine Event-Loop

pro Thread geben.

Du kannst mehrere haben, aber nur in

unterschiedlichen Threads.

und

ja, das Ding läuft halt.

Das ist halt die innerste Loop in deinem

Programm, wenn du sowas benutzt.

Das ist das, was mit LibUV

hintergeht, oder? Das ist die Event-Loop.

Ja, also

LibUV ist eine Implementation, ja.

Also so eine Wild-True-Schleife oder sowas.

Ja, letztlich genau. Das Ding,

ja, wobei das nicht

busy-weighted, sondern das schläft dann halt

auch, wenn nichts zu tun ist, aber

sobald irgendwas zu tun ist, dann wird es

sehr wach und agil und macht irgendwie

Dinge.

In dieser

Einführung

in ASIC.io von Lukas Langer

zeigt er die Implementation

der Python-Event-Loop

glaube ich aus 3.4

oder 3.5, ich weiß es nicht genau.

Und das waren irgendwie so 20

Zeilen, 30 Zeilen Python.

Und es war tatsächlich eine while-true-Schleife.

Und die hat im Wesentlichen nur gemacht so, geguckt,

oh, welche Callbacks sollen jetzt gerade laufen?

Dann hat sie aufgerufen,

und dann noch irgendwie Signal-Handling gemacht und

irgendwie, das war es im Wesentlichen.

Und dann noch geguckt, welche sind jetzt beim

nächsten, bei der nächsten Iteration

dran und das war es eigentlich fast.

Und das war die ganze Event-Loop.

Also Event-Loop ist tatsächlich dieser Loop und da muss man Signale

registrieren oder was? Oder die da hinten?

Callbacks sind vor allen Dingen das, was

man da rein

tut, was dann da drin läuft.

Die stehen dann in irgendeiner Liste, die immer wieder

gemeinsam speichert quasi

der...

Wenn in Datei X irgendwas

passiert, dann ruft damit diese Funktion auf.

Ja, aber wie sag ich das?

Da gibt es halt ein Interface.

Du kannst Call soon zum Beispiel

für jetzt soll dem nix laufen

oder

zum bestimmten

Zeitpunkt. Also die Timer,

du kannst dann auch Timer setzen und die werden halt ausgeführt

und dann wird halt überprüft, ist das jetzt dran

mit dem Laufen oder noch nicht.

Also je nachdem, was halt so eine Eventloop anbietet.

Es gibt ja da viele verschiedene

Sorten Events. Und genau so ein

Timer, ja, im Wesentlichen sagt man halt,

wenn du auf so einen Timer wartest,

dein Python-Programm

sagt, ruft eine Funktion auf,

die sagt, ich möchte

um 0 Uhr möchte ich, dass diese Funktion

gestartet wird.

Und dann muss diese Event-Lob ja im Wesentlichen

nichts anderes machen, als zu sagen, ist es schon 0 Uhr?

Nein, ist es schon 0 Uhr? Und wenn es 0 Uhr

ist, dann sagt sie ja und startet eben

dieses registrierten Callback.

Diese Funktion und genau.

Also Callback ist einfach eine Funktion, ja.

und du sagst, ich möchte, dass eine Funktion

aufgerufen wird und die muss auch normalerweise

schon fertig parametrisiert sein,

also du kannst dann nicht sagen, mit

folgenden Parametern, sondern du musst dann halt die so

oder gibst halt irgendwie mit, aber im Wesentlichen

sagst du nur, da soll dann ein

Funktionsaufruf passieren. Also im Prinzip

iteriert quasi dieser ganze Loop immer

durch diese gleiche Liste und guckt, was da drin steht und versucht

das dann auszuführen. Ja, nur halt

schlau, er iteriert da nicht die ganze Zeit

durch, sondern er sagt zum Beispiel

wann ist denn der nächste Timer

fällig?

Das ist um 0 Uhr, das sind jetzt noch 1 Stunde 55, also kann ich 1 Stunde 55, ich schlafe mal 1 Stunde 54 und dann kannst du dich da so rantasten.

Aber für die 1 Stunde 54 muss der ja nicht immer gucken, ist schon soweit, ist schon soweit, sondern die machen das halt schlauer.

Und das ist eben genau der Trick daran, dass du dich nicht darum kümmern musst, wie der das macht, sondern dass diese Eventloop schlau genug ist, das für dich auf eine schlaue Art und Weise zu machen.

Ja, genau, richtig, da war noch ein Spezialdings dabei, LibUV hat auch noch ein Threadpool irgendwie für, glaube ich, Kommunikation mit Files und so, aber im Grunde abstrahiert alles weg, was Low-Level unten runter passieren muss, damit es halt funktioniert und man hat dann halt ein sehr schönes Interface nach außen.

und wenn man jetzt AsyncIO zum Beispiel verwendet,

dann kann man einfach das AsyncIO-Interface

verwenden und

AsyncIO sagen,

verwende doch LibUV als Event-Loop

und dann benutzt es das Ding unten

drunter.

Und ein weiterer Trick, den es

dann halt noch gibt, ist, das sind sogenannte

Trampoline,

also Callbacks.

Wie man es will, jetzt aber.

Ein Trampoline.

Genau, wenn man das genau wissen will,

wie das

Wie das alles funktioniert,

dieses Videoserie von Lukas Lange

angucken, der erklärt das alles sehr ausführlich.

Ich kann das jetzt nur so anreißen.

Aber im Grunde ist es so, Callbacks, die sich halt

selbst wieder registrieren, sozusagen, weil

man ja, ich meine, wenn jetzt eine

Funktion aufgerufen worden ist und gelaufen ist,

dann ist ja dann eigentlich ja Schluss.

Aber du hast ja oft so Tasks, die

irgendwie die ganze Zeit irgendetwas machen

und ab und zu mal und dann wieder schlafen.

Wie kann das zum Beispiel sein, dass die sich dann

schlafen legen und wieder aufwachen und dann nochmal was anderes machen?

Das ging ja eigentlich nicht.

oder auch die Reaktivität anpassen.

Wenn du gemerkt hast, da ist jetzt nichts zu tun,

dann schlafen die länger oder kürzer.

Ja, und der Mechanismus,

über den das geht, ist, die schedulen sich selbst

wieder auf die Event-Loop.

Hat jeder von uns schon mal gemacht.

Ohne das Wort Trampoline

zu kennen. Ja, wahrscheinlich.

Genau. Und

noch, wenn man jetzt

guckt, wie ist der Mechanismus

eigentlich dafür,

der das macht,

dann sind das halt tatsächlich einfach nur

Generatoren eigentlich.

unten drunter.

Das ist doch der generelle Trick

von Ace und Gaio, oder? Das sind alles einfach immer

Generatoren.

Ja, also

man nennt es halt anders und

es hat einen anderen Typ, aber es ist

tatsächlich fast

das Gleiche.

Also

die Step-Funktion in dem

Generator ist halt eigentlich das, was du dann halt

immer wieder in die Event-Loop rein tust.

Und Await ist halt

nur ein anderes Wort für Yield-From und

vielfreundes halt genau das

Ding, was halt die Generatorgeschichte

da macht da an der Stelle.

So hat doch Async.io auch

angefangen, oder? Dass man einfach gesagt hat,

wenn ich eine Menge von Generatoren habe, dann könnte ich die

alle nacheinander mal ausführen

lassen und die geben mir die Kontrolle zurück.

Die haben genau diese Eigenschaft schon. Generatoren haben

genau das, was man braucht, was man

sagen kann.

Sogenannte Co-Routinen.

In einem Generator kann man ja sagen, okay,

alles klar, jetzt gib mir doch mal das nächste,

und jetzt stopp mal,

bleibt mal kurz stehen,

du machst jetzt erstmal nichts mehr

und dann später kann man dem sagen, okay, und jetzt gibt es nochmal

wieder was, das heißt, es sind schon Funktionen, die man

irgendwie so anhalten und weiterlaufen lassen kann

und wenn man

das jetzt nicht nur aus der

ich kann ja jetzt Sachen rausnehmen Perspektive sieht,

sondern auch man kann da Sachen reintun,

dann hat man eigentlich schon alles

zusammen, was man braucht,

um das zu implementieren.

Und tatsächlich

die werden alle

fair gescheduled, das heißt

also wenn man sich jetzt

naja, da wäre

ein Schaubild ganz nett,

so als Klassen...

Ja, wenn man sich das als