Transcript: Python 3.9 und Design Patterns (Teil 1)

Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python-Podcast, 25. Episode.

Heute geht es um Patterns, Software-Patterns, Design-Patterns, Architektur-Patterns.

Und wir haben einen Gast dabei, der Antoni, hallo.

Hallo mal wieder.

Hallihallo.

Ich bin der Dominik, Jochen ist auch da.

Hoiho.

Wir sind im Wintergarten, beziehungsweise remote, wie es halt sich für die Pandemie so gehört.

Wir wollten noch sagen, wenn wir aufnehmen, heute ist der 20. Oktober.

2020.

20, 20, 20, 20, 20.

Immer noch 2020.

Ja, es zieht sich ein bisschen, finde ich, in letzter Zeit.

Ich erinnere den XKCD, wo ein Zeitreiser nach 2020 kommt

und fragt, welches Jahr es ist, und er sagt 2020.

Ja, aber das wievielte.

Das wissen wir auch nicht so ganz genau.

Ja, vielleicht noch ein paar News aus der Szene vorweg.

Genau, ja, was haben wir denn an News?

5. Oktober kam Python

3.9.0.

Oder war das am 6.? Ich weiß gar nicht

mehr genau. Ich glaube an dem Montag irgendwie.

Ja.

Watch released

on October 5th. Oh, okay.

Ja.

Habt ihr alles schon geupdatet? Nein.

Ich habe mich diesmal nicht getraut, weil letztes Mal

mir bei 3.8.0 so ein paar Sachen

wie Jupiter auseinander geflogen sind.

Und ich diesmal darauf keine Lust hatte.

Ich glaube, ich habe es auch noch nicht

bei uns in die Auswahl

mit reingenommen, aber wir haben eh immer sozusagen

das komplette Portfolio von allem

verfügbar.

Ja, ich habe

überlegt, wir machen das bei 1 dann, bei 3, 9, 1.

Ja, ich bin tatsächlich

schon quasi zumindest mit den privaten

Sachen umgestiegen, aber

das wird natürlich noch ein bisschen

brauchen, bis sich das komplett

durchgesetzt hat,

sodass man es halt auch verwenden kann. Zum Beispiel Pandas

gibt es halt noch keine Binarys

und da ist das natürlich auch so ein bisschen

hässlich, wenn man das irgendwie dann selber kompilieren

muss. Das heißt doch, im Baton

habe ich tatsächlich das in die

Travels-Liste schon mit aufgenommen.

Da kam auch

jemand vorbei, der sich gleich

irgendwie sofort beschwert hatte, dass es unter 3.9

nicht ging, weil

irgendwas ist rausgeflogen.

Achso, die haben im Async

irgendeine

API, die deprecated war, jetzt tatsächlich gestrichen

gehabt. Ich glaube, die in 3.7 hatten sie

irgendeine neue API, um alle

Pending-Tasks abzufragen

eingeführt

und die, glaube ich, in irgendein Untermodul verschoben

oder so, statt im direkten

Async-Modul. Das war was, da musste ich dann irgendwie

hinterher und in 3.9 war dann irgendwie die

Abwärtskompatibilität von der API jetzt weg.

Da flog es dann auseinander.

Ja.

Insofern, ja, ich habe es schon mal in der Hand gehabt, weil ich was

Was gibt es denn Neues?

Ganz viele spannende

Sachen. Union Operators?

Was ist das?

Was macht man damit?

Ja, zum Beispiel Dictionaries zusammenschübbeln.

Ja, ich glaube also wirklich mehr als das,

was man vorher auch schon mit Tuple-Unpacking machen konnte.

Also man schreibt halt irgendwie neuer Key, neuer Value

und dann sagt dann hinten der Sternstern irgendwie das andere Dict,

was man merchen will.

So, ich glaube, wenn man jetzt den Pipe-Operator verwendet,

macht es so mehr oder weniger genau das Gleiche.

Ja, aber warum macht man das?

Also ich habe es nicht genau verstanden.

Ich finde es irgendwie, weiß nicht,

das ist das Erste, was ich bei Python so richtig hässlich fand.

Naja, was fandst du hässlich?

Ja, diesen Operator, diesen Pipe-Operator

da stehen zu haben auf einmal für so eine Operation.

Och, ich weiß nicht.

Ich meine, das wäre halt Mengen-Operations-

Operator an der Stelle.

Es ist halt ein Oder.

Ja, das passt schon.

Das war ja vorher schon immer das Oder

und wenn ich halt über die mengentheoretische

Definition nachdenke,

dann ist das halt genau das, was passiert,

wenn ich halt die Oder-Verknüpfung von zwei

Mengen irgendwie definieren möchte.

Oder gleich dieses

Assignment, irgendwie ist das komisch.

Naja, das ist halt so wie plusgleich oder

malgleich.

Das habe ich tatsächlich in Bato benutzt

oder gleich tatsächlich, auch Bato hat ja so eine

komische Syntax, wo wir plusgleich

benutzen, wo du

so einen Baum aufbaust mit self

plusgleich und dann den Kindknoten

und da gibt es nochmal

ein Overloading für die Pipe,

wo man dann sozusagen eine spezielle Form

von Verkettung hat. Insofern finde ich das

ganz cool, dass die jetzt auch die Pipe genommen haben.

fühle ich mich in meiner Wahl von vor

sechs Jahren bestätigt.

Ja.

Ja, also ich glaube,

also so, was

es halt, es sieht halt, ich finde, es sieht schon besser

aus, als wenn man jetzt immer mit den Sternen und Sternsteinen, da muss man

mal so ein bisschen nachdenken, was denn jetzt,

was man jetzt eigentlich genau machen

wollte. Es ist ein bisschen hübscher,

aber es ist jetzt keine so weltbewegende

Änderung.

Ja, das ist hübscher.

Und es ist vor allem, es erzeugt halt ja ein neues Dignam.

Also ganz

klassisch war ja immer das Thema, dass du

DictUpdate sagst.

Ja, und dann macht das

was anderes, als man denkt. Das modifiziert

den Original-Dict und genau.

Ja.

Ja.

Insofern ist vielleicht ein bisschen eindeutiger, was es macht.

Ja, also

mein Lieblingsfeature tatsächlich, oder

meine Lieblingsneuerung ist

der Pack-Parser. So ehrlich gesagt bin ich jetzt

kein Experte

für so Parser-Geschichten, aber ich fand das schon eigentlich

ganz nett,

was man damit dann eventuell alles dann

zusätzlich so machen kann. Also

es hieß irgendwie so, ja,

das macht dann irgendwie neue Sprachfeatures einfacher

oder so. Das stimmt nicht so ganz.

wirklich viel einfacher wird dadurch nicht,

aber es macht halt so ein paar Sachen, die bisher sehr hässlich

waren. Du musst uns den Hörer nochmal kurz erklären, was überhaupt

ein Pack-Parser ist, bitte. Oh nein!

Das wollte ich eigentlich vermeiden.

Das kann ich ehrlich gesagt nicht wirklich.

Also es gibt halt diese Standard-

Parser für so

Programmiersprachen. Also die meisten Programmiersprachen

sind halt, oh, oh je, jetzt kann man

nochmal positiv in die Informatik

hinabsteigen.

Da gibt es halt so, so Programmiersprachen

sind meistens, die Grammatiken dafür sind so

kontextfreie Sprachen.

Also, oh je.

Ja, ja, genau.

Ja, du musst halt

eine bestimmte

Form davon, so

LR1-Grammatiken oder so, das ist halt

LR1,

LR1-Grammatik zum Beispiel.

LR1-Grammatik.

Ja, also in dieser Form ist auch zum Beispiel immer die Java-Sprachspezifikation. Das ist das Erste, was ich in, sollte man sich im Studium, als ich mal angefangen habe, irgendwie sollte man sich das mal kaufen. Habe ich dann gemacht, fand ich sehr langweilig, ehrlich gesagt. Das war ein sehr dickes Buch, in dem stand halt die komplette Sprache und halt Grammatik drin. Und da dachte ich schon, das ist eine komische Abkürzung und das ist halt genau die, die halt beschreibt, ja, wie die Grammatik für diese Sprache aussieht.

Und wenn man das sozusagen

in dieser Form notiert hat, dann kann man das in einen

Parser-Generator werfen

und dann... Der liest die Sprache und weiß, was

der machen muss. Der gibt einem dann

einen Parser, der genau diese Sprache

akzeptiert.

Und das sind dann so Dinge wie...

In letzter Zeit habe ich da wenig mit zu tun gehabt.

Früher ganz mehr.

Sowas wie YAK zum Beispiel

gibt es da.

Ist auch so ein rekursives Akronym.

Justiner sagt Compiler, Compiler.

Dem kann man

sowas vorwerfen und der spuckt dann halt

einen Parser aus und das gab es dann

Lex und Bison und

ich weiß gar nicht mehr so genau.

Und genau, damit kann man

Parser generieren und die akzeptieren

dann solche Sprachen und die meisten

Programmiersprachen sind halt so irgendwie diese

Geschmacksrichtung von kontextfreier

Sprache.

Und Python Parser

war halt auch sowas.

Aber

das Problem ist, es gibt halt so ein paar Features,

die passen da nicht so richtig rein.

Oder ein paar Dinge in der Sprache, die funktionieren damit halt nicht so richtig.

Und deswegen gab es da sowieso schon immer so Ausnahmen.

Und deswegen ist es halt bisher so ein bisschen hässlich gewesen.

Also es gibt zum Beispiel, ich kriege das auch nicht alles auf die Reihe,

aber es gibt halt den, der Parser nimmt halt sozusagen den Text,

also irgendwie ein Python-Programm und gibt dann halt ein Abstract-Syntax-Tree aus.

Und der wird dann von dem Compiler verwandelt in Bytecode oder so.

Und da wird dann halt irgendwie interpretiert.

Und das gibt dann halt so diverse Teile.

Und

das Problem ist irgendwie, dass manche

Sachen halt

verteilt sind auf unterschiedliche Teile.

Also dass es halt nicht so ist, dass es

oder der Parser bisher,

da bestimmte Sachen halt nicht so einfach damit parsbar waren.

Und der ist auch handgeschrieben.

Wenn man sich das angucken will,

gibt es ein Modul, das nennt sich

ast.c oder so

in Python Source Code,

dass der alte Parser

paar tausend Zeilen handgeschriebenes C

ziemlich fies. Also

genau. Und

der ist halt nicht automatisch generiert,

was halt schon mal nicht so schön ist, weil das

halt dazu führt, dass er nicht so richtig

konsistent ist und so und sich manchmal komisch

verhält. Und

das Problem eigentlich

dabei ist, wenn man jetzt sozusagen

teilweise sind halt Sachen,

ich kriege das nicht mehr richtig auf die Reihe,

wenn man zum Beispiel

rechts neben dem Gleichheitszeichen,

Weil das Gleichheitszeichen ist irgendwie ein Problem und wenn man da mehrere Sachen stehen hat, also mehrere Dinge, die addiert werden oder so, dann muss das hinterher nochmal im Compiler umsortiert werden, weil das der Parser noch nicht irgendwie ordentlich gemacht hat irgendwie.

Und das heißt, wenn man jetzt irgendwie so ein Problem hat, auch ein Syntaxproblem, Funktion A plus Funktion B rechts von einem Gleichheitszeichen, dann ist halt komplett unklar, wenn jetzt da irgendwo ein Syntaxfehler ist, wo der eigentlich passiert.

das ja dann schon einem erst im Compiler

irgendwie um die Ohren fliegt oder so,

sodass halt der einem

sozusagen der Python-Interpreter auch gar nicht sagen kann,

wo der Syntaxfehler ist, was halt eventuell

ein Problem sein könnte. So, wenn man nicht mehr

weiß, wo der Fehler ist, dann ist es halt schwer, den zu fixen

und das sind halt so Hässlichkeiten,

sodass man halt da diese

Überprüfung, ist das jetzt korrekter Python-Code

oder nicht, halt nicht an einer Stelle passiert,

sondern halt über ganz viele Teile verteilt

ist, ist das halt, sind manche Sachen

halt einfach total hässlich und

Und ich habe da so ein Podcast-Init.

Da waren die beiden, die den Pack-Baser hauptsächlich gebaut haben,

jetzt in Python 3.9 zu Gast und haben da halt so ein bisschen was erzählt,

was sie da gemacht haben.

Einer von denen meinte so, also eine User-Anfrage war halt so,

warum können wir das in RIS-Context-Managern mit diesem RIS-Statement

nicht einfach so machen wie bei Imports

oder halt mit

bei Strings, dass wir da Klammern drumrum

machen und dann haben wir mehrzeilige Dinge, weil

mehrzeilige With-Statements geht halt einfach nicht.

Und

das hat er dann versucht umzusetzen im alten Parser

und das ging halt überhaupt gar nicht.

Also er hat da irgendwie wohl eine Menge Sachen

probiert und es ging einfach nicht.

Und er meinte so, ja yes, jetzt geht

es endlich, jetzt kann man das auch mit Klammern

machen, das ist viel besser, voll gut.

Obwohl das wahrscheinlich nie irgendjemand verwenden

wird wahrscheinlich, aber

ja, also

aber das

was jetzt oft erzählt wird

ist halt irgendwie, dass man damit besser

neue Sprachfeatures umsetzen kann oder so, das ist eigentlich

nicht unbedingt der Fall, es ist halt nur so, dass es jetzt konsistenter

ist, dass der Faser automatisch generiert

wird und

ja

Ja, nee, also

er braucht

sogar mehr RAM. Ja, genau, also das

war der Grund, warum man das früher nicht gemacht hat,

weil man muss jetzt alle Tokens im Hauptspeicher

halten und das war halt früher ein Problem.

Heute nicht mehr so.

Also genau, er braucht einfach

mehr Rahmen. Irgendwer hatte

auch was erzählt von, dass sie jetzt per

Default sagen, also mehr als eine Million Zeilen

in einer passenden

Datei wollen sie jetzt bitte nicht mehr sehen.

Ja.

Oh Mist, was war ich denn jetzt?

Ja genau, da habe ich

eine ganze Firma drauf aufgebaut.

Ja,

also von der Performance her

ist kein großer Unterschied, sowohl von der Laufzeit

und Hauptspeicher braucht es ein bisschen mehr.

Aber genau, das ist das tolle Ding, was man

eventuell jetzt damit machen kann.

Was sonst sehr

schwer geworden wäre, ist

da gibt es auch ein PEP jetzt,

weiß ich nicht welche Nummer, Pattern Matching.

Bin mal

gespannt, ob das angenommen wird

für Python 3.10.

Dass man halt so

Lisp-Style-Makros hat, beziehungsweise

in funktionalen Programmiersprachen ist das schon länger

oder das ist halt ja so eins der grundlegenden

Geschichten.

ja, in Python ging das halt auch

vor allen Dingen wegen dem Parser bisher

nicht. Und das

geht dann eventuell. Und wenn man das darin hat, ist es natürlich

schon nett. Da hat man so eines der zentralen Features

von funktionalen Programmiersprachen auch mit drin.

Was sind denn Lisp-like-Makro?

Ja, das müssen wir

mal irgendwann machen, wenn wir irgendwie auch so ein bisschen

so, ja, noch mal funktionalen Programmiersprachen

und was ist Pattern-Matching und was sind Makros?

Da können wir das nochmal. Aber ich glaube, das ist einfach

Okay, das verschiebe ich auf eine folgende Folge.

Für die Leute, die gucken wollen,

wäre es 6-3-4.

Ah, 6-3-4, ja.

Das ist auch eins, wo Guido jetzt selber

wieder, Guido hat ja beim Parser natürlich

mit drin gesteckt

und das ist jetzt auch anscheinend

eins seiner Themen, wo er dran steckt.

Ja.

Ja, also auf jeden Fall, das klingt irgendwie

sehr vielversprechend und ich bin mal gespannt, was dabei so rauskommt.

Ja, ein Bug ist auch schon aufgefallen

wohl. Achso, Match war,

achso, ja, vielleicht tatsächlich

das ist

eine bessere Variante

dessen, was sonst in anderen Sprachen das Case

gewesen wäre.

Nur mal so als

zur groben Einordnung. Also mit

dem Match geht es dann am Ende

tatsächlich darum, die, wenn man sehr

komplexe If-Else

Zweige hat,

dann kann man die damit ein bisschen hübscher abbilden.

Also substanziell

hübscher.

Warum hat man das nicht Case genannt?

Das müsste ich jetzt nachlesen.

Also es macht schon, glaube ich, noch ein bisschen mehr.

Also ich meine, ja, naja.

Ach, keine Ahnung.

Genau, einen Bug gab es auch schon.

Da wird jetzt dann wahrscheinlich in 3.9.1 gefixt.

Und zwar, was der alte Parser konnte

und was jetzt halt mit dem neuen nicht mehr geht,

ist, wenn man Tuple Unpacking,

halt auch so Stern irgendwas in WIS,

so Context Manager verwendet,

dann funktioniert das nicht.

Tja, aber es ist halt bisher niemandem aufgefallen,

also so häufig scheint es nicht verwendet zu werden,

aber das klappt schon irgendwie nicht.

Achso, das ist auch vielleicht ganz interessant,

also in 3.9 sind beide Parser drin,

man kann auch irgendwie per Kommando zahlen,

Optionen sagen, Minus X irgendwas, Old Parser oder so,

verwendet doch bitte den alten,

wenn man irgendwie mit dem neuen Probleme hat.

Der neue ist defaultmäßig aktiv

und der alte ist aber halt noch drin

und mit Python 3.10 wird es dann halt so sein,

dann wird der alte Parser komplett rausfliegen

und nur noch der neue drin sein.

Was mit Tablet-Uppacking in Context-Managern,

das habe ich jetzt nicht so ganz verstanden.

Warum geht das nicht oder ging das vorher auch nicht?

Doch, das ging vorher schon, das hat bloß keiner gemacht.

Warum auch, aber jetzt geht es nicht mehr.

Also warum will er das denn nicht machen?

Na ja, also warum, also das ist halt, niemand versteht dann, was du tun willst wahrscheinlich.

Ich überlege gerade, wie die genaue Syntax ist, was da kaputt geht.

Hast du den Bug irgendwo da?

Na ja, Moment, da müsste ich auch gerade suchen.

Ich versuche so leise wie möglich zu tippen.

Ja.

Also ich kann mir schon vorstellen, warum nicht im Contact-Manager

einfach irgendeinen Tuple anpacken, das ist doch durchaus okay.

Nee, nee, die Frage

meinst du wahrscheinlich oben in der With-Expression.

Ja, ja, in der Expression selber.

Also With und dann irgendwas mit Tuple-Unpacking machen.

Also ich sehe da echt keinen Anwendungsfall

für. Und es ist, glaube ich, also die haben da ja

die komplette Standard-Bibliothek durchgejagt und noch viele

PyPI-Pakete und sie haben es

nicht, also das ist nie aufgetreten.

Also das ist nicht so, dass das irgendwie dauernd gemacht

wurde, sondern das hat bisher wohl noch nie jemand

gemacht. Quasi. Also jedenfalls

nicht ein Code, der irgendwie häufiger

verwendet worden wäre.

Also, ja.

Es war nur, das ist halt schon mal aufgefallen,

dass da ein Unterschied zwischen den beiden Paaren gab.

Ja.

Tja, was haben wir denn noch so?

Oh, na hier.

Also, was ich wirklich hübsch fand, war

jetzt irgendwie nochmal explizit

die String, Prefix,

Suffix-Removals.

Weil das ist einfach, das war

seit langen Jahren

ist ja, es gibt einen L-Strip und einen R-Strip

und da

fallen Leute ja gern drauf rein.

Dass Leute gerne irgendwie sagen

L-Strip oder

Strip und dann irgendwie

eine Zeichenkette und sie denken

damit wird irgendwie, also

wenn ich sage Strip,

ABC, also möchte ich

immer, wenn ABC ganz links steht, das

weggestrichen haben, aber das

macht es ja nicht, sondern das macht ja

Streich von links

so lange alles weg,

wie das, was links ein A, ein B

oder ein C ist.

Das heißt, da kommen ganz lustige Dinge dann manchmal raus.

Und

jetzt gibt es halt ein explizites

Remove Prefix, Remove Suffix und dann

wäre das auch geklärt.

Ja.

Das ist schon hilfreich.

Ja, ansonsten

Zeitzonenhandling

ist jetzt irgendwie mit drin.

Das habe ich noch nicht angeguckt,

ich bin seit irgendwie 15 Jahren

mit PyTZ unterwegs

und PyTZ hat halt den Vorteil,

das ist unabhängig, das ist halt so ein Ding,

die Zeitzonen-Datenbanken werden halt ständig

aktualisiert und geändert

und ich bin mir gerade nicht sicher,

haben die

da irgendwie die Datenbanken mit dabei

oder ist das nur eine API?

Genau, das ist halt auch der Grund, warum

im DateTime-Standard-Modul

in der Standardbibliothek

waren diese Zeitzonen-Datenbanken

auch nie drin, wohl aber eine API dafür,

wie man da seine eigene Datenbank oder sein

eigenes Objekt, das halt implementiert,

das halt so ein Objekt irgendwie

reintun kann, weil sich die Leute gesagt haben, ah,

Python-Release-Zyklus, viel zu lang für diese Updates

und dann wollen die Leute das mal selber machen

und dann haben es die Leute natürlich nicht selber gemacht,

weil keiner Bock hatte, das zu

machen und ja,

nee, wie es jetzt wohl ist, ist, dass

Ach, ja, die nehmen

die System-Time so, weil sie haben eine

API dafür, um das reinzuziehen.

Ja, und genau, auf Windows

gibt es noch eine komische Geschichte,

da gibt es dann ein

First-Party-Package, was man dann noch installieren

muss, TZ-Data oder sowas.

Dann

geht das da wohl irgendwie auch.

Aber

genau, so ist das dann. Ja, das ist so als

Fallback gedacht, für wenn das andere nicht da ist.

Und die intern

funktioniert das wohl

mehr oder weniger genauso wie

DateUtil oder sagen wir so, das ist auch

also wie

DateUtil das macht, also

ich glaube, das ist auch von dem Autor von

von DateUtil irgendwie

meine ich jedenfalls

gehört zu haben, dass der das von dem

das ist und es implementiert halt so die

Kerngeschichten, aber viele von den fancy Features

von DateUtil sind halt nicht drin, aber

so die Kerndinge.

Ja.

Noch was?

Noch irgendwas?

Naja gut, da gab es noch irgendwas mit Dekoratoren

und Syntax, dass man da konnte man

früher immer nur, bis jetzt halt

immer nur Funktionen verwenden und jetzt kann man

halt auch irgendwie ein Dikt nehmen

und dann eckige Klammern oder so, das ging vorher

auch nicht so richtig. Und das geht

jetzt. Ah, das wird wahrscheinlich auch kaum jemand

machen insofern.

Ja, obwohl, da kann ich mir jetzt KMR vorstellen noch.

Ja, dass man halt, man könnte sich vorstellen,

man hatte irgendwie ein Dikt von Dekoratoren oder so,

wo die Values halt irgendwie Funktionen

sind und dann wählt man halt das Ding

aus, was man halt, und da hätte

man halt bisher immer irgendwie eine

Extra-Funktion haben müssen, die dann halt

die richtige Funktion auswählt

und jetzt geht es halt direkt.

Ja, auch nicht so schlecht.

Es ist ja eine Frage von

in solchen Momenten immer bei diesen

syntaktischen Kleinheiten

dann kann man ja immer dieses

berühmte Dokument des

PHP, a fractal of bad design

rausholen,

dass du dich halt irgendwie

darauf verlassen können möchtest, wenn

gesagt wird, okay, hier hinter dem Ad

kommt halt eine Expression,

dann kann ich hier auch bitte alles

machen, was eine Expression halt kann.

Und wenn das halt nicht geht,

dann steht man immer traurig da und fragt sich, was soll

denn der Quatsch eigentlich?

Insofern, ich finde das einfach,

das ist halt so das Thema, wenn das auch gerade was ist, was der

neue Parser vielleicht besser unterstützt,

dann all for it.

Was ist

a PAPEffect of Bad Design?

Also, um nicht auf

anderen

Sprachen rumzuhauen.

Gibt es aber ein

wirklich berühmtes Dokument

zum Thema, warum PHP

so ein massives Problem im Sprachdesign

hat. Und da gibt es

in dieser Blogpost, der ist jetzt auch

bestimmt schon 10 Jahre alt oder so.

2012.

8 Jahre.

Und da geht es

sozusagen darum, dass diese Herangehensweise

des Sprachdesigns, und da ist

Python ja schon lange ein Vorreiter gewesen, dass es halt

eine explizite Sprachdefinition

gibt, aus der dann halt das C-Python

nur, in Anführungszeichen,

die eine Implementation ist, und es

ist klar, es kann auch andere Implementationen

geben, und

ich erinnere mich

an mindestens ein Thema,

wo allein von

dieser syntaktischen Genauigkeit

tatsächlich irgendwie,

ich glaube, war das

das Type-of-Äquivalent

bei PHP oder so, war so

im Parser integriert, dass tatsächlich

die Aussage war, diese eine Funktion kann

immer nur exakt mit einem variablen Namen

aufgerufen werden, aber niemals

jemals mit einer

Expression, wo du dann von dem Ergebnis

den Typen haben

möchtest. Weil halt

jemand das in den Parser so reingestrickt hat.

Und dieser Artikel geht das sozusagen

in arg detaillierter

Form durch und nimmt da irgendwie

tausend von den Sachen auseinander und sagt halt hier

was willst du jetzt noch sagen, wenn du irgendwie

nur noch von einem zum anderen stolperst

dabei?

Ja, der ist mal ganz interessant zu lesen,

wird zum Thema irgendwie

ein bisschen analytisch auseinandergenommen,

was das liebe PHP

da so ein bisschen auf die schiefe Bahn

geraten lässt.

Ja, müssen wir mal in die Shownotes packen.

Ja.

Ja, mit den iii.ii

oder sowas.

Ja, aber

ich glaube, das war es dann auch schon

mehr oder weniger, ne?

Ich glaube, sonst war da eigentlich nichts drin.

Ja, ich glaube, irgendwie noch was zu Typins oder sowas, aber

Oh ja, stimmt, man kann jetzt irgendwie

List, man muss nicht mehr

diese List mit Großbuchstaben vom

Typing importieren. Wahrscheinlich

war das halt auch so gedacht, ja, wer

weiß, wie lange, ob die Leute das gut finden mit

dem Typing, Typins und so.

Nehmen wir mal nicht

irgendwie, machen wir nicht den Aufwand, das

direkt so zu ändern. Und jetzt kann man,

muss man das halt nicht mehr aus Typing

irgendwie

Listen mit großem L importieren, sondern kann halt

die Build-ins verwenden und das

funktioniert dann halt auch in den Type-ins.

Genau, das ist ganz

nett. Das macht es ein bisschen

einfacher, das zu schreiben und man muss nicht immer nachgucken, welche

Imports das jetzt waren.

Ja,

was steht an Veranstaltungen an?

Habt ihr irgendwelche? Oh, hab ich jetzt

dummerweise gar nicht so richtig nachgeschaut.

Die DjangoCon ist gerade vorbei.

Ja, gab es eigentlich die Python auf jetzt?

Oder waren die

War die PyCon dieses Jahr virtuell?

Ich weiß gar nicht. Welche meinst du?

Die deutsche? Ja, die D.

Ne, die haben wir tatsächlich

verschoben. Also wir hatten

relativ zeitig im Jahr mit den, also es

wäre jetzt wieder in Berlin gewesen.

Genau, letzte Woche war es gewesen eigentlich.

Genau, und wir haben aber relativ

frühzeitig mit dem

Veranstaltungsort, wie wir haben gewesen, im

Haus des, nicht Haus des Lehrers

hier daneben an.

Ja.

in Berlin, genau

ach, wie heißt denn das noch, da wo immer

der CCC-Kongress war, da wo immer der Kongress

war, genau, dieses UFO

ja, da wären

wir gewesen eigentlich und

wir haben mit denen dann halt, das war halt so ein bisschen

schwierig, weil im Januar

ja wirklich, im Februar

März war das, März, März

nicht klar war, wie wird denn das

jetzt sich über das Jahr eigentlich entwickeln

und tatsächlich, jetzt sehen wir ja gerade auch

dass die Zahlen schon wieder schwierig sind

und Massenveranstaltungen sind ja eh

abgesagt bis mindestens Ende

2020 und wir hätten gerechnet,

also in einem regulären Jahr

wäre unsere Hochrechnung

glaube ich bei knapp 2000 Leuten gewesen

und das kannst du halt

gerade knicken, das geht gar nicht.

Und gleichzeitig war halt auch schon

eine Anzahlung geleistet gewesen,

deswegen mussten wir mit denen entsprechend verhandeln

und jetzt ist die Aussage, wir probieren es 2021

und 2022, also wir haben uns committet

2021 und 2022 nochmal in Berlin zu machen

und haben uns gedacht, na gut,

um dann halt sozusagen die

Anzahlung zu retten.

Dadurch dürfen wir die für das nächste Jahr mit

verrechnen und haben jetzt auch

garantierte Preise

für 2021 und 2022

schon rausgehandelt. Die haben ja auch das Problem.

Auf der einen Seite müssen sie irgendwie sehen, wo sie bleiben

und auf der anderen Seite wollen sich natürlich auch nicht alle

Leute verbrennen, die eigentlich jetzt

regelmäßig Veranstaltungen mit ihnen machen.

Ich bin ein bisschen froh, dass wir halt jetzt

planmäßig schon für Berlin geplant

hatten und nicht für

Hinterpose Muckel, um

dann sagen zu müssen, so auf die nächsten

x Jahre müssen wir nach Hinterpolse muckeln,

ansonsten

sind wir pleite,

wären wir nicht pleite, aber

ansonsten müssten wir da

irgendwie Dutzende, Zehntausend Euro

vergraben.

Ja, nee, genau,

das wäre es gewesen, das haben wir verschoben.

Was tatsächlich im November noch ist,

vielleicht für alle, die auch im Peißenverband

schon Mitglied sind, ist

Mitgliederversammlung tatsächlich.

Das hatten wir auch ursprünglich geplant,

die jetzt, weil es ja eigentlich ganz gut aussah, im Oktober

mit vor Ort

hier in Halle zu machen, aber

sind gerade dabei.

Ich glaube, morgen wird das beschlossen

und dann wird das wahrscheinlich auch eine digitale

Veranstaltung werden,

im November. Da gehen demnächst

noch Einladungen raus, wer beim

Python-Verband Mitglied werden will.

Stimmt, kann ich das gerne noch machen.

Ja, dafür muss er tatsächlich noch mal kurz Werbung machen.

Die Webseite kurz nennen

und... Genau, das wäre der

python-verband.org

der Python Software Verband

als die deutsche Interessensvorredung

und eine unserer

Hauptaktionen, und das war diesmal jetzt leider

dann auch ein bisschen

wenig durch Corona,

ist, dass wir alle möglichen

Community-Aktionen fördern.

Sowohl organisatorisch

als auch mit Geld. Das heißt, wir

verstehen uns da ein bisschen

als eine Drehscheibe.

Python selber ist ja gut bekannt, aber

was wir stark unterstützen wollen,

ist halt, Python

noch in Communities zu tragen, die es vielleicht

nicht so kennen und aber auch Veranstaltungen

zu fördern. Das heißt, man kann da auf der Webseite

unser Förderprogramm nachschlagen

und dann kann man sich relativ

unkompliziert Geld für Ideen abholen,

die man mal mit, wie man Python an andere

Leute ranbringen will, mal was coden möchte,

etc., etc.

Genau. Okay, interessant. Und

im Corona-Jahr war es jetzt auch so, dass wir tatsächlich

ein, zwei schon länger

bekannte Partner,

da gibt es die TechKids zum Beispiel

im Schwäbischen, die haben

jetzt auch ganz schön drunter gelitten, weil denen die ganzen Veranstaltungen

weggebrochen sind, mit denen sie normalerweise

dann ja auch wieder so Teilnahmegebühren reinholen

und haben da jetzt dieses Jahr

im Fördertopf tatsächlich dann auch eher mal

großzügig gesagt, okay, wir sponsoren euch jetzt auch mal,

wenn gerade nichts los ist, damit

das jetzt hier über die Corona-Zeit

nicht alles zerbricht, einfach,

was die Leute aufgebaut haben.

Ja. Ja. Das ist tatsächlich

vielerorts ein größeres Problem, ja.

Ja.

Tja, ja.

Also es ist dann demnächst Weihnachten. Ich habe heute die

erste Weihnachtswärmung gekriegt.

Ja, tatsächlich. Weihnachtswünsche.

Ja,

geht schnell vorbei

mit so einer Pandemie, ja.

So oder so.

Ja, also genau, ich weiß nur,

Juro Python war jetzt auch

vor kurzem. Die Vorträge sind

irgendwie da und Django Con,

das wollte ich mir auf jeden Fall angucken, aber habe ich

noch bisher nicht geschafft. Gibt es auch die ganzen

Vorträge online.

Und was jetzt in Zukunft kommt, weiß ich gar nicht.

weil ich es nicht nachgeguckt habe.

Ja, wir verpassen übrigens gerade wieder das Django-Meetup

Cologne, ne? Ja, ich weiß, aber das ist halt

dann blöd, muss man...

Ja, die Froscon war auch noch, das ist jetzt auch

so fünf, sechs Wochen her, glaube ich.

Da hat es ein bisschen gedauert, die haben jetzt auch erst vor, glaube ich, zwei, drei

Wochen dann die Videos

online gehabt, genau.

Ja, und es gibt, glaube ich, noch wieder

so eine neue Anmeldung für das nächste Jahr, ne?

Die 21, die auch online statt

sein wird, äh, Forstdem, diesmal, ja.

Forstdem, achso, das ist dann Februar, Januar, Februar

irgendwann die Forstdem, genau.

Nee, ich meinte die Frostcon.

Genau, die ist normalerweise

St. Augustin. Genau, ja.

Damals, ja.

Ja, ansonsten, was mir noch so

eingefallen ist, was jetzt geht, was

früher nicht ging,

Icehorde und Black sind kompatibel.

Ja, das

ist auch nett.

Wie kam es?

Ich weiß es nicht genau,

also

mit irgendeinem Update

von Icehorde ist das jetzt

sozusagen erledigt dann irgendwie gewesen.

Also iSort hat was gemacht, damit Black

nicht mehr dazwischen punkt.

Ja, irgendwie so, genau.

Und ja, jetzt geht es halt, man kann es

halt parallel, also man kann halt beides

verwenden und

hat dann da kein, nicht mehr so, dass das eine

immer die Sachen vom anderen umsortiert, was ja irgendwie ein bisschen doof ist.

Jetzt müsste man das nur noch in PyProjectHummel

konfigurierbar machen, genau wie PyTest und

Lake8 und dann...

PyTest ist das?

Ist das schon? Ja, aber

mit so einem komischen

Ja gut, der Key ist so ein bisschen komisch.

Genau, PyTest, INI-Options

oder so so ein Quatsch.

Wobei ich sagen muss, wir haben jetzt

tatsächlich Black an ein paar Stellen wieder zurückgebaut

und ich breche

noch eine Lanze für alle Leute, die sozusagen

neben schwarz noch ein bisschen grau haben wollen.

Ja.

Und empfehle mal noch ins Japf reinzuschauen.

Japf, okay.

Ja, Black wird auch

ein Problem kriegen, Black Fernandes

auch den alten Parser

und

spätestens ab Python 3.10 wird es dann halt

muss er sich

was einfallen lassen, weil das geht dann nicht mehr.

Naja.

Kannst du kurz was zu JAPF noch

sagen? Ja, JAPF

ist so ein, wie auch, wir waren ja vorhin schon

beim JAK,

der Yet Another Compiler Compiler und

JAPF ist der Yet Another Python Formatter

und die haben

sich tatsächlich eher auf die Fahnen geschrieben, dass das

Ding ein bisschen konfigurierbarer

ist. Auch mit einer Jap Ignore, ich hab's grad

gesehen.

Und der erzeugt

für mich, find ich, deutlich

lesbareren Code. Also das ist

die, ich komm persönlich mit

der Black-Formatierung an

vielen Stellen so richtig gar nicht klar

und find sie einfach

urpot hässlich.

Ich fand sie auch sehr ugly, aber Jochen hat's mir immer aufgezogen.

Ja, sorry.

Also ich unterstütze

volle Kanne das Thema,

einen Auto-Formatter einzusetzen.

Ähm, aber ich finde

Black ist halt nicht der weiße letzter Schluss

Ja, das mag, also ich

verstehe das durchaus, ich finde auch, ich habe so ein bisschen

Schwierigkeiten mit den Anführungszeichen

Ich habe auch vorher immer Single-Codes verwendet

Das ist schon so ein bisschen

Auf der anderen Seite würde ich sagen, naja gut

Also, äh

Selbst wenn man es nicht so hübsch empfindet

Äh, wenn alle den gleichen

Auto-Format verwenden, ist das

ein so viel größerer Gewinn, als

dass ich dann sage, nur gut, dann

gebe ich dafür die persönlichen Präferenzen auf

Aber ja, ich kann auch verstehen, dass man das, ja.

Weil mein Streit sozusagen schon über das, was ich als persönliche Präferenz empfinde, rausgeht, weil es verletzt mein ästhetisches Gefühl so, dass ich wirklich daneben stehe und sage, nee, das ist volle Kanne gegen die Designziele von Python als Sprache.

Ja, also das ganze Thema, dass die Indentation mir Dinge sagt und dann irgendwie über x Dutzend Zeilen hinweg wieder schließende Klammerorgien zu sehen, dafür brauche ich kein Python, also dann brauche ich kein Python, dann kann ich JavaScript schreiben.

Ja, naja.

Und sie wollen, also ich verstehe ja, warum das passiert, sie versuchen ja eine Formatierung zu machen, die möglichst wenig Diff erzeugt, wobei ich das bisher auch nicht gesehen habe, dass das wirklich, also da hätte ich gerne mal tatsächlich noch eine Metrik gesehen und ich muss aber sagen, das verletzt dann so ganz klassische Clean-Code-Aspekte auch von Code optisch ist zum Lesen für Menschen da und wenn das Ding halt tatsächlich erfordert,

dass meine Kognition massiv mehr Aufwand leisten muss, um es zu lesen.

Und alle Leute dann mehr oder weniger mit einem Stockholm-Syndrom ankommen

und sagen, ja, ich habe mich daran gewöhnt.

Dann erinnert mich das so ein bisschen eher wie an die alten Leute,

die ich hatte, als ich ein Haus gekauft habe und die Flugzeuge drüber fliegen

und die sagen, ich höre die schon alle nicht mehr.

Ja, so fühlt sich das für mich jetzt halt an.

Und wir haben jetzt tatsächlich in einem Projekt,

in einem größeren Projekt, das eben nochmal umgestellt von Black

auf einen anderen Formatter.

Auf Japf.

auf JAPF halt mit entsprechenden

anderen Optionen und

siehe da, plötzlich hat man wieder so ein

Ah, stimmt, so muss das aussehen. Danke, das ist Python.

Kannst du dafür mal

die Config irgendwie

teilen mit uns in den Show Notes?

Na klar. Das wäre super, weil das

finde ich sehr spannend. Weil ich finde Black auch

mega ultra hässlich und genau das, was du

sagtest, also ein paar Sachen, wo ich dachte so, ah, wieso

macht das so? Das ist auch eklig.

Ja, na ja, gut.

Ja, so, na ja.

Ist schon was dran.

dazu fällt mir gerade noch ein, ich habe letztens

einen Podcast gehört, also ich höre den

ab und zu,

gefällt mir eigentlich, also mir gefallen ja auch so Formate,

die so ultra lang sind und das ist halt auch

so immer schön lang,

der heißt irgendwie Lex Friedman

und der spricht so mit allen möglichen Leuten

und halt darunter sind halt

auch viele der so Korrifäen.

Zum Beispiel hatte er letztens

ein Interview mit

James Gosling,

zu dem

ja quasi Entwickler

von Java

und das fand ich

ganz interessant

und der erzählte dann halt

auch so, ja, also

was ihn dann dazu gebracht hat, Java

sich auszudenken, war halt

ja, seine lange Erfahrung mit C

auch sowas, was ich nicht wusste, der hat

Emacs irgendwie geschrieben

in C, oder die erste ordentliche Version

von Emacs und stand

dann irgendwann vor der Entscheidung, okay, ich mache jetzt entweder

den Rest meines Lebens Emacs

oder halt nochmal was anderes und dann dachte ich so

naja, Emacs, so geil ist es dann, also weiß nicht,

muss auch nicht sein.

Dann hat er lieber was anderes gemacht und das abgegeben irgendwie.

Also Emacs und Java sind eng

verwandt, interessant.

Naja, also, ja.

In gewisser Weise.

Aber er hat halt auf jeden Fall sehr, sehr viel C geschrieben.

Die ungleichen Zwillinge.

Und dann auch größeren Projekten

und dann sind ihm halt so Dinge aufgefallen,

die immer wieder schief gehen in C und dann

Java war halt sozusagen der Ansatz. Also mit diesen

großen Fehlerklassen, die halt

C immer wieder ganz böse Probleme

machen, halt aufzuräumen und

das ist ja auch dann irgendwie gelungen.

Aber der sagte dann etwas,

als es darum ging,

wie das dann so ästhetisch aussieht,

daher die

Anknüpfung

sozusagen weiter so, ja, also

wenn ich irgendwie Code lese, es gibt ja mal so Leute,

die sagen dann so, oh, ich finde das ästhetisch ist aber

nicht so, gefällt mir nicht so

richtig. Und dann so, mir war das immer alles total

egal. Ich habe da nie

den Code gesehen. Wenn ich irgendwie so

eine Funktion angucke, dann sehe ich immer nur so

dann habe ich da so eine visuelle, so eine

Bildvorstellung von, so wie so Zahnräder

von einer Maschine und dann sehe ich, ob das das Richtige

tut oder nicht. Und wie die Syntax

von der Sprache ist und wie die Sprache aussieht,

das sehe ich gar nicht und das ist mir auch total egal.

Jetzt wissen wir, was uns da war. Und dann dachte ich so,

okay, ja, das erklärt natürlich einiges.

Aber

das ist aber halt, da ist er halt noch

auch schwierigen Positionen, weil er hat den Quatsch halt erfunden

und

mir geht es halt auch so, wenn ich irgendwelche

Tools baue und erfinde,

dann sehe ich da, wenn jemand die Tools verwendet, halt auch mit einem Schlag die Zahnräder.

Das ist aber halt kognitiv ein völlig anderer Prozess, als wenn ich das halt nicht erfunden habe

und ich das verarbeiten muss, was da steht.

Und das ist sozusagen, und da gibt es, jetzt habe ich halt im Studium auch Linguistik gemacht

und deswegen bin ich an der Stelle auch immer ein bisschen mit dran zu gucken,

wie hängt das zusammen und unser Gehirn, kognitive Last ist halt was,

das zwingt uns irgendwann halt dann nicht mehr über die Sache nachzudenken,

sondern das Gehirn ist dann halt nur noch damit beschäftigt,

dieses komplizierte Zeug zu lesen.

Deswegen hast du halt sowas wie Brainfuck.

Da bleibt dann halt nicht mehr viel über für

was macht der Code eigentlich?

Buchstabensalat.

Das ist halt schon eine echte Balance.

Ja, oder

vielleicht sind unterschiedliche Leute da halt auch einfach

unterschiedlich. Vielleicht gibt es Leute, denen

ist das halt egal. Die sehen halt, wie

die Mechanik dahinter

direkt aussieht und können

sozusagen an dem Code vorbeigucken, aber mir geht

das auch nicht so. Also wenn ich

bin sehr an der ästhetischen...

Wenn man die ästhetischen Patterns direkt

sehen kann und die einem klar ins Auge springen.

Ja, du willst

ein anderes Thema einleiten.

Ich habe gerade versucht, einen kleinen Übergang

zu finden.

Ich weiß nicht, ob es mir geglückt ist. Wie geschickt.

Ja, aber es war wirklich so.

Wenn man das sehen kann, dann kann man doch auch diese

Patterns auch mit einer gewissen Ästhetik betrachten.

Und deswegen ist vielleicht

diese Ästhetik der Sprache

für manche wichtiger,

vielleicht für einige unermichtiger, aber ich finde, das ist ein sehr essentieller Teil.

Also gerade, weil auch die Hürde dadurch deutlich gesenkt wird.

Selbst wenn es jetzt ein sehr hochentwickeltes Feature ist,

ermöglicht es halt auch einen deutlich einfacheren Einstieg,

weil durch diese ästhetische Klarheit man das Konzept auch deutlich einfacher verstehen kann.

Man kann ja auch tatsächlich Ästhetik mal zur Seite legen und an der Stelle einfach,

also es gibt ja mehrere andere Kriterien, die man ansetzen könnte,

eben zum Thema Lesbarkeit, Menge der Zeichen auf dem Bildschirm,

Menge an Noise, an syntaktischem Drumherum und so.

Und es gibt auch bestimmte Sprachen, bei denen ich halt sage,

da ist es mir wieder zu wenig.

Also Python ist halt tatsächlich für mich so die Sweet-Spot-Sprache.

Da ist mein Gehirn super drauf angesprungen damals und extrem gut drin.

Mit Ruby tue ich mich zum Beispiel extrem schwer.

Ruby hat halt dieses Thema, dass sie sehr viel metasyntaktisch arbeiten.

Und das heißt aber, du musst teilweise schon überlegen,

meint, hier ist ein Leerzeichen,

deswegen bedeutet jetzt gerade hmm, und wenn das

dahinter eine Funktion ist, dann

da musst du schon auch

in diesen Mustern ganz schön

arg drin stecken, um das halt wirklich lesen

zu können. Und ich habe bei Python halt immer

das Gefühl, egal wie es

geschrieben ist, irgendwie kriege ich

es dann schon auch wieder relativ schnell auseinander

klamüsert. Aber ich

merke auch, oh, jetzt ist es auf eine Art

geschrieben, die ist irgendwie von dort durch die Brust

ins Auge und war

irgendwie nicht zum Lesen gedacht.

Ja, man muss ja schon irgendwie

Methode relativ schnell begreifen können irgendwie,

das ist zumindest ein Ziel, wenn man das so

vernünftig machen möchte.

Naja, es ist halt so, ich glaube auch da

wieder, dass halt für unterschiedliche Leute

vielleicht da unterschiedliche

Trade-Offs besser funktionieren oder

schlechter und irgendwie

so die, wie sieht das aus oder wie kann man,

wie schreibt man Dinge dran, ist halt irgendwie so das

User-Interface der Sprache,

was ich auch letztens noch gehört habe,

was ich ganz interessanten Ansatz fand,

dass es ja auch noch andere Aspekte gibt.

Also genau, das war auch in einem Interview-Podcast

mit, glaube ich, Chris Lettner,

der Swift und Clang und so gebaut hat.

Und das hatte ich vorher noch nicht so richtig auf dem Schirm,

weil ich dachte immer so,

ja gut, was halt dann an Code dasteht,

ist halt das Entscheidende.

Und der meinte dann halt auch so,

ja, also User-Interface der Sprache sehr wichtig

und Python voll gut.

Wusste ich auch gar nicht, dass er da so meinte,

das ist total super.

Das Problem ist nur, es gibt halt auch noch

andere Dinge,

die halt auch eventuell wichtig sind, wie zum Beispiel

so etwas wie, wie gut ist das denn jetzt nicht,

wenn ich da drin irgendwas

programmieren will, was dann irgendwie mein Problem löst,

sondern wie ist das eigentlich,

wenn ich jetzt ein Framework da drin entwickeln will,

oder irgendeine Library,

ist das denn dann immer noch gut, weil

bei Python hat man dann zum Beispiel

das Problem, okay,

wenn das jetzt irgendwas ist, was

CPU-bound ist,

sozusagen, dann hat man

wahrscheinlich, wenn man jetzt irgendwie so ein Basis

zum Beispiel sowas wie ein Machine Learning Framework oder so

bastelt, dann

kommt man da nicht aus ohne relativ

große Anteile C, C++, irgendwie

sowas. Und

dann wiederum hat man das Problem,

dass das User Interface sozusagen

von dem Use Case ausgesehen halt

nicht mehr so schön ist, weil jetzt kann man nicht mehr richtig

debuggen, weil man hat halt ein Teil

in C und ein Teil

in Python und

ja, was macht man jetzt, wenn irgendwie

und wenn

da irgendwo Fehler auftreten, gibt's

keine konsistente Art mehr, das so richtig zu

debuggen.

Und das ist natürlich schon so ein Punkt.

Oder was er auch meinte, ist dann halt so was

wie, ja, also

was ist eigentlich, kann ich so was

wie ein Int-Typ

überhaupt irgendwie selber basteln?

Das geht ja jetzt in Python nicht, geht

auch in Java nicht. Aber in

Swift ging das natürlich, deswegen Swift, voll gut.

Da könnte man halt, kann man solche Typen halt

tatsächlich bis ganz runter selber

sozusagen als Library-Autor

halt auch haben und

selber definieren.

Und natürlich, also in gewisser Weise

da ist schon das auch ein Punkt dabei.

Und das ist natürlich in Python vielleicht jetzt nicht

so einfach wie in anderen Sprachen.

Also ja,

aber

zum Lösen von Problemen

finde ich das auch, das ist halt irgendwie

schon sehr, sehr angenehm im Vergleich zu allem anderen.

Aber kann auch sein, dass ich da einfach nur

komisch bin und das halt für mich funktioniert.

Und die Interviewreihe, die du da gerade aufgemacht hast, die kann ich auch allgemein empfehlen. Da hatte ich letztens nämlich jemanden, wie hieß der noch mal, wie hieß der Interviewer?

Lex Friedman.

Lex Friedman, genau.

Und da hatten wir diesen einen Chip-Designer.

Der ist auch extrem spannend, den sich anzunehmen.

Das ist gerade so ein thematischer Querschlag.

Aber ich glaube, die muss ich einfach mal loswerden,

weil der hat mich dermaßen begeistert.

Wie hieß er denn?

Lex Friedman mit...

Der hat zu viele Sachen gemacht.

Oh ja.

Der macht eine ganze Menge, ja.

Ah, genau.

Wo ist er, wo ist er, wo ist er?

Chipdesigner, Chipdesigner, Chipdesigner.

Namen sind Schall und Rauch.

Ja, manchmal macht er auch so ein bisschen komisch.

Also manchmal ist mir das auch...

Ich weiß nicht, es gibt ja so eine...

Also ich würde das mal...

Also wenn man das so...

Wenn man versteht...

Also es ist halt auch sehr amerikanisch, muss man sagen.

Und manchmal macht er auch einfach so

etwas seltsame Dinge, irgendwie so

sagt er, dass er jetzt nur noch Fleisch isst

oder keine Ahnung oder macht ganz viel mit

Cryptocurrency-Zeugs, was ja auch irgendwie

so ein bisschen ist, aber

ja, aber es sind auch auf jeden Fall

super interessante Sachen dabei.

Genau, also hier Lex Friedman Nummer 70,

Jim Keller. Ah, okay,

gut. Jim Keller

ist tatsächlich einer, der

also ich habe da gleich

nach 10 Minuten so ein bisschen so einen Man-Crush entwickelt.

Der ist so

intense,

wie der da sitzt

und denkt und redet und

sein Minenspiel eigentlich gar nicht so richtig

präsent ist so richtig. Und dann doch so

ganz kleine Nuancen und

haut da Sachen raus zum Thema

Chip-Design. Und der ist halt sozusagen

in den 80ern

ins Chip-Design eingestiegen

und hat so alles mitgemacht.

Der hat halt bei AMD und bei Apple und bei

Tesla und bei Intel gearbeitet.

Und ich habe jetzt so ein bisschen so persönlich

so diese, dieses Gefühl

von, ah, dieser

Kampf zwischen AMD und Intel,

der wird eigentlich nicht irgendwie da weit

oben ausgetragen, sondern die Frage ist nur,

ob Jim gerade bei AMD oder bei Intel ist.

Die Folge heißt übrigens

Moore's Law, wenn ich das so sagen würde.

Ja, genau.

Also der war, der ist schon krass.

Der war richtig gut.

Ja, der Podcast kann man

tatsächlich empfehlen. Es gibt auch andere tolle Folgen,

die man hören kann, mit Donald Knoos oder

Paul Krugman sogar mal dabei gewesen

und und und. Es lohnt sich, die auch

auf YouTube zu gucken. Es gibt Videos davon mit

den Interviews, nicht nur als Podcast.

Und da ist,

ja, die Mimik ist

Peter Norweg.

Ja, ja.

Wenn man mal so durchscrollt.

Ja, genau.

Wo waren wir denn jetzt?

Wir waren eigentlich bei Petra Kohl

gemacht.

Ja, genau.

Ja, und

irgendwie gewisserweise,

da, genau, da, da

auch zu Patterns hatte

Dirk Fresslater noch was zu sagen und da meinte er dann so,

ja, also Patterns sind ja auch immer so,

es wird halt gesagt,

wenn man Patterns braucht, dann hat

die Sprache eventuell, ja,

einfach nicht genug, also hat,

was ist das eigentlich?

Das ist ein Zeichen dafür, dass die Sprache

halt etwas nicht kann, was sie vielleicht können sollte, ne,

und deswegen muss man halt einen Pattern machen

und das kenne ich auch schon

lange und er

fügte halt dann noch was hinzu, was mir dann

Und ich dachte so, oh ja, das stimmt, das ist ja auch eigentlich so ein Punkt, das ist nicht nur bei Patterns so, sondern halt auch bei sowas wie, gibt es eigentlich sowas wie eine Standardbibliothek und das ist halt immer, das ist ein ähnlicher Trade-off.

Also wenn du jetzt eben wie bei Python eine relativ große Standardbibliothek hast, dann hat das natürlich eventuell den Vorteil, dass du dir so etwas erspaarst wie JavaScript, ja, die haben das da halt nicht und dann kriegst du halt NPM.

Und das ist halt sozusagen

ein Pattern, um halt

diese fehlende Standardbibliothek

irgendwie dann aufzufangen,

sozusagen außerhalb von

dem, was die Sprache tatsächlich macht.

Und das ist halt so ein bisschen fies

dann unter Umständen. Auf der anderen

Seite ist es natürlich auch so, dass es wieder

ein Vorteil sein kann, weil wenn man jetzt

irgendwie sich TypeScript anguckt oder so,

wenn sich so ein

Typesystem halt außerhalb

der Sprache entwickeln kann, kannst du das natürlich deutlich

schneller tun, als wenn das immer nur

alle 18 Monate oder jetzt alle 12 Monate

updatbar ist.

Mit dem Release-Zyklus der Sprache.

Also es ist nicht so einfach.

Und mit Patterns ist es halt irgendwie

ähnlich.

Wenn eine Sprache halt sehr, sehr viel kann, dann

braucht man eigentlich nicht so viele Patterns, weil

dann hat man einfach diese Probleme nicht.

Und auf der anderen Seite, wenn

ja,

gibt es einen Nachteil, wenn eine Sprache zu viele Features hat.

Naja gut, dann ist man halt auch an die

Sprache sehr gebunden.

Naja, eigentlich hat das keinen Nachteil.

Also Patterns, ich glaube Patterns ist sozusagen

Das war gerade

aufgekommen, da war ich glaube ich im Studium.

Ich weiß nicht, wann das

Buch rauskam. Ich glaube 1994

war es. Wenn man das typatisch jetzt wüsste,

dann war ich da nicht im Studium.

Oh, Tatsache.

94. Ne, da war ich

bei weitem noch nicht im Studium.

Oh.

Ja, Tatsache, 94.

Und

wir hatten ja vorhin schon mal kurz angerissen,

dass das in C++

Ja, also du wolltest über das Buch

reden, ging auch vor, Design Patterns.

Ging auch vor, Design Patterns, genau. Das ist

wenn man diesen Begriff Patterns in die Hand nimmt,

ist das in der IT sozusagen das, wo

es alles mit

angefangen hatte. Und

vielleicht kann man da noch kurz

den

einen Umweg gehen zu

Name, wie hieß er,

Steve Alexander?

Nee.

Alexander war Alexander...

Christopher Alexander.

Christopher Alexander war das, genau.

Er war ein Architekt.

Und der hatte dieses Thema Patternsprachen halt mal aufgegriffen

und beziehungsweise entwickelt,

um sich städtebaulich so einem Gesamtkunstwerk anzunähern.

Um halt auf der einen Seite zu sagen,

okay, Patterns sind Dinge, die immer wieder auftauchen,

die halt in leichten Variationen anwendbar sein müssen.

Und es ging ja nicht darum, dass Patterns,

es sind ja Patterns und nicht Templates.

Also was ist das denn?

Ist das sowas wie ein Mosaik-Baustein-Ding,

das man irgendwo reinstecken kann

und dann in alle Richtungen funktioniert?

Nee, eigentlich nicht.

Eigentlich ist es halt tatsächlich ein Entwurfsmuster,

wo du mehrere Dinge genannt bekommst drumherum.

Also die haben da ein gewisses formales Schema aufgebaut.

Es ist ein Name und Klassifikation und Zweck und Synonyme und Motivation.

Und aber was eben tatsächlich interessant ist, sind halt dann immer Hinweise zur Anwendbarkeit,

Hinweise zu einer allgemeinen Oberflächenstruktur,

Akteure, das ist jetzt sehr C++ nah, dann schon so Klassen, die daran beteiligt sind,

aber auch das Zusammenspiel davon und eine Abwägung von Konsequenzen mit Vor- und Nachteilen,

Implementierungen und Beispielcode häufig.

Und da geht es halt darum, dass man für einen bestimmten Fall, wenn man merkt,

ich schreibe jetzt hier Code, der hat so ein ähnlicher Einsatz wie von diesem Muster

und dann liefert dir das Muster zumindest schon mal einen Design-Input von,

also wenn du jetzt sowas in dieser Art machst, dann solltest du auf x, y, z achten

und dann hängt da noch das und das und das dran.

Und es ging nicht darum, sozusagen ein fertiges Stück Code,

was man nur noch copy-pasted irgendwo reinzusetzen,

sondern zu sagen, na guck mal, es gibt zum Beispiel,

wenn du das Problem hast, dass du Code dynamisiert auswählen können möchtest,

dann ist zum Beispiel das Strategy-Pattern eine mögliche Variante, das zu tun.

Das sieht dann so und so und so aus

und da muss man auf das und das und das aufpassen

und den Rest baust du dir jetzt selber zusammen.

Ja, das ist ein bisschen wie, wenn ich sage, ich setze mich hin und schneide mir ein Kleid, dann habe ich da Entwurfsmuster, aber ich muss natürlich trotzdem noch messen, ob mein Bauch ein bisschen dicker ist, meine Beine ein bisschen länger und muss das dann halt anpassen.

Und da ging es tatsächlich dann darum, und das ist auch das, was der Christopher Alexander an der Stelle wollte, er wollte ja damit Leuten eine Auswahl von Mustern an die Hand geben, wo die Muster auch ineinander greifen und zusammenspielen.

Also das ist ja auch ein Thema, dass das nicht irgendwie eine wahllose Menge von Patterns ist,

wo man sagt, die lerne ich jetzt auswendig und dann nehme ich einmal das und einmal das und einmal das,

sondern das soll eine Sprache ergeben, wo man dann anhand von diesem Zusammenspiel,

von den Verknüpfungen zwischen den Teilen dann immer weiß,

ah, wenn ich hier drüben das mache und da das mache, dann sollte ich wahrscheinlich hier drüben gleich mal aufpassen,

dass ich nicht noch x, y, z versaue.

Und diese Sprache, da geht es ein bisschen um Kräfteverhältnisse zwischen den Dingen,

aber eben auch immer dieses, man muss es sich selber zurechtschneiden für den eigenen Anwendungsfall.

Ansonsten hätte man das ja auch in der Library kippen können.

Das hätte man sagen können, das ist jetzt der einmal fertige Code.

Und der Trick ist aber, das Muster auf einer Ebene greifen, wo ich nicht vorher sagen kann,

ah, da braucht man eine Funktion für oder da braucht man dieses Ding oder eine Klasse oder sowas,

sondern es ist häufig auch ein, ja, wenn du folgende sieben Zeilen dreimal geschrieben hast,

dann solltest du mal darüber nachdenken, ob du das vielleicht anders anordnen möchtest.

Aber das ist jetzt ja vielleicht noch mal

interessant für alle unsere Hörer, weil wir haben jetzt ja

abstrakt vielleicht irgendwie da

mit angefangen, was so Patterns

vielleicht so

konzeptuell sein sollten und

vielleicht gehen wir noch so ein bisschen in die konkretere Implementierung,

was es denn so gibt

an Sprachpatterns überhaupt und

dass wir vielleicht die mal erklären und

ein bisschen

versuchen, wie man das in Python vielleicht macht,

wenn man

das macht, wenn man die überhaupt braucht.

Also,

Ja, genau. Also ich meine, die Muster, die sind ja sozusagen allgemeingültig. Das sind ja tatsächlich sehr abstrakte Ideen, die da existieren.

Fangen wir vielleicht mal mit der Antwort an. Hast du eben irgendwie Strategie gesagt?

Ja, ich würde woanders anfangen. Ich würde beim Singleton anfangen.

Ja, okay. Fangen wir beim Singleton an. Was ist denn Singleton?

Die mäßige, schöne Übersetzung ist das Einzelstück. Ich mag es einfach nicht, wenn.

Es gibt ja so ein paar Kategorien, also der Singleton gehört zu den Mustern aus dem Bereich

Creational Patterns, also wie werden in einer objektorientierten Sprache Objekte erzeugt.

Da gibt es so verschiedene Muster und es gibt manchmal den Effekt und gerade in Java ist

das halt noch ein stärkerer Fall, dass ja alles muss eine Klasse sein und manchmal brauchst

aber Code, wo das Objekt

nur ein einziges, wo es nur ein einziges

Objekt zu geben darf.

Ja. Und

dieses Objekt soll aber auch gut

zugänglich sein. Und

das kann zum Beispiel sowas sein wie

das Objekt

in Python ist, es gibt ein

Python-Analogum dazu tatsächlich sogar.

Das ist nämlich das Objekt, was

den Logger in dieser Anwendung

zum Beispiel repräsentiert.

Davon will es nicht, will sie fünf

Logger haben nachher, sondern du willst halt

irgendwie, wo ist denn hier die Log-Konfiguration,

mit dem Ding möchte ich jetzt reden, da soll jetzt

bitte Log-Output rausgehen.

Und

da gibt es dann halt

entsprechende Muster, wo man sagen kann, okay,

wenn irgendwer die Klasse in die Hand kriegt und die

nochmal neu instanziiert, dann dreht die sich um

und gibt einfach statt

ein neues Objekt zu machen,

dir das eine erzeugte Objekt

schon wieder zurück.

Und dieses konkrete Singleton

lässt sich aus Java

so auf Python, du kannst es glaube ich

codemäßig sogar

so

bauen, das hat aber nicht

die gleichen Eigenschaften, weil die Sprache ja eine andere ist

und in Python gibt es

dafür halt andere Möglichkeiten sowas zu machen

dass du zum Beispiel sagst, du hast einen Namespace

bei dir

in deiner Anwendung, ein Modul, das heißt dann

Log, Tipp, man sollte es nicht

Logging nennen, das geht gerne schief

wenn man die Standardbibliothek startiert

das heißt

vielleicht Log und da drinnen

gibt es eine Klasse, das ist dann dein

Logger und nach der

Definition der Klasse würdest du gleich

dieses Objekt instanziieren und wenn du

willst, löschst du danach

diese Klasse einfach aus dem

Namespace von dem Modul wieder raus.

Dann kann auch

keiner aus Versehen so eine

zweite Instanz machen und dann

muss man wieder dazu sagen, naja, Python als Sprache

für Erwachsene, das stimmt halt so auch nicht, weil wenn du

die Klasse aus dem Modul dann löschst,

dann ist der Name zwar nicht mehr ansprechbar,

aber du kannst natürlich auf diesem Singleton-Objekt

wieder nach under, under class fragen.

Dann hast du das Klassenobjekt,

dann kannst du da wieder eine neue Instanz von machen.

So, jetzt kannst du halt hergehen

und kannst, wenn du willst, in Python sagen,

also der, jetzt muss ich selber überlegen,

welche Doppel-Underscore-Methode da die richtige war.

Nicht init, sondern was?

Create?

New, genau.

Ich habe es zu lange nicht mehr in der Hand gehabt.

Ich merke, ich mache in letzter Zeit

zu wenig Metaprogrammierung in Python.

Du könntest aber under under new nehmen und könntest dort sowas machen wie, wenn es auf dem Klassenobjekt schon ein bestimmtes Attribut gibt, nämlich die Instanz selber von dem Objekt, was du mit der Klasse erzeugt hast, dann liefer einfach das zurück und ansonsten mach einmal ein neues und ansonsten nie wieder.

Solche Meta-Aktionen kann man damit machen.

Die Frage ist nur immer,

wie gesagt, was hat das Pattern für einen Kontext?

Und es gab eine ganze Zeit lang,

und das wurde so ein bisschen diesen Java-Programmierer-Schmieden,

die halt so viele Leute, wie möglich,

die Java programmieren können sollten,

rausgespuckt hatten, so Ende der 90er und Anfang der Nullerjahre.

Die sind immer rausgekommen mit,

ich kann die Patterns, ich muss alles in Patterns denken.

Und das ist aber in der Informatikausbildung selber ein Pattern, was immer wieder kommt, dass die Leute irgendwie Werkzeuge in die Hand gedrückt kriegen und dann denken, ich muss alles mit diesen Werkzeugen ausdrücken.

Und eigentlich ist es aber umgekehrt. Eigentlich ist es halt, du schreibst halt Code und wenn du die Patterns kennst, dann merkst du vor deinem Auge plötzlich, ich baue hier etwas auf, das riecht wie so ein Singleton.

Dann sollte ich mir jetzt nochmal kurz Gedanken machen, was wir alles wissen über diese Form von Pattern und ob ich jetzt bestimmte Dinge von Fehlerbehandlung, von bestimmten Edge Cases etc. nicht einfach alle gleich glatt ziehe, weil ich weiß, wenn ich das jetzt so und so mache, dann habe ich das hier alles handwerklich ordentlich gemacht.

Und es ist aber ein Bottom-Up-Approach und gelehrt wird das Ganze häufig halt als Top-Down-Approach, im Sinne von, du baust deine Anwendung nur noch aus Dingen zusammen, die diese Patterns sind. Und das ist halt Quatsch. Du baust halt die Anwendung erstmal, wie du die willst und wenn du feststellst, ah, du hast hier ständig irgendwie Dinge, die eigentlich nach diesen Patterns riechen und dafür ist es dann wichtig, dafür muss man sie halt kennen, dann kannst du es damit leichter und schneller strukturieren und musst das Rad nicht jedes Mal neu erfinden.

Ja, genau. Ich würde auch sagen, eben genau diese Creational Patterns, das ist halt so ein, es gibt irgendwie drei Teile, Creational, Structural und Behavioral oder sowas, glaube ich.

würde ich sagen, ist auch

schon eine der Hauptpunkte, dass es halt

irgendwie fehlende Sprachfeatures

so ein bisschen relevant, weil

tatsächlich

braucht man diese Patterns vor allen Dingen

in Sprachen, wo halt

das syntaktisch einen Unterschied

macht. Also wenn ich halt zum Beispiel in C++

oder auch in Java

oder selbst in JavaScript, wenn ich da new sage,

um ein neues Objekt

irgendwie zu erzeugen,

dann

habe ich halt das Problem, dass das, also

in Python ist es halt, ist ja

sozusagen neues Objekt erzeugen gar

nicht syntaktisch zu unterscheiden von einem Funktionsaufruf.

Das sieht halt einfach genauso auf.

Und ich kann ja irgendwas zurückgeben. Also ich

muss ja jetzt, wenn ich ein neues Objekt erzeuge,

nicht irgendwie irgendwas new sagen, sondern

ich rufe halt eine Funktion auf und dann

habe ich halt ein neues Objekt. Aber die könnte da halt

auch was ganz anderes machen. Auch ein

Objekt von einer anderen

Klasse zurückgeben oder so. Das geht

halt in C++ nicht. Wenn ich da sage

new irgendwie diese Klasse, dann kriege ich halt

ein Objekt von dieser Klasse. Also muss ich mir, wenn

dann was anderes dabei rauskommen soll, halt überlegen,

wie gehe ich denn jetzt damit um? Und dann wird es halt,

kriege ich halt irgendwie If-Else-Kaskaden

in irgendwie Konstruktoren und dann irgendwann denke ich mir

so, hm, das sieht aber hässlich aus, was meine ich denn jetzt?

Und dann brauche ich halt Patterns.

Und das

hat man in Python so, eigentlich

würde ich sagen, so viele der braucht man so nicht. Also es gibt

vielleicht, ich würde sagen, Ausnahme ist vielleicht das Bilder-Pattern,

das man halt auch in Python vielleicht ganz gut

verwenden kann.

Dann bitte noch mal erklären, was ist das für ein Bilder-Pattern?

Also das Builder-Pattern

ist halt sozusagen, wenn man jetzt nicht nur

ein Objekt bauen möchte, sondern halt

eine ganze Menge von Objekten,

dann

wird das halt unter Umständen unübersichtlich.

Wenn ich das jetzt irgendwie,

muss ich halt einen Konstruktor machen, der irgendwie

riesig wird und ganz viele Argumente übergeben oder so,

das ist halt eventuell nicht so schön.

Ein gutes Beispiel dafür ist halt

LXML hat da so ein Ding,

wie man sozusagen XML-Dokumente zusammenbauen kann.

Das ist halt quasi Bilder-Pattern, kann man sagen.

Also wenn man sich das mal angucken will,

da gibt es dann halt für jedes Tag gibt es halt ein Objekt

und dann kann man das halt ineinander schachteln

und dann sieht das quasi syntaktisch so ein bisschen aus,

als würde man XML zusammenbauen

und hat dann aber tatsächlich eigentlich quasi

halt eine Reihe von Objekten zusammengebastelt.

Meistens reicht es aber,

also das, wofür dann das Bilder-Pattern verwendet wird,

in anderen Sprachen, in Python reicht es dann

meistens irgendwie einfach eine neue

Klassenmethode an ein Objekt ranzumachen, die halt dann

irgendwie Sachen zusammenbaut.

Das geht halt. Anderswo geht das

halt nicht so gut. Da muss man halt

das ein bisschen komplizierter machen. Aber es gibt

auch in Python Fälle, wo man das

Pattern tatsächlich braucht.

Und es ist halt schön, das Pattern zu kennen, auch wenn es

halt nicht primär um komplizierte Syntax geht.

Hat das was mit Factory

zu tun, weil das Builder-Pattern heißt?

Ja, also Factory-Pattern würde ich sagen, braucht man

fast nicht. Das ist genau so etwas,

das ist, da das irgendwie

da Funktionen

First Class Dinger sind in Python,

gibt es eigentlich gar keine.

Was ist denn das Factory Python? Fangen wir wieder so an, wir wollen ja auch ein bisschen

erklären.

Ich weiß gar nicht, ob ich das genau

gut erklärt kriege.

Äh,

guckt irgendwas aus, wird

irgendwas fabriziert auf eine ähnliche Art und Weise,

irgendwas generiert,

was ähnliche Eigenschaften besitzt, ich weiß nicht.

Nee, es geht eigentlich

eher darum, dass du deine Objekt

Konstruktionen konfigurierbar

machen möchtest. Dass du nicht

sagen möchtest, also du hast halt nicht irgendwie einen Hammer

und ich hätte was jetzt irgendwie

New Hammer, sondern du hättest gerne

jetzt einen sehr speziellen Hammer mit einem

möglichen, keine Ahnung,

so ein Stil, der so und so lang ist und

keine Ahnung,

der soll so und so schwer sein und weiß ich nicht.

Und ja,

jetzt ist halt

die Frage, wie konfiguriert es zu

dieses Ding halt und wo man in Python halt eine Funktion

verwenden würde, musst du halt in

anderen Sprachen jetzt anfangen,

sozusagen da Objekte ineinander zu

stapseln.

Und ja, aber ich kriege es jetzt auch,

weiß ich nicht genau, ob ich das so super erklärt kriege.

Ich habe mir das auch schon lange nicht mehr angeguckt.

Ja, man muss an der Stelle halt auch

es geht wieder

um Syntax halt auch an der Stelle.

Das eine ist, du benutzt

halt plötzlich keinen New Operator mehr an der