Transkript: Python 3.8

Ja, hallo und herzlich willkommen zur 14.

Folge vom Python-Podcast heute.

Ja, wir haben euch länger nicht mehr blicken lassen.

Das tut uns natürlich sehr leid.

Wir waren ein bisschen hektisch, haben hintereinander beide Urlaub gemacht und dann ist natürlich vorher nachher immer sehr viel zu tun.

Und wir hatten ein paar Abschiebungsprobleme.

Wir wollten nämlich eigentlich eine Projektmanagement-Folge machen.

Das ist dann an schlechtem Projektmanagement wirklich gescheitert.

Sieben verschiedene Termine gehabt und dann immer wieder verschoben.

Aber heute machen wir deswegen eine Laberfolge, damit wir euch nicht ganz enttäuschen.

Aber wer ist wieder dabei, heute ist der Tony wieder bei der Christian?

Hallo.

Nächstmal vielleicht ohne Knacksen.

Mal gucken, wer es hier bekommen.

Das werden wir hinterher rausfinden.

Ja, ansonsten wieder hier aus dem Wintergarten, wird auch dabei.

Ja, das ist der Jochen, ich bin der Dominik.

Ja, genau.

Und ja, weiß nicht, womit fangen wir an?

Irgendwelche Neuigkeiten.

Ja, genau, wir wollten wieder ein bisschen News aus der Szene erzählen.

Und ihr beiden weit auf der Pikehone.

Das habe ich leider nicht geschafft wegen meinem Urlaub, aber ja, das ist bestimmt sehr spannend gewesen.

Erzählt doch mal, was war da alles los?

Ja.

Also ich habe dummerweise auch nebenher noch so ein bisschen arbeiten müssen, aber so ein bisschen, es war alles so, man muss halt so eigentlich so ein bisschen Zeit dafür nehmen.

Genau, es tut jetzt noch weh.

Ja, aber es war schon interessant.

Ich hab mir einige Dinge da angeguckt.

Super fand ich zum Beispiel den Vortrag, jetzt habe ich den Namen vergessen, Luciano Ramalio oder Ramallo, der das Buch Flu in Pyth geschrieben hat, ist auch, kann ich auch nur empfehlen, sehr, sehr gutes Buch.

Hat einen Vortrag darüber gehalten, dass vielleicht diese Unterteilung, die man klassischerweise jetzt aus der Informatik kennt, irgendwie in funktionale, objektorientierte, strukturierte Programmiersprachen nicht so komplett trifft auf das, was man heute so vorfindet.

Und man sich vielleicht auch eher an den Features der Sprachen orientieren sollte oder so.

Und das hat da schon einen relativ starken Punkt.

Also man sollte sich mehr daran orientieren, wie die Syntax, wie die Features, was die Sprache so kann.

Ja, was man mit der Sprache so machen kann, genau.

Und das jetzt nicht, weil zum Beispiel Python wird halt immer in diese Skriptsprachenecke gesteckt.

Und warum?

Ja, es gibt eigentlich keinen besonderen Grund dafür.

Man könnte es auch in die objektorientierte Programmiersprachen-Ecke stellen.

Also was, warum ist das jetzt keine, aber C-Sharp schon eine oder so?

Das ist halt nicht so richtig klar.

Und ja, so ein bisschen schwingt damit ja auch dann sozusagen immer das Vorurteil mit, dass das jetzt gar keine richtige Programmiersprache ist oder so.

Dann gibt es halt die Gruppe der richtigen Programmiersprachen, Java, C-Sharp und so.

Und Python ist halt irgendwie so eine komische Skriptsprache.

Von richtigen Programmierern wird man als Python-Programmier auch immer ein bisschen schreck angeguckt, ja.

Das Interessante ist, dass ja jetzt aber alle, die letzten Jahre war es schon so, dass wir uns auf den, wir, also die Python-Community und Python als Sprache sich ja über die ganzen Indizes und diese Bewertungen, von welche Sprachen beliebter sind, immer weiter nach vorne geschoben hat.

Und ich glaube, dieses Jahr.

Ich habe gut, dass wir dann zu Indien gelehrt.

Ja, also ich meine, ich habe es die letzten drei, vier Jahre beobachtet, dass Python immer bei allen Bewertungen im Prinzip unter den Top 5 ist.

Und jetzt dieses Jahr hat es ein paar Mal wirklich geknackt, dass wir, ich glaube, bei drei von vier, und ich weiß nicht mehr welche es waren, auf Platz 1 sind.

Das sorgte auch dafür, dass unser Branchendienst heise nach der PyCon und nachdem sie irgendwie ihre eigene Machine Learning-Konferenz hatten, sich beim Verband bei uns gemeldet hatten und meinten, sie hätten das gar nicht so richtig gemerkt, aber Python scheint ja irgendwie benutzt zu werden.

Ja, lassen das.

Wo das ja jetzt

plötzlich herkäme,

wie kommt denn das?

Ja, genau.

Und aber ich glaube tatsächlich, also inzwischen, ich höre das auch manchmal nochmal, auch wenn man jetzt, ich hatte, Heißek hat er heute auch ein Thema, was wir später noch aufgreifen werden, auf dem Ticker.

Und wenn man dann wieder die Kommentare dazu durchliest, dann ist es ganz spannend, weil halt so breit gestreute Vorurteile gegenüber Python, die letzten, die das immer noch rausholen von wegen, ja, Indentation ist ja eklig, ja, ich glaube, das wird nie weggehen, dass da irgendwer nochmal mit den Augen rollt, aber ich finde es eigentlich ganz angenehm, heutzutage nicht mehr irgendwie argumentieren zu müssen einem Kunden gegenüber oder einem Projekt, ob ich jetzt Python einsetze oder nicht, ist letztendlich gegessen, nach 20 Jahren

auch mal Zeit.

Ja, die ersten gehen schon in Rente, haben wir gehört, letzte Woche Halloween, als mich der Guido hat getwittert, dass er Dropbox verlassen wird und in Rente geht.

Also endgültig, nachdem er ja letztes Jahr schon seinen teilweisen Rückzug als Benevolent Dictator for Life angegeben hat.

Ja, wobei das sind ja zwei verschiedene Dinge.

Also sozusagen das Thema Erwerbstätigkeit zum Lebensunterhalt, das hängt da an den Nagel.

Aber den Benevalent Dictator

weiß, ob das nicht insgesamt so ein bisschen mit der Karriere zu tun hat, dass man sich dann so insgesamt zurückzieht und dann auch im Berufsleben ausgeht.

Also wohl.

Als letzte alte Macht hat er, glaube ich, Typisierung gemacht in Python, oder?

Irgendwie mit MyPai viel.

MyPai, genau, das war sein großes Thema bei Dropbox gewesen.

Da ist der, da kommt die MyPai-Idee her.

Den Namen habe ich von dem Verursacher gerade nicht im Kopf.

Aber ja, persönlich, Guido hat letztes Jahr beim BDFL, es war ja kein BDFL an den Nagel hängen, sondern nur einen nicht definierten langen Urlaub nehmen.

Und der Prozess, der angetreten wurde zum Thema Core-Team und wie werden Entscheidungen ohne ihn getroffen, welches Gremium kommt er zustande.

Auch da ist er in dem Gremium ja wieder drin und er ist aktiv dabei.

Ich glaube, natürlich, er hat er signalisiert, dass er jetzt dann langsam auch irgendwann mal auf seine Gesundheit auffassen muss und mit seiner Energie haushalten.

Aber ich habe den Eindruck nicht gewonnen, dass er jetzt schon jetzt einen Plan hat zu sagen, bis dann und dann will er irgendwie komplett sich raus zurückgezogen haben.

Ich habe eher das Gefühl, er will es halt mit seiner Energie eben haushalten, um das noch eine Weile durchzuhalten.

Ja, durchaus vernünftig, ja.

Das ist ja aber dann der richtige Schritt, wenn dann bei Dropbox jetzt nicht mehr gebraucht wird, aber vielleicht gebraucht wird er schon, aber irgendwie

das jetzt nicht mehr so nicht mehr unbedingt machen muss.

Ich habe auch genug.

Ich meine, Falten gibt es ja schon lange als Schwert.

Das müssen wir herausfinden, wann 30-Jährige ist.

Ja, stimmt, das sollten wir nicht verwenden.

Zünden wir eine Kerze, ne?

Und ja, ich habe dann nochmal auf, als ich das gelesen habe, auch auf Wikipedia geguckt, dachte mir so, so früh in Rente, das ist ja aber, das stimmt gar nicht, das ist ja auch schon tatsächlich irgendwie echt, echt lange dabei.

Ja, Guido macht das schon eine Weile und ich habe ihn aber tatsächlich, mein Eindruck, wie ich ihn so die letzten Jahre wahrgenommen habe, ich habe ihn, glaube ich, ich weiß nicht, wann ich es das letzte Mal gesehen habe, aber der hat Spaß an Python.

Der hat halt den BDF-L unter anderem deswegen weggelegt, weil natürlich diese Verantwortung für diese Größe der Community und mit allem, was halt dann immer mal in so dynamischen Community-Prozessen passiert, was halt auch unschön ist, war für ihn, das ist ja im Prinzip der Move zu sagen, ich will nicht, dass das dann alles, weil ich derjenige bin, der die letzte Entscheidung trifft, dann zum Schluss bei mir landet und ich den ganzen Mist an der Backe habe.

Sondern dass wir das halt dann auf mehr Schultern verteilen, was natürlich dann auch schön ist, vorausdenken von natürlich Busfaktor, da ist es gut, wenn die Community sich sortiert hat.

Oh, da kommt halt, dass es irgendwann Magie mal nicht mehr geben sollte.

Ja, ja, das fand ich auch schön.

Also das den Busfaktor, das ist ja auch mal so ein, vielleicht, ich weiß nicht, ob das jeder versteht, aber das.

Was ist ein Busfaktor?

Ich habe gerade nur gemacht, BDFL, BMF.

Das ist halt sozusagen die Frage, wie viele Busse unterwegs sein müssen, um eventuell ein Projekt irgendwie kritisch zu beeinflussen im Fortgang.

Wie viele Leute dürfen vom Bus überfahren werden, bevor das Projekt dann vorbei ist.

Ja, und das ist meistens eins irgendwie so für die allermeisten Projekte.

Und manchmal will man vielleicht mehr haben als eins, weil es nicht gut wäre, wenn das so einfach zu beenden wäre.

Und ich habe aber jetzt letztens, deswegen habe ich da kurz noch eingepackt, gehört, dass jemand das anders genannt hat, weil er meinte, das klingt immer irgendwie so negativ, wenn Leute vom Bus überfahren werden.

Und er nannte das, er spricht jetzt immer vom Lotto-Faktor.

Leute im Lotto gewonnen, gewinnen und dann halt irgendwie was anderes machen vielleicht.

Ich meine, der Faktor war bei Python zu dem Zeitpunkt eh schon nicht mehr so stark ausgeprägt, weil ich meine, die PSF ist breit aufgestellt, das Code-Team ist breit aufgestellt.

Und es ist natürlich schöner, wenn man das halt dann nicht in einer Notsituation machen muss, sondern wenn es halt vorab geklärt ist.

Ist halt so ein bisschen wie mit seinem Partner dann schon vorher zu klären, wer Patientenverfügung hat und so.

Ja, klar, so ein Notfallkoffer, ne?

Wenn du wirklich so eine Firma hast und dann darauf angewiesen bist, dann brauchst du Notfallkoffer, weil drinsteht, was du machen musst, wenn der Chef tatsächlich irgendwo es rendert.

Ja, wobei, jetzt haben wir natürlich den schönen Fall, dass wir halt keinen Notfallkoffer brauchen, sondern dass wir jetzt einen neuen Standard etabliert haben, wie das Tagesgeschäft jetzt in der Kernentwicklung funktioniert und dass Guido halt trotzdem dabei ist, ist halt schön.

Und also mir ist es lieber, wenn Guido sich das jetzt so zurechtgelegt hat, dass er wirklich Spaß dran hat, als wenn er irgendwie nach hinten raus dann irgendwann entnervt drauf kippt.

Ja, sehr schön.

Also ja, für alle, die es noch nicht wussten, also Python kann tatsächlich auch feste Typisierung.

Also, ne?

Wenn ihr MyPy benutzt, dann könnt ihr auch die Typen festnageln, wenn ihr möchtet.

Also mehr oder weniger könnt ihr immer noch, müsst ihr nicht, aber es wird euch wenigstens gesagt.

Es gibt eine statische Analyse dazu.

Genau.

Ja, aber ihr wollt noch bei der PyCon.

Also, Pykon.de

dachten wir auch gerade, ja, da waren wir gerade.

Genau, ja, ansonsten, ich muss jetzt nochmal so gerade überlegen, was hatte ich denn noch angeguckt, was mir gut gefallen hat.

Oh, das muss ich jetzt, das habe ich mir dann vorgenommen, mir nochmal näher anzuschauen.

Nicht nur Alpython-Notebooks, da war nicht schon ganz lange, oder Jupyter-Notebooks.

Der gibt es einen bösen Buck in Python 3.8 übrigens.

Oh, okay.

Und da gibt es jetzt so eine komplette Entwicklungsumgebung eigentlich, JupyterLab, die hat auch da irgendwie diverse Fortschritte.

Ich habe sie mir schon mal vor irgendwie einiger Zeit angeguckt.

Bin dann aber bei den Notebooks geblieben, aber da hat jemand einen Vortrag darüber gehalten, dass man damit alles so machen kann und das sah schon sehr, sehr gut aus.

Also so ein Problem, zum Beispiel, was man, vor allen Dingen gibt es ja jede Menge Plugins, die man für tolle Sachen benutzen kann.

Also etwas, was ich, was ich irgendwie immer nervig finde, ist, wenn man zum Beispiel nicht so richtig Diffs sehen kann, wenn man irgendwie Sachen eincheckt oder Sachen verändert.

Du kannst ja Jupiter auch einen VS-Code öffnen, übrigens live in Sitze ID.

Oh, okay, das muss ich mir auch mal angucken.

Ja, das funktioniert ja noch nicht richtig gut mit der Dangeschale.

Tumis habe ich das nicht von übt hinbekommen, aber ja, doch, sonst.

Ja, und aber da waren echt tolle Sachen dabei.

Da waren auch so viele interaktive Geschichten, man kann ja komplette UI-Geschichten irgendwie mitbauen und Sachen drin, also ein Plugin ist, man kann da irgendwie Diagramme drin malen.

So, weil normalerweise man sich immer fragt, so, okay, wenn ich jetzt nochmal so ein Architekturdiagramm aufmalen möchte oder so, was nehme ich denn jetzt dafür?

Inzwischen oft nehme ich dann irgendwie ein Online-Tool dafür oder so, aber das geht auch alles in JupyterLab.

Und ja, also das war beeindruckend, was da für Fortschritte inzwischen erzielt worden sind.

Und ich muss mir das unbedingt wieder angucken, hab's aber noch nicht gemacht, weil Urlaub, aber also das fand ich fand ich noch ziemlich gut.

Und was habe ich noch?

Oh, ich habe mir noch einen Vortrag angeguckt über ein System, das ich mal irgendwann gebaut habe, wo jemand, da stand schon im Abstrakt drin, irgendwie so, ja, wir treiben hier so ein Machine Learning-System seit zehn Jahren produktiv und hier mal so, was wir alles gelernt haben und was alles irgendwie schiefgelaufen ist und was wir dann ändern mussten und so.

Und ja, das war tatsächlich etwas, was ich mal irgendwann mitgebaut hatte.

Damals dachte ich so, oh je, ein Vortrag darüber, was ich alles falsch gemacht habe vor zehn Jahren.

Aber war, nee, war sehr gut.

Und was hast du alles falsch gemacht?

E Kurzversion von?

Also alles gemacht?

Ja, also was sich die Leute dann nicht mehr erklären konnten.

Also das war, das war auch interessant.

Also viele Dinge haben dann so hinterher eine andere Erklärung bekommen, weshalb das denn passiert sei.

Aber es gab da oft irgendwie, die tatsächliche Erklärung war oft eine andere.

Sowas wie zum Beispiel, warum wurde eigentlich Disco genommen als Map Reduce Implementation?

Ja.

Was auch immer Disco ist.

Das war auch damals schon nicht so super populär.

Das ist irgendwie so ein Projekt gewesen von Nokia Research, wo die halt, ja, also dieses Map Reduce-Paradigma implementiert haben.

Und ich meine, wir haben, wir haben damals eine Menge Sachen ausprobiert, haben wir Hadoop ausprobiert.

Und der Grund, warum wir dann Disco genommen haben, war, weil es das einzige Python-Map-Reduce-Framework war und Hadoop war wirklich, also hätte man nehmen können, aber das war so, das hat keinen Spaß gemacht.

Und eigentlich, was wir vorher verhalten hatten, waren selbst entwickelte Geschichte, aber es hieß halt, nee, das bitte nicht, sondern irgendwas Externes nehmen an der Stelle, weil wir nicht da nochmal Infrastruktur selber bauen wollen.

Das war der eigentliche Grund.

Oder dann auch solche Sachen wie, warum wurde das eigentlich so aufgeteilt?

Oder diese Probleme kennt man heute gar nicht mehr so.

Das lag, also warum macht man das überhaupt so parallel, warum macht man das nicht auf einer großen Maschine?

Und der Grund damals war, dass wir da noch ganz viele 32-Bit-Rechner hatten.

Und da gibt es halt dann bloß so 3 Gigabit-Hauptspeicher und dann ist halt irgendwie Schluss.

Und dann muss man das Problem halt in kleinere Dinge aufteilen, wenn man zum Beispiel Sachen tokenisieren will und die Liste der Tokens einfach nicht mehr in den Hauptspeicher fasst oder so.

Erstmal so als Beispiel.

Und dann muss man das halt plötzlich dann auf mehrere Rechner verteilen und dann halt sowas Map-Reduce-Artiges verwenden.

Ja, also, ja, es ist alles.

Und heute würde man das alles gar nicht mehr so machen.

Noch ein paar RAM-Riegel reinschieben.

Ja.

Vor allem mehr RAM.

Ja, aber es war auf jeden Fall eine tolle Geschichte, war so ein bisschen Nostalgie.

Hat Spaß gemacht, ja.

Das ist cool.

So weit möchte ich auch mal kommen, dass ich auf eine Veranstaltung gehe und irgendjemand einen Vortrag darüber hält, was ich vor 10 Jahren falsch gemacht habe.

Ja, es ist also sie bauen das System.

Es ist jetzt auch weg und es gibt jetzt ein neues.

Also es ist halt jetzt dann wohl ausgenieend.

Ja, was war noch so?

Genau.

Dann war noch so ein Freelancer-Panel, das war irgendwie ganz interessant mal da.

Also da habe ich mich auch irgendwie viel zu selten mit beschäftigt, mit dem

Jahr das Freelancer-Panel, wolltest du kurz erzählen?

Ja, was eigentlich so die Rahmenbedingungen von dem, von dem, was ich so normalerweise halt beruflich mache, angeht.

Und da waren einige sehr interessante Informationen dabei.

Ich weiß aber nicht, ob das so weiter.

Wir haben alle gesagt, lachen Leute sein.

Wir haben da gesagt, mach das alle.

Ja, nö, ist schon nett und so.

Ja, ich habe auch nie so, ich hab dann auch mal einen Begriff dafür gelernt, wie das heißt, was ich mache.

Das heißt irgendwie Team Augmentation.

Team Augmentation.

Man ist das Augment für ein Team.

Genau, man arbeitet eigentlich ganz normal in so einem Team mit und ja, das war mir alles gar nicht so richtig klar.

Und dann zahlt andere Dinge, die man auch machen kann und das hat andere Probleme.

Es war nicht, war nicht, und es gibt auch tatsächlich inzwischen so, das habe ich dann aber woanders gehört, ich glaube in einem Podcast, es gibt Leute, die dann komplette Teams auch ausleihen und nicht nur, weil das ist ja auch so ein Problem, nicht wenn du so einen Entwicklungsprozess.

Du wirst aber auch mal skalieren, hast auf einmal ein neues Projekt, so ein Side-Projekt, hast aber gar keine Abteilung, die das irgendwie machen kann und merkst, hey, du hättest irgendwie noch ein neues Projekt dabei.

Genau, wie macht man das eigentlich?

Dann kann man schon wieder richtig ein Projektmanagement hinterher.

Ja, ja, ja.

Und dann gibt es halt eventuell die Möglichkeit, oder das machen halt momentan manche Leute wohl, dass sie dann komplette Sprints irgendwie verkaufen und dann Teams, die schon gut zusammenarbeiten, irgendwie dann vermieten.

Ja, das ist ja gar nicht so blöd.

Und das ist auch eigentlich nicht so blöd, das soll man richtig sagen.

Wenn die so guten Code schreiben, dass sie niemand anderes danach auch noch lesen kann und benutzen können, dann kann man das nicht.

Ja, das sollte schon dann alles praktismäßig.

Hey cool, damit machen wir jetzt weiter.

Du brauchst halt, wenn du das ganz teamweise machst und sprintweise brauchst du eine gewisse Mindestgröße, weil du bei dir ja dann trotzdem wieder das Zweck zusammenführen musst, ja.

Ja, ja.

Also es gibt diesen alten Spruch, einen Freund von mir, der ist nach dem Abi irgendwann zur IBM, dass die IBMer, als sie dann in den 90ern die Informatiker nach Indien ausgelagert haben, festgestellt haben, dass sie für zwei Preiswerte inner einen teuren Deutschen brauchen, der das alles wieder zusammenzieht.

Ja.

Da war sie Einsparung nicht so riesengroß.

Da muss man sich wirklich Gedanken drum machen, wie das funktioniert, ja.

Ja, aber was, welche, welche, hast du dir eigentlich irgendwelche Vorträge angeguckt oder?

Nee, ich stand, nee, ich stand auf dem Stand.

Ich hab, was hatte der Tweet hergegeben, Andre hat gesagt, wir haben.

Vielleicht hatte ja einer unserer Hörer verpasst, was du überhaupt machst, deswegen musst du mal erzählen, was für ein Stand das denn überhaupt war.

Ja, genau, also vom Flying Circus und auch sagst du, was hier mit DevOps, DevOps as a Service sozusagen.

Im Prinzip so wie so wie Team Augmentation, was der spät, meine Kinder haben mich tot gemacht.

Jochen, was der Jochen, was der Jochen gerade gemeint hat, so ein bisschen Team Augmentation, sowas in der Art machen wir für DevOps-Szenarien, dass du also als Team sagst, der ganze Ops-Kram, ich will das von der Kontrolle haben und wissen.

Aber im Prinzip kannst du das komplette Management, den ganzen Betrieb der Anwendung zu uns rüberkippen.

Und dann hast du bei uns ja so ein DevOps-Team, was man nicht sagen sollte, aber am Ende sagt.

Ah, ja,

wieder doch nur ein Silo.

Ja, ein neues Silo.

Das ist ein schöneres Silo als vorher.

Also tatsächlich, wir sagen jetzt auch manchmal, dass man uns die Software wieder über den Zaun werfen kann, aber wir klettern dann wieder über den Zaun zurück.

Ja, da haben wir einen Stand gehabt, um uns ein bisschen zu zeigen.

Und ich stand im Prinzip die ganze Zeit nur auf dem Stand rum.

Du warst nicht in der Nähe von irgendeinem Hörsaal oder sowas, wenn wir uns um die Ecke hören oder so.

Naja, man könnte, nee, die waren halt immer schön zu, damit man da auch die Ruhe hat.

Ich habe aber dafür irgendwie, glaube ich, zwölf Kilo Schokolade verteilt oder so.

Ich muss halt gegessen.

Das war seine Zeit ganz dauert.

Ja.

Nee, also ich war dann halt in Summe auch mehr beschäftigt mit so ein paar von den Metathemen, weil ich dann ja doch eher auch von der organisatorischen Seite eingebunden bin.

Jetzt nicht so direkt bei der PyCon.de, da werde ich dann nur manchmal gefragt, aber gerade über den Python Softwareverband, da hatten wir Jahresversammlungen, die war ganz gut besucht eigentlich und konnten auch neue Mitglieder gewinnen.

Das war eigentlich ganz spannend, weil die Pycon.de ist ja sozusagen unter der Flagge des Python Softwareverbands veranstaltet.

Und zum einen haben wir jetzt mal nach relativ vielen Jahren sehr kontinuierlicherliche Arbeit.

Im Vorstand nochmal ein bisschen neue Gesichter gesehen.

Zum einen das erste Mal eine Frau im Vorstand.

Wir haben immer noch keine Folge mit einem weiblichen Hörer oder einer weiblichen Hörerin.

Also falls ihr Lust habt, kommt vorbei und sagt Bescheid.

Genau, also die Theresa, äh, Yuf Chiu.

Ich weiß immer nicht ganz genau, ob ich ihren Namen richtig ausspreche.

Sie ist selber sehr schnell dabei, ihn auszusprechen.

Das ist ganz schwierig.

Also die Theresa ist jetzt mit dabei, die ist, glaube ich, in Hamburg und die hat auch im Rahmen von dem Förderprogramm von PISV schon mehrfach mit Schülern und mit anderen Gruppen, ich glaube, Raspberries oder MicroPythons verbaut.

Genau.

Und der Alex Hendorf, der Hauptorga von der Pycon.de, der hat sich jetzt auch noch bereit erklärt, mitzuhelfen.

Wir mussten nämlich tatsächlich feststellen, dass der Python-Verband in Summe mit der Pycon.de, das ist einfach inzwischen ein Riesenschlachtschiff.

Wir haben die letzten Jahre so ein bisschen gedacht, mit, ah, das kochen wir alles mal wieder ein bisschen klein, dann läuft das alles von alleine und in Wirklichkeit, da gibt es nichts klein zu kochen.

Wir haben irgendwann mal vor drei, vier Jahren dargestanden und gemeint, die Verwaltungskosten sind sehr hoch.

Und tatsächlich hatten wir gedacht, der PISV ist so ein Verband, Verein mit 10.000, 20.000 Euro Umsatz pro Jahr.

Das machst du irgendwie nebenbei.

Und wenn man aber die PyCon.de und noch zwei, drei andere Veranstaltungen, die wir drin haben, reinziehst, dann siehst du, dass der Python-Verband jetzt in Deutschland kontinuierlich über eine halbe Million mehr Umsatz macht pro Jahr.

Ja, genau, und dann standen wir da und dachten so, oh, okay, da ist normalerweise eine Vollzeitstelle für die Verwaltung fällig.

Und deswegen der Alex Hendorf, der hat, der das sehr viel Zeit in die PyCon.de steckt, der hat auch bei sich aus dem Team jetzt jemanden, den wir vom Python-Verband bezahlen, der das dann fast in Vollzeit tatsächlich machen wird, die Verwaltung vom Verband aufzuziehen.

Das wird, glaube ich, ganz gut, weil da haben wir jetzt auch gemerkt, das ist ein Thema aus der Open Source Community an sich ja, dass Volunteer-Burnout irgendwann mal kommt, wenn du die Leute vor allem mit irgendwelchen Kram überlastest.

Wir haben so ein paar Sachen mit Sponsoren.

Wenn du mit den ganz Großen jetzt halt immer im Bett bist, da hast du wirklich von Microsoft und Google und Ebay und sind halt irgendwie alle dabei, weil alle mit Python arbeiten und alle wollen es sponsoren und wollen Mitarbeiter werben.

Und dann hast du aber plötzlich so ein Glück, dass es heißt, ja, bei uns im Beschaffungsprozess, füllen Sie bitte folgende 20R4 Seiten aus, gehen Sie damit zu Ihrer Bank, lassen Sie von der bitte einen englischen Brief ausfüllen, schicken Sie es darüber und dann müssen Sie innerhalb von sieben Tagen auf den Button drücken und sonst geht das Spiel wieder von

vornhere los.

Das machst du abends, wenn die Kinder im Bett sind und bevor die manchmal.

Ja, genau, genau, ja, ja.

Mit sowas unterhalten die einen, das ist halt was, das willst du eigentlich nicht auf Freiwillige abgießen.

Es willst auf niemanden abgießen, aber es reicht nicht auf Freiwillige.

Genau.

Nee, insofern der Verband, der steht gerade echt gut da.

Wir sind es auch nochmal dabei, dann zu gucken, die Aufgaben zu verteilen, was die Öffentlichkeitsarbeit angeht und diese Bewerbung von dem Förderprogramm, das da nochmal ein bisschen vorangeht.

Genau.

Und insofern da war die Pacon.de für mich alles mehr so aus dieser eher so Verwaltungs-Vereinsmeiererei-Perspektive.

Aber immerhin, ich meine, es waren 1200 Besucher.

Genau, genau, das hatte ich auch, ich habe die genaue Zahl nicht gehört, aber das waren auf jeden Fall mehr als tausend Leute und ich, wenn ich mich so an vergangene Veranstaltungen erinnere, das ist diesmal deutlich, also es war halt die mit den meisten meisten Publikum da und das ist kontinuierlich mal mehr geworden.

Und jetzt ist es halt eine richtig, richtig große Veranstaltung.

Früher war das alles irgendwie überschaubar und jetzt ist das echt Wahnsinn.

Also ich erinnere mich die erste Runde, die wir hatten, die erste in Anführungszeichen Konferenz, die in Python-Umfeld, die war halt damals von den Soap-Leuten.

Die war 2001 in Bielefeld, da waren wir 24 Leute.

Da haben uns an der Uni mit dem Grill getroffen und mal irgendwie zwei Tage lang uns Dinge gezeigt.

Das war eigentlich sehr cool.

Und damals gab es dann auch schon dieses Thema von, das zog dann auch an und dann waren statt 25 irgendwie 50, dann hast du irgendwie 100, dann hast du irgendwie 150 und dann war es eine Zeit lang so immer so in der Größenordnung.

Und ich erinnere mich, dass ich auf der ersten Python-Konferenz in USA, so 2004 glaube ich, war, das waren dann damals 400 Leute oder so in der Größenordnung.

Und die wuchsen auch immer weiter und dann waren es, glaube ich, in Texas und in Dallas waren es plötzlich 2000.

Und wir haben uns immer angeguckt, weil du hast halt auch alles, was die Konferenzen an Räumlichkeiten konnten, gerade was das Internet anging, du hast immer alles gesprengt.

Weil die dann immer dachten, naja, von 2000 Leuten sind mal irgendwie 10% irgendwie mit ihrem Notebook unterwegs oder brauchen WLAN und du musstest denen damals mal schon klar machen mit, nee, hier kommen jetzt 2000 Leute, die haben jeder zwei Geräte.

Ja.

Genau, und da sind wir jetzt im Prinzip halt auch angekommen.

Ich meine, mit 1200 Leuten sind wir so groß wie die EuroPython.

Die hatten, glaube ich, auch 1200, wobei da gibt es ein paar Unstimmigkeiten wohl angeblich, was die Rechnung von Köpfen und Tickets angeht.

Und wir hatten vor allem 800 Leute auf der Warteliste.

Ja, Wahnsinn.

Also wir werden nächstes Jahr nochmal die Location wechseln.

Ich meine, die neuen Termine sind schon draußen.

Also für alle, die nochmal hinkommen wollen, es wird nächstes Jahr wieder in Berlin sein.

Und tatsächlich die, die habe ich noch, die habe ich jetzt nicht griffbereit, aber es wird wieder im Oktober sein.

Und es gibt schon offizielle Daten im Oktober.

Die Webseite gibt es gerade nicht her, aber leider nicht mehr im Kosmos.

Das Kosmos fand ich eigentlich sehr schön.

Das Personal da war auch echt angenehm.

Ich fand es einen guten Move, dass nur vegetarisches Essen angeboten wurde.

Ich finde, das braucht es auf der Konferenz nicht, dass man sich da mit irgendwie billigem Fleisch irgendwie versorgt.

Und das hat mich überrascht, weil ich zwei Wochen vorher hatte ich selber darüber nachgedacht, es wäre eigentlich mal cool, wenn das jemand mal machen würde und war dann ganz positiv angetan.

Kam nicht bei jedem gut an.

Ich muss auch sagen, die haben auch handwerklich leider ein paar Stellen dann daneben gegriffen, weil es einfach nicht gut gemacht gewesen war.

Aber die Idee fand ich auf jeden Fall gut.

Ja, und nächstes Jahr wird es dann wohl noch eine etwas größere Location werden.

Ich glaube, da werden wir anderthalb oder 1600 Leute reinlassen.

Aber das ist im Prinzip schon mit Ansage, dass es wieder eine Warteliste geben wird.

Nur wir kommen halt nicht, es gibt irgendwann keine größeren Locations mehr.

Ja, irgendwann ist halt Schluss.

Es gibt noch irgendwie am Alexanderplatz irgendwie da, wo auch der CCC-Kongress häufiger war.

Ja, warm, warm, warm.

Wir waren noch bei der Pack.de, wir hatten ein bisschen geguckt, wie groß es wird, wo es nächstes Jahr hingeht.

Also es wird auf jeden Fall wieder Berlin sein.

Wir werden zusehen, dass wir irgendwie mehr Leute reinlassen, weil es natürlich blöd ist, wenn wir zu viele Leute auf die Warteliste setzen müssen.

Und du hattest gerade erzählt, dass das Essen trotzdem sehr leckeres Vegetarisch geben sein soll, irgendwie ab und zu mal komisch geschmeckt haben soll.

Ja, gut, ich meine.

Ja, es gab halt vom, der Anbieter hat es halt an ein paar Stellen nicht gut umgesetzt.

Ich glaube, am ersten Tag war das Kartoffelgarton halt nicht durch.

Aber das wäre bei einem Stück Fleisch genauso blöd.

Ja, und das ist natürlich auch schwierig, was so solche Mengen irgendwie alle gleichzeitig schicken.

Ja, Catering ist ein Challenge, ja.

Ja, aber sie versauen es auch immer wieder auf die gleiche Art und Weise.

Tja.

Nee, genau.

Also ansonsten, ich fand es in Berlin eigentlich sehr angenehm.

War vom Umfang her, fand ich gut.

Ich habe halt auch bei mir so viele interessante Gespräche gehabt.

Es war jetzt ja diesmal überlagert mit der Pi Data.

Wird es wahrscheinlich nächstes Jahr auch wieder sein.

Man merkt so ein bisschen, das ist halt, Python hat je nach Generation schon fast so ein bisschen unterschiedliche Schwerpunktthemen.

Vor zehn Jahren war Web halt immer so das treibende Thema im Programm.

Jetzt ist es alles, was rund um Machine Learning, Data Science und so geht.

Und das sind eigentlich zwei Konferenzen, die laufen jetzt aber zusammengefaltet in einer im Prinzip.

Aber in Summe ist es einfach so ein extrem diverses Portfolio.

Es ist halt nicht so, dass alle jetzt irgendwie erst A und jetzt B gemacht haben, sondern es wird halt immer mehr.

Es wird halt, man hat halt irgendwie das eine Hauptthema, was vielleicht so 60% der Themen bestimmt.

Und aber die anderen 40% sind immer noch doppelt so groß wie das, was wir vor fünf Jahren hatten.

Also da ist einfach die Diversität und worüber man mit Leuten reden kann, schon, das ist fantastisch.

Ja, fand ich auch sehr schöne Veranstaltung.

Ja, sehr spannend.

Also dieses Jahr versuche ich mir auch tatsächlich wieder tiefer in die Kalender reinzustreichen.

Aber dieses Jahr, da kam leider nichts mehr da rein.

Ich meine, spannend ist ja, dass es eine rein englischsprachige Konferenz ist im deutschen Raum.

Und wir so ein bisschen der EuroPython den Rang ablaufen an ein paar Stellen.

Deutschland liegt einfach, das haben wir in Karlsruhe gemerkt und jetzt in Berlin auch wieder, Deutschland liegt halt schön zentral.

Und da ist für viele der Anfahrtsweg gut kalkulierbar, als wenn es dann irgendwie mal in Spanien zu Schweden zu Edinburgh war es, glaube ich, auch mal.

Schweiz war jetzt dieses, glaube ich.

Nein, Stockholm war und das ist Dublin angeneigt, oder?

Nichts Jahr, ja, kann sein, weiß ich nicht.

Aber diesmal war es, glaube ich, Basel, ja.

Und diesmal war es Basel.

Ich meine, Schweiz ist halt auch ein teures Pflaster.

Das schreckt auch mal so den einen oder anderen ab.

Was war denn in Stockholm?

Wann war das denn?

Es gab ein Django-Con mal irgendwo da in der, aber ich weiß nicht genau, wann das war.

Naja.

Wie auch immer.

Ja, ähm.

Tja, was haben wir denn sonst noch an Neuigkeiten?

Ja, ist draußen.

Es gibt ein paar ganz interessante Geschichten, die dabei sind.

Ja, es ist jetzt auch nicht so wahnsinnig umwerfende neue Geschichten.

Es gibt ein bisschen neue Syntax, ich weiß nicht, vielleicht fangen wir damit am besten mal an.

Es gibt den Warrus Operator.

Eine Assignment Expression.

Was ist das?

Es ist eine Expression, die vorher nur ein Statement war.

Hätte sein durch die TSI kein Anfänger.

Ja, also on the fly würde ich zugewiesen.

Ja, man kann damit Zeilen sparen.

Voll gut.

Man muss nicht erst was definieren, sondern man kann quasi in der Frage was definieren.

Ja, also ein Fall, den man ganz oft hat, vielleicht ist es am einfachsten, das an dem Beispiel zu erklären, ist, dass man irgendwie sich zum Beispiel irgendeinen Wert aus einem Dikt oder so holt und dann damit irgendwas macht.

Aber das eigentlich auch nur dann machen möchte, wenn das tatsächlich da drin ist.

Also was man dann üblicherweise macht, ist, man macht Sache Dikt.get und dann überprüft man halt, ob das, was zurückgekommen ist, ein Nann war oder nicht.

Und das kann man sich jetzt quasi sparen und das halt in einer Zeile hinschreiben.

Und da das relativ oft auftritt, das spart es halt schon ganz ordentlich Zeilen.

Man kann halt ja eben sozusagen if und dann halt die Variable, die man zuweisen möchte, Doppelpunkt gleich und dann könnte man sowas machen.

Also if, keine Ahnung, Key, Doppelpunkt gleich, Dick Get, bla.

Nee, Value eher nicht Key, aber genau, dann macht man irgendwas und in dem Fall, wenn es halt nicht drin ist, dann würde man da gar nicht reinspringen in den Block.

Ein anderer Fall, wo man es gut anwenden kann, sind halt Wildschleifen, wo du irgendeine Arbeitsvariable belegst und du das einmal am Anfang halt gleich zusammenfassen kannst.

Dann kannst du sagen, hier geht hier geht die nächste Runde von der Wildschleife los.

Weil X Doppelpunkt gleich deine Expression und das

ist ja fast wie ein Repeat an Till.

Ja, nein.

Warum nicht?

Weil es ja immer noch im Kopf ausgeführt wird, es wird ja immer am Anfang gemacht.

Ja, okay,

also das ist tatsächlich, okay.

Das heißt, du hast halt für den Einstieg in die Schleife hast du es dann immer noch trotzdem muss es homogen sein.

Ja.

Und ansonsten, was wir auch mal bei regulären Ausdrücken, ist auch oft so, dass man dann halt ein Match-Objekt zurückbekommt, wenn es halt irgendwie gematcht hat oder ansonsten halt einen Nann und das geht halt dann auch, so dass man das halt deutlich so ein bisschen einfach hinschreiben kann.

Wow.

Also für manche Fälle ganz praktisch.

Es ist halt nicht aus dem Zeilensparen, sondern die Lesbarkeit ist manchmal halt einfach angenehmer, wenn du momentan Dinge erst an eine Variable binden musst, um sie dann auszuwerten.

Und aber eigentlich würdest du es vom Lesefluss her gerne zusammengeschrieben haben.

In den Fällen wäre das halt was, was du gut reinlegen kannst.

Also alle sind begeistert vom neuen Assignment-Operator.

Nee, das kann man nicht sagen.

Nein, überhaupt nicht.

Also gerade bei euch an.

Ja, nee, es gibt halt so drei, vier Fälle und ich glaube, das ist ein Ausdruck von dem deutschen Begriff für Maturity, von der Ausgereiftheit von Python.

Es gibt so Python ist ja in Summe vollständig.

Es gibt ja wenig Dinge, die einem so die ganze Zeit irgendwie im Weg rumstehen, dass man sagt, oh, bevor das nicht geht, kann ich Python nicht benutzen.

Sonst würde man ja nicht hier stehen.

Aber es gibt immer mal den einen oder anderen Fall, der dann doch auch eine Diskussion, in der Wolverse-Operator war, lange diskutiert worden, glaube ich.

Ich habe das Pep gerade nicht, ich weiß gerade nicht.

Gildern sagte so, nö, mach erstmal ohne mich.

Möglich, ja.

Und es ist halt immer, wenn man sagt, naja, Python soll halt nachher auch gut zu lesen sein, dann ist es natürlich schön, sich über die Zeit halt auch Gedanken zu machen, ob bestimmte syntaktische Ergänzungen Sinn machen, auch wenn man sie nicht ständig braucht.

Das ist immer ein bisschen blöd, weil ein größerer Sprachumfang heißt, komplexere Interpreter, also mehr Möglichkeiten, dass irgendwas kaputt geht.

Gerade jetzt in dem Fall wird, das ist jetzt ein Feature, wo etwas, das vorher nur in Statements ging, jetzt auch in Expressions ging.

Das heißt, da muss in Zukunft im Sprachdesign auch darauf aufgepasst werden, wenn am Scoping oder an ähnlichen Dingen was geändert wird, dass das dann halt auch in einem Expression halt auseinanderfliegen kann.

Das muss man gut abwägen.

Aber in Summe offensichtlich hat man sich ja geeinigt und gesagt, das ist es uns wert.

Also ich finde es aber doof, wenn ich das richtig verstanden habe.

Nö, das, also ich finde es tatsächlich ganz, ganz nett, aber ich weiß auch, dass es irgendwie sehr kontrovers diskutiert wurde und dass es halt Leute gibt, die das hassen.

Und was auch irgendwie in gewisser Weise nachvollziehbar ist, also aber ja, wir werden wahrscheinlich irgendwann in ein paar Jahren wissen, ob das eine super Idee war oder total doof, keine Ahnung.

Vielleicht kriegt es jetzt wieder ganz viele Anfänge ab und so.

Meinst du noch nicht?

Ich meine, die Gefahr ist tatsächlich immer, dass, wenn, aber Python hat eigentlich, was die Lernkurve angeht, einen ganz angenehmen Vektor, dass Leute sozusagen zu früh auf zu spezielle Fälle sich einschießen und dann meinen, sie müssen den Wolf-Operator rechts und links an allen Ecken und Enden einsetzen.

Es ist aber mehr dieses Thema, dass man halt, Python ist halt nun mal eine idiomatische Sprache, das heißt, es ist eine Sprache, die ist daraufhin designt, dass man sich ähnlich wie eine natürliche Sprache auch so mit ihr auseinandersetzt und bestimmte Wendungen in bestimmten Situationen halt einsetzt und in bestimmten Situationen halt nicht.

Deswegen gibt es halt, wenn man im Fernsehen ein Wort mit F sagt, dann irgendwann ein piepsen.

Und in einem anderen Kontext kann man das halt einsetzen.

Und das ist halt, da ist Python, Raymond Hettinger sagt an der Stelle immer gerne, Python ist halt eine Sprache für Erwachsene.

Du musst halt wissen, was du tust.

Und so ist es mit allen professionellen Werkzeugen oder auch mit Power Tools.

Klar kannst du dir halt in den Finger bohren.

Deswegen solltest du halt wissen, was du tust.

Eine Bohrmaschine bitte nicht anfassen.

Ja, genau.

Nicht direkt auf die Hand zielen.

Vielleicht auch über andere dem sich die Organe ausnutzen.

Also der Warus Operator ist ein Punkt, da kommen wir nachher vielleicht ganz zum Schluss, wenn wir unser Rattenlocht-Thema finden.

Ist tatsächlich ein Aspekt, mit dem ich halt in letzter Zeit öfter mal gehadert hatte, weil ich habe einen Anwendungsfall, wo ich ständig etwas sowohl verwenden als auch zuweisen möchte.

Und das ist halt schwierig.

Ja, jetzt geht's.

Und insofern, ich habe eine ganz persönlich eben eine Anwendung, wo ich gesagt habe da wird es dann interessant werden.

Ich habe eher das Thema, dass bevor ich halt sagen kann, in meiner Library unterstütze ich halt alles nur noch ab Python 3.8 aufwärts.

Das wird halt noch eine Weile sein.

Ich bin halt mehr in der Spanne 3.5 bis 3.8 halt momentan.

Aber das ist zumindest halt am Horizont erkennbar, ja.

Ja, also mit 3.8, wenn wir es mal weitermachen wollen.

Also was ich, wo ich doof gestolpert habe, es gibt einen blöden Bug jetzt mit Jupyter.

Und zwar fliegt das unter Windows einem um die Ohren, wenn man versucht, so ein Notebook aufzumachen.

Geht einfach aus bei 3.8.0.

Das ist natürlich nicht so toll.

Aber es gibt einen Fix.

Man kann nämlich einfach in Tornado, was da irgendwie querschießt, AsynKIO anpassen.

Alles unter Tornado-Plattform AsymK.O, irgendwie in deren Zeit-Packages drin.

Und kann da einen kleinen Code-Schnipsel eintragen, Import ASMK.O und dann den Event Loop Policy einsetzen auf den Windows-Selektor Event Loop.

Und dann geht's wieder.

Das ist ein bisschen hakelig, aber ich habe gehört, das soll wohl irgendwann gefixt werden in 381 oder so.

Nur für alle, die vielleicht drüber gestorben hat und sich gewundert haben, worum das nicht geht.

Ah, das ist natürlich schon so ein bisschen bitter, wenn das dann wie alle Notebooks auf.

Ich meine, na gut, wer benutzt denn Jupyter Notebooks auf Windows?

Vielleicht ist es ja auch nicht.

Ja, nein, ich glaube, das geht tatsächlich bei einigen Menschen um die anderen Dinge.

Ist der Trigger gewesen, weil die Default-Policy geändert wurde fürs Asynchro und Windows?

Möglicherweise, ich habe keine Ahnung über den Grund, muss ich ehrlich gestehen.

Ich habe einfach nur diesen Fix gefunden und gedacht, okay, ich probiere es mal aus und dann ging es tatsächlich wieder.

Also irgendwas war da mit ASUGIO kaputt.

Ich weiß nicht, die haben glaube ich bei 3.8 auch was mit ASOGO verändert bei dem Verhalten.

Und da kann gut sein, dass da irgendwas geändert worden ist.

Also ich meine auch im Kopf zu haben, dass über dieses Thema, welche Loops wo Default sind, dass da was passiert ist, kann halt sein, dass da jetzt irgendeine, ja.

Ja, es war es kaputt gegangen und das ging da nicht mehr.

Und dann, ja.

Bin gespannt.

Das hat ein bisschen Gehäude verursacht, irgendwie online.

Ja, ich bin auch noch nicht wirklich umgestiegen, weil halt viele der Data Science-Geschichten noch nicht, also ich könnte gar nicht wirklich umsteigen, weil eben, wenn solange sowas wie OpenCV und solche Sachen noch nicht wirklich, also ich glaube, heute ist Pandas in Conda Forge oder auch schon in der offiziellen Distribution mit drin, irgendwie für die Python 3.8, aber es gibt halt noch jede Menge Pakete, die noch nicht gebaut sind.

Also oft ist es, es muss einfach nur nochmal neu gebaut werden und dann geht's.

Aber manche Sachen brauchen halt auch so ein bisschen mehr Aufwand und ja, daher hänge ich da immer so ein bisschen hinterher hinter den aktuellsten Python-Versionen.

Das fand ich auch spannend, da hattest du dem Thema nämlich auch Hindeck einen 1, 2, 3 Tweets losgelassen zum Thema Wheelbuilding auf 3.8, dass er halt jetzt solange die ganzen, also HINEC ist ja in der Community auch relativ gut bekannt um das ganze Security Packaging, da ist er relativ aktiv und schreibt Blogpost und macht immer gute Vorträge und ihm ist halt auch aufgefallen, dass jetzt halt wieder so eine Phase einsetzt von die ganzen Wheels

sind alle noch nicht gebaut und er hat sich in seinen Deployments stark darauf verlassen, dass seine Build-Times im Prinzip relativ schlank sind, weil er halt überall Wheels einsammeln kann und jetzt halt gehen halt überall die Compiler-Orgien los und du hast irgendwie eine vor 10, 20-Fachung deiner Compile-Time.

Da war er dann auch nicht so happy in der Kombination mit, dass die Release-Kadenz ja dann noch angepasst wurde.

Ja, das stimmt, das ist jetzt schneller.

Ja, jetzt haben sie es von 18 auf 12 Monate runtergesetzt, wobei die Support-Zeiten die gleichen sind.

Also jetzt müssen sie mehr Branches noch supporten.

Aber es ist halt auch eine oder sowas, die dann, wenn man die Einkürzung von 18 auf 12 mal hochrichtet, glaube ich, mehr wird es nicht.

Was sagt eigentlich die Uhr für Python 2.7?

Es sind noch 31 plus 30 plus 26 sind noch 57 Tage.

Dann ist rum aus vorbei mit Preis von 2.7.

Eigentlich wäre es jetzt allmählich mal so an der Zeit, die Landingpages hochzufahren und etwas zu buchen auf dem Consulting für Y2K, nee, warte, ähm Python 2K.

Ja, das ist gleichzeitig mit der Abstellung der Streitumstellung.

Ja, nee, die haben sie ja verschoben.

Da kannst du in zwei Jahren separate Consulting-Aufträge draus machen.

Na gut.

Ich meine, was tatsächlich interessant ist, ist aber, die Aussage von Python, von der Python Software Foundation ist ja auch, wenn du von deinem Vendor im Stich gelassen bist, dann such dir halt Consultants.

Hier gibt es Leute, die offerieren dir auch danach noch Support für Python 2.

Es ist halt nur die ganz, eben die Aussage mit kostenlosen Support von den Kernentwicklern, da ist jetzt mal endlich der Zopf abgeschnitten.

Die kümmern sich um ausreichend Dinge, die müssen sich nicht auch noch um veraltetes Python 2 sind.

Legacy Stuff.

Ja, ja.

Also die haben sich wirklich lange.

Die haben jetzt wirklich zehn Jahre, noch länger.

Ich weiß es gerade nicht.

Und also da gibt es Consultants, die da auch beworben werden tatsächlich von der PSF.

Die pflegen irgendeine Liste.

Also Jochen, wenn du da noch was.

Doch kapazitätenfrei.

Kannst du ja eintragen.

Ich meine, ich habe selber gerade mein eines großes Projekt mal noch schnell Just in Time auf Python 3 umgestellt.

War wirklich auch erstaunt, ob der in Summe Geschmeidigkeit, also ich meine, seit zehn Jahren die Aussage ist, schreib halt Tests für deine Sachen.

Dann kannst du halt nämlich danach gucken, ob die Tests wieder gehen.

Und also ich bin, glaube ich, jetzt bei einem Projekt, was relativ komplex ist und ich weiß nochmal, 6000 Zeilen, 6000 Zeilen, war ich in der Umsetzung mit, glaube ich, 10 Stunden Arbeit in Summe dabei.

Und dann waren die Tests alle wieder okay und es tat erstmal sinnvolle Dinge.

Und tatsächlich, das 223-Tool hat mir extrem viel weggefuttert.

Das hat gut funktioniert.

Und wenn man viel I.O.

macht, muss man halt eine Weile lang am Unicode rumschrauben und dann geht es halt.

Ja.

Nee, war ich jetzt über, war eigentlich überrascht, dass das doch ziemlich geschmeidig ging.

Hatte ich irgendwie mit mehr Geknirsche gerechnet.

Ich habe letztens hatten wir eine schöne Diskussion dafür im Channel, was der Weihnachtschick gegangen ist.

Und zwar haben sie das Rundungsverfahren geändert.

Und dann ging kaufmächisches Runden irgendwie auf einmal anders.

Und da war auch die Frage, was dann Pi223 macht.

An der Stelle, das wusste ich auch nicht.

Ja, wenn das wichtig für dich ist, dann kannst du dir das zum Glück anpassen.

Ja, aber das war tatsächlich spannend.

Ja, 223 ist ja pluggable mit den Fixern, die da drin sind.

Also wenn man, wenn man selber wirklich eine große Codebasis noch haben sollte, die man noch nicht mal angefasst hat.

Aber dann ist man, glaube ich, auch nicht derjenige, der Custom Fixer schreibt.

Ja.

Ja, da hat man sich wahrscheinlich dann schon länger nicht mehr so wirklich dafür interessiert, wie das da weitergeht, wie alles.

Ja, aber es ist jetzt auch mal, ich bin mal gespannt, wie viele Schmerzen das verursachen wird.

Ich meine, es gibt ja auch dann größere Institutionen, die dann noch Support anbieten.

Ich glaube, Red Hat hat auch irgendwie gesagt, dass sie das, dass sie einen Python 2 Fork weiter maintainen wollen oder so.

Oh, sehr gut.

Wir haben doch alle einen neuen Fork modell.

Dann kann ich auch in fünf Jahren nach einem Python 2.7 auf einen 3.6er Kernel fahren.

Ja.

Software-Archäologie.

Ja, genau.

Lebende Archäologie.

Sehr schön.

Genau, ja.

Was kommt eigentlich nach Python 3.8 und 3.9?

Kommt dann 3.10 oder kommt dann 4?

3.10.

Also außer sie ziehen das Argument wie Linus, der sagt, Versionszimmern haben in dieser Hinsicht für mich keine Bedeutung und ich mache ab irgendeinem Cut.

Einfach aber, also die zweite Stelle kann ja auch zweistellig werden.

Das ist ja nicht das Thema.

Und jetzt, wo man die Leute schon mit von 2 zu 3 so erschreckt hat, wartet man da jetzt noch ein bisschen.

Ich meine, was bei 3.8 noch dazu kam, das ist noch ganz interessant, aber auch wieder so eine Kleinigkeit ähnlich wie beim Boris Operator, sind die Positional only Arguments.

Oh ja, genau.

Bisher kann ich ja in dieser Kombination aus Argumenten, die ich in einer bestimmten Reihenfolge ohne Namen oder mit Namen und einer beliebigen Reihenfolge und unbenahmt nach Reihenfolge und benamt ohne Vorankündigung in diesen ganzen dynamischen Varianten zulassen kann, kann ich momentan nicht verhindern, dass jemand mir ein Positionsargument halt auch mit Namen angibt.

Und das gibt es jetzt tatsächlich als neues Ding, dass man markieren kann, dass Argumente wirklich nur positional übergeben werden dürfen.

Wobei ich tatsächlich auch zugeben muss, zum einen, da ist mir tatsächlich der Syntaxanteil eher zum Abgewöhnen.

Warum macht man das?

Also was gibt es da für einen Grund für?

Nein, den habe ich tatsächlich gerade auch nicht geführt.

Ich weiß es nicht so genau.

Ich hab mal, das war, ich hab eben auf der PyCon war halt auch ein Talk über diese Änderungen und da hat jemand ein Beispiel gebracht, irgendwie mit Potenzieren, dass das da irgendwie ein Böse beißen kann.

Und ich krieg's jetzt glaube ich auch nicht so wirklich auf die Reihe, was ja da das Problem war, aber im Grunde ist halt das Blöde, dass ja, wenn du halt nicht so richtig erwartest, dass wenn du irgendwie ein Keyword-Argument halt übergibst, dass das dann halt als Positionsargument auch reinkommen kann und dann sozusagen vielleicht einfach Dinge in der falschen, im falschen Hals irgendwie zur Funktion landen.

Ja, was passieren kann, ist, wenn du ein, da weiß ich aber auch nicht, was momentan der Effekt wäre, aber du kannst solche Sachen bauen, wenn du zum Beispiel halt durch Stern- und Sternstern Dicts übergibst und in dem Dikt ist etwas drin, was eigentlich ein Positionsargument wäre, dann könntest du das damit ersetzen.

Das heißt, wenn es zwei, aber da würde sich eigentlich Python jetzt schon gegen wehren.

Wenn du ein Positionsargument namens A per Position übergibst und dann im Dikt nochmal ein A mit drinnen stehen hast als Sternstern, Keyword-Argument, da würde sich eigentlich schon gegen wehren und sagen, das geht so nicht.

Aber für mich ist es ein bisschen so ein Ding, ähnlich wie du bei Command-Line-Tools häufig, wenn du hintergelagerte Prozesse starten möchtest, so Star Stop-Demon-mäßig, und du willst an denen auch noch Argumente übergeben, dann hast du manchmal auf der Command-Line so ein Doppelminus, um zu sagen, so hier ist das Ende von den Argumenten, die ich kriege und hier gehen die Argumente los, die an die nächsten weitergegeben werden, damit die Parser nicht durcheinander kommen.

Und so in dieser Kategorie ist das für mich halt auch angesiedelt, nur diese syntaktische Auswahl, dass du dann halt neben den bisher schon Sternchen in der Funktionsdeklaration jetzt noch ein Slash als bedeutungstragendes Element hast.

Ich weiß gar nicht, ob der Doppel-Slash auch belegt für die Keyword-Arguments oder sowas?

Nee, ne?

Nee, ich meine nicht nur das Slash.

Aber das sieht ex, also meine Ästhetik ist arg verletzt, ja.

Ja, und wenn man halt nicht weiß, dass das die Spiel.

Ich meine, es ist sowieso, denke ich, für Leute, die damit anfangen.

Also die Stern- und Doppel-Stern-Geschichten sind schon so, hui, was passieren hier für magische Sachen?

Und jetzt aber der Slash ist auch nochmal, da kann ich auch mir gut vorstellen, dass da Leute ein bisschen verwirrt werden.

Aber naja, ich meine, die meisten Leute werden das ja auch nicht zu sehen kriegen.

Also das ist halt etwas, was man halt dann macht, wenn man muss.

Aber ansonsten, ja.

Ja, das ist auf jeden Fall auch eine interessante Geschichte.

Ah, genau, dann.

Das Next Ding für Python 3.8.

Bitte?

Das nächste Ding für Python 3.8.

Halt mal braucht man auch eine Chaptermark.

Ja, ich, äh, das muss ich mir mal sagen, ich glaube, ich habe es sowieso verpeilt, ich weiß nicht, Reaper macht die Chaptermarks manchmal an den Anfang, wenn man das irgendwie falsch einschaut.

Haben wir eigentlich noch keinen Button, den wir irgendwie mit dem Raspbi-Truck haben?

Ja, ja.

Buzzer oder auch mal vor.

Genau, muss ich mal irgendwie sterben.

Vielleicht zählt es irgendwie im Jahresflex und ein bisschen.

Ich muss mal einen Buzzer kaufen und dann gucken wir mal so ein Interface oder so.

Gibt es eigentlich eine API für Reaper?

Entschuldigung, Kleines oft.

Ja, ja, ja, man kann da solche Dinge reinhängen.

Das ist tatsächlich alles möglich.

Ja, genau, nee, schöne Geschichte.

Also ich finde das total toll.

Ich weiß nicht, ob andere Leute das auch gut finden.

Aber für Multiprozessing gibt es jetzt so Shared Memory-Geschichten automatisch.

Also wenn man so Arbeit verteilen möchte auf mehrere Prozesse, was man manchmal muss, wenn man zum Beispiel ja auch irgendwie CPU-Power haben möchte, dann geht das ja wegen Global Interpreter Log nicht so wirklich mit Threads und dann startet man halt mehrere Prozesse, das ist halt die Lösung dafür.

Dann hat man aber das Problem, dass man, wenn man jetzt eine Funktion sozusagen, also eine Funktion mit unterschiedlichen Parametern in fünf unterschiedlichen Prozessen ausgeführt haben möchte, dass man irgendwie diese Parameter, die man der Funktion übergibt, halt irgendwie in diese Prozesse reinbekommen muss.

Und da kann man natürlich einfach irgendwie die Sachen pickeln oder das funktioniert auch, ich glaube, sie werden auch per Default gepickelt.

Aber wenn man jetzt irgendwie was übergibt, zum Beispiel halt auch gerade bei so Data Science-Geschichten, irgendwie große NumPy-Arrays oder so, die halt so groß sind, dass ich die nicht fünfmal in Hauptsprecher packen kann, dann habe ich halt ein Problem, weil geht halt einfach nicht mehr.

Und das, was man dann machen konnte, ist aber eine ganz schöne Fummelei, ist, man macht halt einfach ein Shared-Memory-Segment, was halt alle irgendwie, auf das halt alle Prozesse zugreifen.

Und also man kann dann so Dinge machen, wenn man nimmt halt irgendwie Struct in der Standardbibliothek, das Modul und baut sich dann halt so eine binäre Datenstruktur zusammen in ein Chat-Memory-Segment und dann lädt man das in den Prozessen halt irgendwie, greift man darauf zu und dann hat man halt auch sozusagen die Daten übergeben, ohne dass man da irgendwie

selber muss.

Aber das ist halt schon, ja, ich würde mal sagen, die meisten Leute, also das ist schon auch ganz schön wild und würden das nicht so machen wollen.

Und jetzt gibt es halt eine Geschichte, die halt automatisch drin ist und man muss sich selber nicht drum kümmern.

Und wenn man die Daten, wenn man alle Prozesse, die man aufruft, die gleichen Daten verwenden sollen, dann kann man sagen, so hier in diesem Shirt mein Musikwend ist das drin und dann kriegen die das.

Und das ist natürlich schon ziemlich cool.

Ja.

Einen habe ich noch.

Es gibt noch ein kleines Ding, das war vielleicht sogar den meisten nicht aufgefallen.

Es gab noch einen, eigentlich war es ein Bug, aber hat jetzt eine Weile gedauert und zwar Unpacking, also wenn ich Listenelemente an einen Wert antackern möchte.

Also ich kann zum Beispiel ein Tupel haben, da sind irgendwie die Zahlen 4, 5, 6 drin und wenn ich das jetzt einem neues Tupel zuweisen möchte, kann ich dann wieder sagen, T ist gleich 1, 2, 3 Stern mein bestehendes Tupel, um die dann halt schön zu vermischen.

Das könnte man bisher machen, aber das konnte man nicht benutzen, wenn man eine Expression hatte, die an einen Return oder einen Yield ging.

So.

Seltenes Ding, aber das ist gerade, wenn man so funktionale Sachen hat, Generatoren, so ein Zeug, wo man irgendwas dynamisch ausgerechnet ist mit was Statischem verknüpfen möchte, dann sind diese Unpackings manchmal sehr, sehr angenehm und die musste man momentan immer über mehrere Zeilen verteilen.

Es wird auch dargestellt, als eigentlich war es irgendwie ein Unintentional Behavior seit Python 3.2 und

jetzt ist es nicht mehr als.

Oh, ja, ich weiß nicht, aber ansonsten.

Haben wir vergessen, Python 3.8?

Es gibt noch die Audit Hooks irgendwie.

Ja, was ist das denn?

Ja, du kannst

Was ist ein Audit?

Fangen wir doch erstmal so an.

Also von Python jetzt.

Du kannst halt dich irgendwo reinklingen und dann Notifizierungen kriegen, wenn so bestimmte Sachen passieren.

Aber das ist jetzt natürlich so ein bisschen zu allgemein.

Ich weiß nicht genau.

Debugger über die Python Runtime bauen.

Hört sich komisch an.

Ja.

Ich habe sie ja tatsächlich auch noch nicht angeguckt, aber es kann sein, dass etwas, was ich schon eine Weile haben wollte, das Spannend ist, die Hooks können nämlich zum einen halt von außen reingegeben werden, dass ich die, wenn ich jemanden eine Python Runtime zur Verfügung stelle, so als Hosting Provider oder als Plattform Provider, kann es interessant sein, dass ich die forcieren kann.

Und also ein Thema, und da ist nämlich letztens der Bug, den ich vor 14 Jahren eingesteuert habe, mir zugemacht worden mit, das geht jetzt irgendwie anders und da muss ich mal reinschauen, war, dass Python zum Beispiel, wenn ihm der Speicher ausgeht, kriegst du, kriegt dein Python-Programm halt einen Memory Error, dass er keinen Speicher mehr zitieren kann und dann kannst du sozusagen nochmal versuchen, sinnvolle Dinge zu tun.

Das Problem ist, es gibt einige Programme, gerade so Server, die laufen und haben, und der Memory Error ist halt keine System Exception, sondern es ist halt eine Exception.

Das heißt, die wird von einem normalen Try-Except auf Exception auch abgefangen.

Und wenn du halt einen Server hast und deine Anwendung läuft in Speicherprobleme.

Das klingt lustig.

Ja, dann kriegt der Main-Loop halt für den, keine Ahnung, für die HTTP-Anfrage oder was auch immer, kriegt der Main-Loop halt dann einmal einen Memory-Error, wirft einen 500er-Fehler dem Client gegenüber und nimmt die nächste Anfrage entgegen.

Und wenn sich aber ein Programm halt dermals in die Ecke manövriert hat, die räumen mir normalerweise nicht ordentlich in sich auf und da wäre es mir lieber, wenn ich halt von außen eben sowas beobachten könnte und sagen kann, hey, in dem Fall mach bitte, mach den Python ins Prozess einfach aus, lass ihn neu starten von Supervisor Assistant.d oder wem auch immer, weil besser wird es nicht mehr.

Also da haben wir halt nicht mehr.

Speicherecken, in die niemand hin will oder sowas oder in der du irgendwas machen kannst, wo du nicht hin sollst oder?

Nee, einfach nur wenn der Speicher halt voll ist.

Das kommt halt auch bei den, auch bei größeren Kisten halt mal vor.

Bei Java ist das immer noch ein bisschen härter, da gibt es ein ähnliches Problem mit diesen, wie der Heap alloziiert wird.

Und bei Python ist es halt so, das brauchst du nicht konfigurieren, aber wenn er oben am Limit anschlägt, dann hast du so ein halbgares Programm, das reagiert meistens halt in irgendwelchen Health-Checks, auch gerade noch so von ich bin einsatzfähig, aber wenn es irgendwas Sinnvolles tun soll, fliegt es halt ständig auf die Nase.

Da haben wir uns lange mit rumgeschlagen.

Und da kam jetzt irgendwie die Info mit, hey, das könnt ihr jetzt irgendwie von außen steuern.

Aber ich glaube, das sind nicht die Audit-Hooks, das ist irgendwas in der Nähe noch.

Ja, ich weiß nicht, also man kann hier, also ich habe ja auch gerade noch in den Pub geguckt, was man da, also man kann an sehr vielen Stellen sozusagen sich so einen Hook setzen, wo man dann sagt, okay, wenn das passiert, dann möchte ich benachrichtigt werden und dann irgendwie drauf reagieren.

Und das, ja, aber ich habe es mir ehrlich gesagt noch nicht so gemacht.

Direkt E-Mail an den Admin.

Ja.

Tja, genau, ansonsten, ich weiß nicht so genau.

Haben wir noch irgendwas in 3.8, was irgendwie interessant wäre?

Na.

I don't know.

Ne, ich glaube also.

Nee, beim Drüberfliegen waren das jetzt so die Sachen, die ich mir rausgesucht hatte.

Ja, gut, dann.

Können wir die Liste auch wieder abhaken?

Genau, so wäre Python 3.8 irgendwie durch.

Ja.

Dann hatten wir noch den Courseprint.

Man wollte noch was erzählen von einem Coresprint.

Erstmal vielleicht ein kurzes, was ist ein Core Sprint?

Also da geht es um die Core-Developer, sind das eigentliche große, die Gurus von Python, die Entwicklerteams, die am Kern der Sprache arbeiten, ist das richtig?

Ja, genau.

Und also typischerweise, die nutzen halt schon auch die Gelegenheit, wenn sie können, dass sie sich mal treffen.

Und diesmal war es jetzt vom sitzt, vier Wochen her, 9.

bis 13.

September, wo schon auch relativ lang, fünf Tage, vier Tage, haben sie 34 Leute getroffen, große Gruppe.

Viele Langzeitleute, aber das Kernteam hat sich auch in den letzten Jahren extrem gut diversifiziert.

Also viele Leute auch aus unterschiedenen Ländern, unterschiedenen Hintergründen.

Das ist eigentlich gut gewesen.

Und die haben einen Haufen Pull-Requests verarbeitet, 120 Stück haben sie gesagt.

Und da wurde dann auch der Python 3.9 Release-Schedule und jetzt die neue 12-Monats-Kadenz beschlossen.

Und da machen sie auch viele mal eine Infrastruktur.

Also der Bugtracker wird nochmal angeguckt und solche Dinge.

Und zwei Sachen, die sind mir aber dann konkret nochmal genauer aufgefallen.

Das eine ist, es wird mal wieder am Gill rumgedoktert.

Ich weiß nicht, ob wir den im Cast schon hatten.

Der Global Interpreter Locker ist einer Dinge.

Vielleicht nochmal kurz anreichen für alle Menschen, die jetzt das als erstes hören oder so.

Ja, das ist der Global Interpreter Lock und das ist halt, um zu verhindern, dass nicht synchronisierte Datenstrukturen auf C-Ebene sich auf den Füßen rumtreten.

Und das ist der Grund, warum halt der immer nur ein Statement verarbeitet werden kann gleichzeitig.

Und ich mit Multithreading in Python halt auch immer nur eine CPU auslasten kann.

Und Jochen hatte jetzt gerade schon gesagt, dass es ja jetzt besseres Shared Memory Management auf der einen Seite gibt.

Und das ist mir nämlich dann beim Durchgucken von dem Sprint auch aufgefallen.

Das scheint noch in, die Arbeit scheint noch in eine andere Richtung zu gehen.

Nämlich, dass man, um den Guild um rumzugehen, mehrere Python-Interpreter in einem C-Prozess haben kann.

Und bisher, das ging bisher auch schon, der Interpreter war selber ein Objekt, was man.

Ich weiß gar nicht, ob man es, ob man tatsächlich mehrere Interpreter starten konnte.

Die Ecke fasse ich einfach zu selten an.

Aber auf jeden Fall arbeiten Sie jetzt daran, dass es so umgearbeitet wird, dass mehrere Interpreter im Prozess jeder seinen eigenen Global Interpreter Log kriegt.

Und ich meine, das ist von der Arbeit her relativ logisch, was da zu tun ist.

Es ist ein C-Programm, da gibt es halt, wenn man nicht aufpasst, globalen Scope, globale Variablen.

Und die müssen sie jetzt im Prinzip einmal komplett alle wegputzen, dass alle Daten, die irgendwas mit dem Interpreter zu tun haben, nicht globale Variablen sind, sondern dass die alle an eine Interpreterinstanz dran getackert werden.

Und dann haben wir nämlich tatsächlich die Chance, Python-Code in einem Prozess über mehrere Threads parallel auszuführen.

Und wenn man dann nämlich wieder die Techniken ins Spiel bringt zum Thema Shared Memory, dann geht das vielleicht sogar tatsächlich auch ganz gut leichtgewichtig.

Und das klingt jetzt nach so einem ganz interessanten Kunstgriff, anstatt den Gill loszuwerden oder den Interpreter an der Stelle da weiter aufzubohren, einfach zu sagen, kommen dann mehrere Interpreter parallel.

Wir dröseln die Datenstrukturen so auf und dann kann halt jeder Interpreter in unterschiedlichen Prozessen Threads laufen und siehe da, wir sind in der Lage, mit einem Prozess mehr CPUs auszulasten.

Also das wäre, das wäre tatsächlich nochmal, finde ich ein interessanter Ansatz.

Ja, das klingt tatsächlich sehr interessant.

Ja, gerade werde ich der Kern also mehr zunehmen, ne?

Ja, ja, das ist natürlich auch so ein Dauerthema, wobei, ich meine, die Fälle, wo man das wirklich, wirklich braucht, sind auch eher so beschränkt, würde ich mal sagen, weil die meisten Leute ja nicht, also ich meine, dass man CPU und dass man IO-Multiplexen will, irgendwie, das kommt schon häufig vor, aber dass man das gleichzeitig mit viel CPU-Verbrauch macht, ist, also wenn man nicht gerade einen Datenbankserver schreibt oder so, würde ich jetzt sagen, gar nicht so super häufig.

Nee, du willst ja immer eigentlich auch über mehr Prozesse skalieren können.

Ja klar, natürlich.

Genau, ich glaube, der Grund, warum das mit dem Gill halt so ein Problem ist, ist auch da irgendwie, dass wie Python den Hauptspeicher verwaltet, ist da so ein Riesenproblem, weil das Reference Counting, man müsste das alles irgendwie locken, eigentlich.

Also ich habe es jetzt auch so, was ich mal darüber gehört habe, aber schon wieder ein bisschen her.

Und das kann man natürlich machen.

Man kann irgendwie vor jeder Operation, die man irgendwie beim Reference Counting macht, sagen, okay, wir locken das jetzt hier oder da halt irgendwie den Zugriff dann exklusiv machen, damit sich da irgendwie nichts überschreibt.

Aber dann wird halt, wenn man das einfach so macht, glaube ich, wird das wird Python 40 Mal so langsam.

Und dann haben irgendwelche Leute sehr unheilige Dinge getan und rumgetrickst und haben es auf Faktor 20 irgendwie runtergekriegt oder so, wovon schon niemand geglaubt hat, dass das möglich wäre.

Und aber das ist halt so das Problem.

Man kann es halt nicht, äh, also mit der Art, wie das Haupt, wie das Speichermanagement, also mit Reference Counting funktioniert, geht das halt wohl nicht gut.

Und ja, die einzige gute Möglichkeit, also wie es halt weiterhin schnell bleiben kann, ist, dass man sagt, nee, es gibt nur einen Thread, der halt irgendwie daran Dinge am Reference Counting ändern kann.

Ja, und dafür braucht man halt einen Gill irgendwie.

Aber ja, also das mit den mehreren Interpretern, das klingt auch sehr interessant.

Also da bin ich mal bin ich mal gespannt, weil das ist ja auch mal so ein Standardargument, was an Python halt nicht so nicht so toll ist gegenüber anderen.

Und ja.

Was aber auch für den Alltag kein Problem ist.

Nicht wirklich, nein.

Und gerade das Tooling über Multiprocessing ist halt inzwischen extrem geschmeidig geworden, sowohl auf der einen Seite halt für I.O.

Multiplexing ist Async.io extrem angenehm geworden und mit Multiprocessing und Supprozesse starten, das tut meistens tut vor allem auf eine Art und Weise, wo man weniger scharf nachdenken muss.

Sweats haben halt das Problem, und das wissen wir seit 20 Jahren, dass du dir ganz schnell halt in den Fuß schießt und Dinge passieren, die du nicht willst und wenn du es halt über so Prozesse auftrennst, hast du eine klare IO-Grenze und wenn du Async-IO machst, dann hast du halt eben das Thema, dass du selber bestimmst, wann du die Kontrolle über dein Kreuzpfad abgibst und wann nicht, ja.

Ich glaube, das ist nochmal so eine eigene Folge irgendwie, Async und Sweading in Python.

Da haben wir auch gar nicht genug für gemacht.

Das ist auch jedes Mal, glaube ich, mindestens eine Folge wahrscheinlich komplett.

Das ist alles ziemlich fette Brocken.

Was mir auffällt, ist, dass man bei Async wahrscheinlich tatsächlich dann, wenn man das hier nochmal rausholen möchte, was glaube ich wirklich eine gute Idee ist, dann müsste man uns wahrscheinlich was einfallen lassen, um Codebeispiele während in den Stream irgendwie einzubetten.

Ja, da genau, das ist natürlich auch so eine Sache, wie kriegt man das eigentlich gut hin, da auch schon mal drüber nachgedacht, aber auch noch keine Lösung gefunden.

Ich meine, man könnte natürlich auch irgendwie Videogeschichte dazu machen, aber das ist halt auch irgendwie alles.

Ja, ich höre

meines auch irgendwo anders.

Ja, genau.

Da kann ich noch Video einbinden, irgendwo auf der Frontscheibe von meinem Wagen.

Ja.

Nee, dass das widerspricht irgendwie so dem, wie es benutzt wird.

Ja, ich weiß es auch nicht.

Muss man überlegen.

Aber prinzipiell wäre das natürlich schon eine interessante Geschichte, dass man das halt irgendwie dabei hätte.

Also zumindest irgendwie in den Shownotes auf der Website oder da kann man so.

Dokumentiert.

Ja, ich glaube, Monos ist glaube ich gleich draufreichend.

Wenn jemand nachschauen will, wie das denn geht, dann haben wir dann so als Mini-Tutorial drin, wenn sich jemand dann die Mühe machen möchte, das mitzudokumentieren von uns, dann reicht ja.

Also Dings sind ja dabei.

Also ich würde sagen, das passt euch.

Ich weiß ja, der anderer Meinung seit schreibt uns gerne.

Also wir sind immer auf euer Feedback.

Oder vielleicht hat jemand schon mal was gesehen, wo das gut gemacht wurde.

Also das ist irgendwie so das Level, auf dem ich jetzt noch nicht so ganz angekommen bin, dass ich halt große Probleme habe, immer noch so zu verstehen, wann benutze ich denn jetzt was und was ist denn jetzt überhaupt ein Zwett und wann nehme ich den, wann nehme ich jetzt irgendwie Async und vielleicht doch irgendwie ein anderer Taskmanager oder sowas dazwischen, das ist noch nicht so ganz angekommen.

Und ich glaube, das wäre auf jeden Fall nochmal spannend zu verstehen, warum, wieso, weshalb ich denn jetzt welche Technikansätze und wann das so Best Practice ist für was überhaupt.

Ja, auf jeden Fall.

Eigene Folge.

Ja, der letzte Punkt, der mir beim Sprint aufgefallen war, war, dass Guido.

Jetzt schließt sich so für heute wahrscheinlich so der Themenkreis ein bisschen, dass Guido nämlich angefangen hat, eins der im Kern befindlichsten Bauteile von Python, nämlich der Parsergenerator für Python selber, wo er tatsächlich sich damals 89, 90 und dann über die 90er und weg das Herzstück der Programmierung einer Sprache, nämlich Parser, Compiler, Interpreter, das er damals halt selbst eingeb

aut hatte.

Und er wohl die letzten Jahre immer mal angesprochen wurde auf einen ganz spezifischen Typ von Parser, nämlich Generator, nämlich den sogenannten Pack-Parser.

Da hat er sich dran gemacht, tatsächlich dieses Stück komplett nochmal auseinanderzunehmen, neu aufzubauen.

Weil das wohl tatsächlich dann Einfluss hat auf die später mal Parsing-Performance auf der einen Seite und aber auch, welche Sprachkonstrukte sich eigentlich wie elegant definieren lassen, mit wie viele Hacks man eigentlich die Sprache definieren muss, um den Parser dann dazu zu zwingen, dass er tut, was man will.

Und er hat dann eine ganze Reihe von Blogposts schon zugeschrieben, die entstehen gerade noch, aber er hat immerhin beim schon mal eine Gesamtübersicht aller, ich glaube, acht oder zehn vorhandenen und geht da recht detailliert in der Anwendung durch eine Motivation und auch, wie das ganz konkret für Python aussieht, was er da wie zusammensetzt.

Das ist ein sehr spannend zu lesendes Thema.

Und das hat mich halt vor allem deshalb beschäftigt, weil ich die letzten Wochen immer so ein bisschen wieder mit dem Thema zu tun hatte, für einen bestimmten Anwendungsfall Python-nativ zu benutzen oder mit einer DSL und wenn man DSLs macht, eine externe oder eine eingebettete Domain-Specific Language.

Also es gibt ein Projekt von mir, das ist das Bateau, das ist so ein Deployment-Werkzeug.

Und da gibt es sowohl einen deklarativen Anteil von wie definiere ich, wie meine Anwendung deployed werden soll im Allgemeinen.

Und dann auch so einen imperativen von, ja, wie kommt denn jetzt die Datei auf die Platte und so.

Und da habe ich mich damals dafür entschieden, dass ich das innerhalb von Python mache mit einer reinen API.

Und Python ist ja keine Sprache, in der Domain-Specific Languages so eine große Rolle spielen.

Also in Ruby ist es ganz typisch, da ist die Syntax für geeignet, dass du das so dir zurechtlegst, dass du im Prinzip etwas hast, das sieht dir auch noch nach Ruby aus.

Und du musst aber keinen eigenen Parser schreiben, weil du das Ruby so sozusagen gezüchtet hast, dass es dann wie was anderes aussieht.

Und es kommt auch aus den funktionalen Sprachen aus Lisp und Scheme, die haben alle ja so Makros wie auch C, wo du dir dann so komplexe Makros definieren kannst, dass du im Prinzip die drunterliegende Sprache nicht mehr wiedererkennst.

Und das ist in Python aber gar nicht so üblich.

In Python gibt es eher solche, da nennt man die dann Domain-Specific Libraries, SQL Alchemy so ein Beispiel, die dir dann einfach eine sehr fluffige API liefern, die man benutzen kann und du nicht das Gefühl hast, Brüche zu haben zwischen dem, was du

in Anspruch irgendwie so eine, weiß ich, Grammatik zu entwickeln, um die Probleme, die ein bisschen komplexer sind, in einfacher Logik zu beschreiben.

Ja, und dass du halt auch wenig Brüche hast.

Man nennt das halt in der Informatik ein Impedance Mismatch, wenn du halt bei SQL Alchemy, wenn du SQL hast, dann ist das halt so eine deklarative Sprache.

Und wenn du dann aber diese Statements dynamisch zusammenbauen möchtest, dann hast du halt irgendwann nur noch, ja, ich kann irgendwelche Strings generieren, aber dann hast du keine Ahnung mehr, ob die jetzt in taktisch korrekt sind, ob dir beim Quoting was kaputt geht.

Und das nennt man halt einen Impedance-Mismatch.

Also die Audiotechniker können das bestimmt aufs Deutsch übersetzen, wenn du halt nicht passende Widerstände anschließt.

Keinen guten Sound.

Und dafür nehmen viele Umgebungen-Specific Embedded Domain-Specific Languages, also die du in die eigentliche Programmiersprache halt einbetten kannst.

Und in Python sind die Libraries eher so das Thema, wie SQL Alchemy, oder auch Requests, bei denen einfach die API so geschmeidig gemacht ist, dass du das Gefühl hast, du kannst konzeptionell und syntaktisch, so wie du runtertippst, auf einer Ebene arbeiten und hast da nicht ständig Übersetzungsverluste dazwischen.

Und da gibt es tatsächlich inzwischen eine Reihe von, die Pack-Parser kommen halt genau aus diesem Umfeld von, du kannst eine Sprache, eine Metasprache modellieren, die dann wiederum sich in Python zum Beispiel schnell selber parsen lässt.

Und ich hatte ja auch gesehen, es gibt Pack-Libraries für Python, die dann wiederum mit dem Python, was du halt hast, interagieren können.

Das ist ja erstmal so ein bisschen Brainfuck-Niveau und da bin ich aber dann tatsächlich, weil ich mich gerade mit diesem DSL-Thema jetzt beschäftigt hatte, darauf angesprungen, dass die Pack-Powser und dass Guido das gerade anfasst, wohl doch irgendwie interessant sein müssen.

Da gibt es auch ein paar Doktorarbeiten zum Thema, wie kann ich eigentlich schnell Sprachfeatures mal entwickeln und testen und experimentieren.

Und genau das ist was, wo ich gerade davor stehe, will ich eine verballhornte Form von Python haben, die irgendwie so ein bisschen Python ist, aber nicht?

Oder will ich es irgendwie eine ganz neue Sprache mal ausprobieren?

Genau, das war eine schöne Anregungen, wie ich mir das im Courseprint mitgenommen habe.

Ja.

Ja warum denn, aber warum muss das eigentlich?

Ich meine, wenn ich da so ein anderes populäres DevOps-Tool betrachtet, so Ansible, da wird ja Yaml verwendet.

Warum reicht das nicht aus oder ist das, ich meine, deklarativ ist das, aber man kann natürlich nicht so viel damit machen, das ist natürlich.

Genau, also wir machen das jetzt, also Bateau ist interessanterweise ziemlich glatt genauso alt wie Ansible.

Ich glaube, die Repos sind beide irgendwie mit zwei Wochen Versatz angefangen worden.

Also irgendwann 2011, 2012.

Und wir kamen damals von schon einem deklarativen Format, wo wir ständig das Problem hatten, dass wir die deklarativen Formate, also YAML ist ja jetzt erstmal noch kein Datenformat und noch kein Format, also insofern ist es natürlich deklarativ, weil Daten sozusagen in sich deklarativ sind.

Aber da wird dann teilweise halt eine Finite State Machine mit beschrieben.

Also tu das, tu das, tu das.

Hat teilweise auch selber wieder Eigenschaften von der Programmiersprache mit Schleifenbildung und solchen Dingen.

Und was, was, wo mir so ein bisschen immer wieder die Fingernägel hochrollen, ist halt, dass da drinnen dann auch noch Ginger-Templates abgesenkt werden.

Und das haut mir so ein bisschen dem Pferd die Krone aus dem Fass.

Also das ist einfach, da hat man dann so viel aneinander gestrickt und wenn man so in der DevOps-Community rumhört, ist halt auch so ein bisschen eigentlich die Aussage mit Jammel ist so das unvermeidbare Übel, aber so richtig cool finden kann es eigentlich keiner.

Und deswegen hatte ich mich damals entschieden zu sagen, nee, mach ich nicht, ich mache etwas, wo ich in Python deklarativ arbeiten kann.

Und aber immer wenn es sein muss, kann ich die volle Sprachpower von Python halt wieder rausholen und dem Ding meinen Willen aufzwingen, ja.

Naja, das ist halt ist natürlich dann schwieriger, irgendwelche Voraussagen darüber zu machen, was das denn dann tut, weil bei Yammel kann ich das vielleicht dann noch so halbwegs oder so, aber wenn ich jetzt liebige Sache.

Das ist in die Tasche gelogen, weil Yammel ist halt eben nur eine Oberflächenstruktur und die tiefe Struktur drin, wenn das Yammel selber wieder die Komplexität hat von Schleifen und solchen Dingen und sich dann noch kombiniert mit Ginger, wo dann manchmal je nach Werkzeug nicht klar ist, ob das Ginger als aus dem Ginger fällt dann das Yammel raus oder das, was da dann auf der jeweiligen Zeile steht, kommt erst dann später zur Laufzeit ins Ginger rein.

Da können sich auch ganz fiese Kombinationen draus ergeben.

Und für uns war da die Frage eher, das ein bisschen leichtgewichtiger zu halten.

Aber weil auch das ist wieder sozusagen ein Rückgriff jetzt auf den Warras Operator, weil Python inzwischen ja syntaktisch relativ vielfältig ist, ist da die Lesbarkeit irgendwann schon auch das Problem, wenn es zu komplex wird.

Und wir haben so an der einen Stelle eben das Thema, dass wir eine Syntax brauchen, bräuchten.

3.8 könnte es jetzt, wo ich gleichzeitig etwas mit einer Expression mir ranziehe und zuweise und dann weiterverarbeite.

Das wäre ganz nett, aber da überlege ich tatsächlich gerade auch eben, ob sowas wie ein Pack, der sich gut integriert in die Laufzeit von dem Python, was da ist, nicht die Gelegenheit gibt, da nochmal auch über eine Sprache nachzudenken, die das eigentlich besser kann.

Interessant.

Also auf jeden Fall sehr komplex.

Das war jetzt ja kein ganz Anfänger-Thema, wenn ich das nur sagen habe.

Das war keine Einstellungsvoraussetzung, oder?

Nein, nein, das war mal so was.

Die Mischung macht es auch hoffentlich.

Ja, ja, ja.

Absolut.

Falls ihr nicht wisst, was Ginger ist, müsst ihr es einfach mal googeln.

Das ist eine kleine Template-Sprache.

Ja, das ist halt auch wieder so ein ganz eigenes Feld.

Ich glaube, also ich meine, ich würde sogar fast sagen, das ist auch eines der Dinge, für die Python viel benutzt wird.

Halt so Infrastrukturen hochziehen.

Ich glaube, bei Facebook ist Python halt sozusagen die Sprache für alle Services, die irgendwelche operativen Geschichten machen, hintendran und so.

Und es gibt ja noch diverse, es gibt Ensible wird ja auch viel benutzt oder halt OpenStack und ach, weiß der Teufel ganz viele Sachen.

Ja.

Aber es ist alles nicht so ein richtig einfaches Problem irgendwie.

Ja.

Ja, habt ihr noch was habt ihr?

Meine Liste ist gerade unten angeschlagen.

Ja, gut.

Hatten wir noch, wir könnten noch irgendwelche Dinge picken, zum Beispiel, könnten wir noch mal.

Ja, der pickt der Woche natürlich dran.

Der Monat war es einfach an, solange wir die Folge gebraucht haben.

Ja, ich habe eine ganz nette Geschichte gesehen.

Normalerweise, also wer ist der Software, aber da habe ich jetzt gerade nichts.

Aber eine andere Geschichte, die auch ganz nett ist, finde ich, ist, es gibt jetzt ein Django-Forum.

Ja, überhaupt Django ist auch ganz interessant.

Gibt es jetzt bald wahrscheinlich irgendwie eine neue Version und da gibt es auch so Async, genau.

Async, Django 3.

Also erste Schritte dahin und das wird auch alles sehr spannend.

Und es gibt jetzt halt auch ein Forum, wo man sich austauschen kann und das tatsächlich ziemlich nett aussieht, muss ich sagen.

Also das sind zum Tummeln.

Ja, viele der Leute, die da viel machen im Projekt unterwegs und es gibt viele interessante Diskussionen.

Ich war sehr überrascht, was da alles so geht, weil normalerweise ist ja mal Forum vielleicht irgendwie nicht etwas, wo man jetzt unbedingt hin will, aber da, das war echt toll.

Und also wenn man sich mit Django beschäftigt und da Spaß dran hat, dann kann man sich das mal angucken.

Das ist irgendwie echt nett.

Okay.

Ich hatte gehört, tatsächlich in einem der Dango Cars hatte irgendjemand Textblob erwähnt, das fand ich irgendwie ganz interessant.

Das ist irgendwie für Sprachanalyse sehr wichtig, irgendwie auf NLTK aufgesetzt.

Und macht dann irgendwie so Tags an Satzteile dran und Sentimentanalyse und Togenisierung nett und sowas.

Da wollte ich nochmal ein bisschen tiefer reingucken.

Das sah sehr spannend aus und das soll wohl ganz cool auch funktionieren für größere Textoperationen.

Wahrscheinlich eher mit Englisch, aber ja.

Das ist mein Pick der Woche.

Christian, hast du auch ein Woche ist

die Woche ist zu neu, ich habe noch keinen Pick.

Ich glaube, die Packs letzte Woche waren mein Pick.

Ja, ja, das auch mal angucken.

Ein ganzes Pack

statt ein Pink ist auch was nehmen.

Ja.

Ja, da sind wir tatsächlich wieder am Ende dieser Folge angelangt, dieser wunderschönen.

Wo auch immer ihr gerade seid, wo auch immer ihr uns gehört habt, oder?

Schönen Tag, schönen Abend, schöne Nacht und so weiter.

Bleibt uns gewogen, habt viel Spaß.

Kommt gut rein, wir hören uns.

Achso, bevor ich es vergesse, ich wollte noch fragen, wenn ihr Fragen habt oder sowas, ne?

Wir wollten demnächst auch mal eine große Fragefolge machen, wo wir den Jochen löchern und ganz einfache Fragen stellen, die in einer Minute beantworten muss.

Falls ihr da irgendwelche habt,

dann schickt die bitte.

Ich kann dann immer noch hinterher treten.

Mich löchern, ne?

Ja, genau, ja, das machen wir.

Und deswegen, wenn ihr Fragen habt, einfach raus damit.

Achso, und falls ihr noch eine andere Geschichte, wir wollten demnächst auch mal was über die Standard-Library machen, also so ein bisschen

erzählen, was das ist.

Das war auch eine Anregung, die wir per Mail bekommen haben und das war eigentlich, fanden wir ganz gut die Idee.

Und vielleicht können wir da einfach mal so durchgehen, weil da sind ja viele verborgene Schätze eigentlich drin, die man mal irgendwie näher betrachten könnte.

Und falls ihr auch da irgendwie einen Wunsch habt, was wir denn besonders mal belohnt sollen, also auch raus damit.

Ja, vielen Dank, Toni, dass du da warst.

Vielen Dank, Christian.

Sehr gerne in dieser Zeit.

Wieder, sehr schön.

Ich habe wieder viel gelernt heute.

Tja.

Dann hoffen wir einfach mal, dass wir es ein bisschen schneller demnächst wieder hinkriegen konnten.

Ja, wir werden uns diesmal nicht wieder zweieinhalb Monate Zeit lassen.

Alles klar, gut.

Ciao, bis dann.

Tschüss.

Bis dann.

Tschüss.

Ciao, ciao.