Ja, hallo und herzlich willkommen beim Peißen-Podcast. Heute Episode 40, Jochen, wir haben Jubiläum.
Oh ja, herzlich willkommen Dominik. Ja, 40.
40, kann nicht so schlecht, ne?
Das ist ja schon viel älter, als wir sind.
Ja, fast.
Ja, zumindest teilweise.
Ja, noch.
So, was wollen wir heute machen? Wir haben ja erst überlegt, ob wir irgendwas über Ensebill erzählen wollen,
Aber das müssen wir wann anders, glaube ich, nachholen, weil wir niemanden gefunden haben, der sich mit Ensebel so richtig gut auskennt, den wir ja gerne als Gast gehabt hätten.
Wenn ihr also von Ensebel Ahnung habt und was erzählen wollt, dann sagt uns doch einfach mal Bescheid.
Das gilt auch übrigens für alles andere Feedback, was ihr uns schicken wollt an hallo.heißenpodcast.de.
Genau, wenn ihr ein Thema habt, über das ihr gerne mal gesprochen haben wollen würdet, dann könnt ihr das auch gerne selber mit uns tun oder jemanden nennen, die wir mal fragen sollen.
Wir haben zwar noch viele schöne Themen auf unserer Liste
und so, aber wir lassen uns auch immer gerne bereichern
mit neuen tollen Themen. Da müssen wir vielleicht nachher nochmal
drüber reden, welche Themen das denn sind, damit Leute dann auch
eine Chance haben, irgendwie zu sagen, ob sie jemanden kennen.
Die können ja einfach ihr Thema bringen, auf das sie besonders Lust haben.
Okay, dann sagen wir das jetzt zuerst, wo noch
so viele Leute dazuhören, dass sie das mal machen sollen.
Ja, es gibt ja so eine Burnrate.
Genau, und dann am Schluss ist ja keiner mehr übrig.
Ja, aber was machen wir denn dann heute?
Wir wollten einfach so ein bisschen mal wieder kunterbunt
durcheinander reden,
Zeugs besprechen. Eben so Metageschichten vielleicht
tatsächlich mal wieder. Das haben wir jetzt auch schon länger nicht mehr gemacht.
so eben, über was man mal reden könnte
oder ja, was wir
so tun. Ja, so richtig Meta,
ja, Meta über was, ja, über Podcast
ist es nicht, Meta über Python ist es nicht mehr.
Ich glaube, es ist eigentlich so Web-Dev-Meta, oder?
Also was man so alles benutzen kann an Tools
oder so. Ja, ich meine, wir machen
ja relativ viel Web-Entwicklung, oder ich
mache gerade relativ viel Web-Entwicklung
seit einer ganzen Zeit.
Ich weiß auch nicht, warum das so ist, weil ich
mache ja eigentlich auch viel Maschinenleutent-Kram und so,
oder habe auch mal viel gemacht, aber in letzter Zeit
ist es irgendwie mehr Web-Entwicklung, obwohl das
andere Dinge ja auch gerade so halbt. Ich weiß nicht,
woran das liegt. Ich muss halt vielleicht einfach mehr Machine Learning
wieder machen. Ich wollte gerade sagen, einfach den Job wechseln,
Jochen. Ja, das kann natürlich auch sein.
Ja, gut.
Vielleicht Webentwicklung
ist eigentlich so ein bisschen
Convenience-Software-Entwicklung.
Das kann man mal so ein bisschen
dazwischen schieben, mal Teilzeit, ist nicht so schlimm.
Also Machine Learning auf Blockchain
oder so. Oh mein Gott.
Ja, das ist jetzt nur,
das weiß ich jetzt nicht. Duo in Finale.
Ob ich das machen möchte? Nee, eher nicht.
Aber genau, vielleicht fangen wir einfach mit News an.
Ja, mit News wie immer, oder?
Okay, warte mal, die Kapitelmarke News.
Dafür musst du dich jetzt aber ziemlich strecken.
Ja.
Das müssen wir noch optimieren.
Das muss ich, der Raum ist noch nicht ganz optimal, das stimmt.
Okay, also wir haben gerade ein Kapitelmarke.
Ich sehe schon, dass die Kapitelmarke irgendwie am Anfang jetzt sitzt
und nicht da, wo ich sie eigentlich haben wollte.
Irgendwie funktioniert das alles noch nicht so richtig.
Ja, ihr merkt, heute wird eher eine Laberfolge.
Ah, was ist denn da schon wieder kaputt?
Okay, ich stelle jetzt hier mal das Ding
in Ultraschall auf.
Wir benutzen übrigens Ultraschall zum Aufnehmen.
Ultraschall 5.
Sehr gut.
Ein Plugin auf Reaper.
Ja, genau.
Wie produziert man Podcasts?
Das haben wir noch gar nicht.
Haben wir das schon mal gesagt, wie man Podcasts produziert?
Oder wie wir unseren produzieren vielleicht?
Also Kurzversion ist tatsächlich,
wir nehmen das auf mit diesem Plugin für Reaper.
Reaper ist eine Software, die
eigentlich kostenlos.
Nein, nein, nein.
Ich habe auch bezahlt.
In der Evaluation-Version gibt es.
Also erstmal zum Ausprobieren kostenlos, ich wollte jetzt sagen.
Und dann gibt es halt dann dieses Plugin Ultraschall
für Podcasts, was echt cool ist.
Und danach machen wir noch so
Post-Production mit
Aufphonic. Ja, und Shownotes schreiben
und so, das machen wir auch so. Leider nicht automatisch,
sondern muss man überall aufwarten.
Tja, aber Shownotes kann man ja
einigermaßen gebrauchen, dann kann man doch mal nachschauen,
was wir für einen Quatsch irgendwann mal erzählt haben.
Vielleicht ist da ein bisschen Schumanns drin, wenn das
dann jemand aufgeschrieben hat.
Genau. So, jetzt kann ich auch die
News-Kapitelmarke nochmal verschieben.
Ich kann kein schlechtes Gewissen haben.
Jetzt haben wir aber auch wirklich ein bisschen Meta über Podcasts.
Das ist doch schon mal etwas. Du wolltest bestimmt auch mal über andere Podcasts
gleich erzählen.
Ja, aber vielleicht erstmal News.
Na gut.
Was gibt es denn Neues?
Also ganz schick.
Task Groups gibt es jetzt.
Es ist gerade gemerged worden für Python 3.11.
Okay, was ist
Taskgroups? Fangen wir vielleicht erstmal damit an.
Naja, also sagen wir so, es gibt
ja irgendwie bei, also es gibt
eine Schwachstelle bei Python
Async-Geschichten,
die halt da schon oft
irgendwie
ja, Leute
ein bisschen depressiv gemacht hat
oder keine Ahnung, oder geagert hat.
Ich weiß nicht genau, wie man das am besten
also zum Beispiel
Trio ist eine Bibliothek, die sich halt
mit diesen ganzen Problemen beschäftigt. Es ist halt auch
schwierig.
Nathaniel Smith hat die geschrieben.
Es gibt ja diverse Implementationen
von diesem Async. Ich habe jetzt ganz viel gehört, aber ich habe
immer noch nicht genau verstanden, was denn das Problem
dabei ist und warum. Also das Problem ist halt
also, sagen wir mal
so, wir
befinden uns, was diese Async-Geschichten angeht,
ja so ein bisschen in einem ähnlichen
Stadium wie, als man
irgendwann mal angeführt hat, strukturierte Programmierung
zu verwenden, anstelle von
Gotoh oder so.
Das ist jetzt ein bisschen abstrakt.
Es ist so, als wäre jetzt nebenläufig ein Feind gedankenlos gelaufen,
der aber nicht mit dem anderen wieder zusammengekommen ist,
weil ich den nicht einsammeln konnte.
Ja, aber genau.
Also nachdem man strukturierte Programmierung,
also mit Funktionen und so oder Prozeduren irgendwie eingeführt hatte,
da muss man auch erst mal sich umgewöhnen oder so,
weil man das bisher immer anders gemacht hat.
Also man strukturierte Programmierung bedeutet,
man schreibt nicht von oben nach unten irgendwas durch
und sagt dann, okay, gehe wieder zu dieser Zeile
und mach da irgendwie weiter.
Sondern man trennt das in logische Blöcke,
die man aufrufen kann.
Die halt, wo man am Anfang weiß, was da reinkommt
und am Schluss weiß, was da wieder zurückgeht.
Und sozusagen, damit man das halt nur noch ...
Nennt man das eine Clojure?
Nö.
Clojure ist eine innere Funktion,
die halt Zugriff auf etwas hat, was ...
Ja, also du kannst zum Beispiel,
wenn du eine Funktion in einer Funktion hast
und du gibst jetzt sozusagen die innere Funktion zurück,
dann hat die ja noch Zugriff auf den Scope
der Funktion, aus der sie rauskommt.
Und da kannst du jetzt Sachen drin definieren.
Also zum Beispiel Closures ist halt
das allgemeine Prinzip hinter, wie man
Dekoratoren in Python dann implementiert.
Also Dekoratoren machen das.
Die rappen sozusagen die Funktion,
die man dekoriert, in eine innere Funktion rein.
Jetzt bin ich mir gerade nicht ganz sicher, ob wir die
Menschen, die uns zuhören, jetzt nochmal abhören dabei.
Falls die Dekorators sind. Oder ob die das alle schon wissen.
Dann können wir mal eine Episode dazu machen.
Dekoratoren, super Sache.
Eigentlich schon, ne? Ja, okay, dann machen wir eine eigene Episode dazu.
Haben wir schon mal wieder eine.
Man rappt dann quasi
die Funktion und dann da dir aufgerufen wird
und das Funktionsobjekt da durch die Gegend gereicht
wird, muss man da halt Objekte oder Dinge
reingeben können, rausgeben können und kann halt vorher
und nachher Sachen machen.
Oder da irgendwelchen Kontext setzen, genau.
Und ja,
also
das ist nochmal was Komplizierteres, aber
also Funktionen sind ja eigentlich relativ einfach, aber
trotzdem, wenn man das halt nicht gewohnt ist, dann muss man das umstellen
und es ist die Frage, wie arbeitet man damit, was macht man
jetzt eigentlich in einem Fehlerfall und so und all diese
Probleme haben wir jetzt nochmal so ein bisschen, weil
wir jetzt uns irgendwie überlegen müssen, okay,
wenn wir jetzt Async-Sachen machen, wie machen wir das
dann richtig? Und
zum Beispiel ein Problem, was jetzt halt den Leuten
öfter mal auf den Fuß gefallen ist, vor allen Dingen
die Bibliotheken entwickeln, als Endanwender
oder Endbenutzer
von diesen Geschichten, hat man das
eigentlich gar nicht so oft, aber
kann man sich ungefähr verdeutlichen. Also wenn man
jetzt zum Beispiel, man hat halt so ein,
also was man mit Async-IO oft macht, ist
sowas wie, zum Beispiel, also im einfachsten Fall
man hat eine Liste von URLs, die man abfragen möchte
und dann sagt man halt irgendwie
Gather
den ganzen Kram und kriegt
dann halt das alles zurück.
Was passiert denn? Was macht denn das Gather
jetzt genau?
Das wartet, bis sie alle einmal durch sind.
Alle awaiten. Gather macht await eins
nach dem anderen und zwar in der Reihenfolge, wie die in der Liste drinstehen.
Oder das letzte.
Reihenfolge gibt es so ja nicht mehr.
Naja, aber die laufen ja nebenläufig
und eins ist ja zuerst fertig.
Ja. Und eins zuletzt fertig.
Und Gather wartet, bis alle fertig sind.
Genau.
das
sozusagen, also man muss es halt noch
erwarten, aber das wartet, bis halt
alle fertig sind. Und die Ergebnisse sammelt das
auch oder gibt es da Ergebnisse?
Ja, also
man kann da durchaus auch, wenn
da halt Ergebnisse zurückkommen, jetzt weiß ich jetzt nicht genau was
mit all den Dingern, wenn da jetzt unterschiedlich, also normalerweise
hast du eine Liste von Sachen, wo das ist das gleiche, wo
Liste von Responses oder so zurückkommt, dann kriegst du halt die Liste
von Responses
dann halt zurück, denke ich.
Wenn das jetzt unterschiedliche Sachen
sein sollten, weiß ich gar nicht so genau.
Weil ich jetzt gar nicht so
sicher, was dann passiert.
Aber wahrscheinlich kriegst du halt eine
Liste, der
wie auch immer die Struktur dann
aussieht, keine Ahnung.
Aber das Problem ist halt eben,
und das, was halt nicht so gut geht, wenn du jetzt
sagst async-io-gether und jetzt
passieren aber mehrere Dinge.
Jetzt hast du zum Beispiel einmal einen Connection-Error
irgendwie, wenn du eine URL
holst, und bei einem anderen Ding hast du
aber irgendwie einen, weiß ich
not authorized und bei einem anderen
hast du irgendwie
Authentication Error oder was auch immer.
Du hast halt so unterschiedliche
Fehlertypen.
Du kannst jetzt aber, im Interpreter
kann immer nur eine Exception
weiterreichen. Was passiert denn jetzt?
Du kriegst die aber zu unterschiedlichen Zeitpunkten.
Wenn du jetzt das try irgendwas
gather, was
passiert denn jetzt, wenn du Accept sagst?
Ja, dann sollte die Exception, die zuerst
rausfliegt, rausfliegen. Aber eigentlich sollte man die ja vorher
auch catchen, oder? Also innerhalb des
Dekor-Routines und nicht...
Ja, willst du ja aber auch nicht. Also du willst ja die
Exception an der Stelle fangen, wo du irgendwas mit der machen kannst.
Das hängt halt davon ab natürlich,
aber es ist halt so die Frage, wenn du die Frage
gefangen hast, okay gut, dann kriegst du sie ja auch nicht mehr.
Aber wenn du jetzt mehrere
Exceptions hast, die halt da
auftreten, was passiert denn dann? Und ja,
die Antwort momentan ist halt irgendwie
doof, weil
es gibt
da sowas wie Chained Exceptions, das sieht man
manchmal auch gerade bei so Web-Frameworks häufiger
irgendwie, dass halt irgendwas eine Exception wirft
und dann dir sagt, ah,
also das ist passiert, also
oder in Tests passiert es auch häufig,
während ich versucht habe, diese Exception zu werfen,
ist halt das passiert oder keine Ahnung,
also sowas geht
auch, aber das
bildet das halt auch nicht ab, was du dann eigentlich
können müsstest, wenn jetzt irgendwie mehrere
unterschiedliche Exceptions halt
aufgetreten sind oder ein ganzer Baum, also
im allgemeinen Fall ein ganzer Grafbaum
von Exceptions, die halt irgendwie
so, das geht irgendwie nicht. Das kann auch tatsächlich
der Interpreter nicht.
Und ja, das ist halt ein Problem.
Und dafür gab es ein
654
Exception Groups and Accept.
Und da der Code dafür
ist jetzt irgendwie
vor Woche oder so
oder ein paar Tagen
gemerged worden und alle so
und das kommt in 3.11 und das bedeutet
halt, dass man jetzt quasi damit sauber umgehen kann.
Also Trio habe ich deswegen angesprochen, weil
das war halt so ein Ding,
damit umzugehen. Also der nannte
seinen Ansatz da auch irgendwie
Structured Concurrency
und der hatte dieses Konzept von Nurseries,
die man da benutzen kann, um halt damit
dann sauber umzugehen. Das hat in der Asienfolge, glaube ich,
schon mal erwähnt. Das hat in der Asienfolge und
ich weiß nicht, ob wir das wirklich, also
ich glaube, das hat damals schon niemandem so wirklich
ehrlich gesagt und
wahrscheinlich ist das jetzt auch nicht anders. Aber
ich finde es interessant und
also es ist
aber auch ein kompliziertes Thema und
naja, also
sagen wir so, die Kurzfassung ist, es geht jetzt
alles, also ab 3.11 wird es deutlich besser, es gibt da
diverse Leute, zum Beispiel auch der Juri
Selivanov,
der mit
HQL und HDB,
der hat auf Twitter relativ
enthusiastisch gesagt, so 3.11, das ist voll gut,
dass das jetzt drin ist, wir haben schon seit Jahren
Probleme damit und jetzt
ist es endlich sauber gelöst und damit ist
quasi, Python hat jetzt irgendwie
sehr gute Unterstützung im Vergleich zu
allen anderen Sprachen eigentlich.
Spielt da jetzt ganz vorne mit.
Und juhu!
Also das kann man
auf jeden Fall schon mal erwähnen, dass das irgendwie ziemlich cool
werden wird.
Jetzt muss ich nur noch verstehen, wie man halt so eine
Exception Group,
was das halt...
Ja, da musst du dir den Pepp angucken, da steht das drin,
wie man dann damit umgeht,
dass da jetzt so ein... Du kannst halt auch, ich glaube,
man kann das ganz normal...
Einmal noch mal kurz, wir haben jetzt relativ viel,
also ich habe
zwei verschiedene Exceptions, wir fangen mal mit zwei an,
die gleichzeitig auftreten. Also einmal, keine Ahnung,
Autorisierung verweigert und einmal Connection abgebrochen.
In zwei verschiedenen Threads.
Was machen die?
Muss ja nicht Thread sein.
Aber ist auch egal.
Die haben auf dieselbe API oder auf eine andere API zugerufen,
ist auch egal. Also Hauptsache, die schmeißen beide irgendwie Exceptions.
Aber der
Zeitpunkt ist egal
oder nicht egal, wenn das auftreten ist.
Naja, das kannst du jetzt nach einem Zeitpunkt
ordnen, du kannst es aber auch irgendwie anders ordnen, je nachdem
wie du willst. Also du hast halt eine Exception-Group und
darunter hast du jetzt dann halt unterschiedliche
Exceptions. Und dann
hast du halt quasi einen Baum. Also eine Exception-Group
kann halt wieder unterschiedliche
Exception-Groups drunter haben, die dann
wieder Exceptions drunter haben. Das ist halt ein Baum
von... Und wofür brauche ich das?
Naja, also wie gesagt, als
Endanwender hat man da den Fall, dass man das wirklich braucht,
gar nicht so häufig. Aber wenn du jetzt halt irgendwie so eine
High-Performance-Datenbank-Library
irgendwie Dings-Geschichte baust,
sowas wie zum Beispiel Async-PG oder so,
dann kann das durchaus passieren,
dass du halt in solche Sachen reinläufst,
wo du dann gerne irgendwie was gut,
wo du zum Beispiel einfach noch einen ordentlichen Traceback
werfen wollen würdest,
wo man sehen kann, was passiert ist.
Weil wenn du das auf 1 runterdampfen musst
und dann rausschmeißen und sagst Datenbank-Error,
sagen wir mal, es gibt eine Zahl zurück, Datenbank-Fehler,
dann ist das nicht sehr hilfreich.
Du musst halt, aber
alle Sachen kannst du nicht angeben, weil du kriegst ja,
du hast nur eine Exception. Also weil die erste,
die quasi dann geraced wird, dann
die rausfliegt und die anderen gehen dann unter.
Das wäre das Problem sonst. Genau, ja.
Ja, okay. Und ich will halt quasi, dass die durchgereicht
werden. Du willst die irgendwie
behandeln können. Ob du sie jetzt rausprintest
oder irgendwie darauf reagierst oder so, ist ja nochmal eine andere
Sache, aber du kannst sie jetzt handeln.
Also so wäre, das wäre quasi so, als müsste
ich so eine Art Exception-Cache
bauen und dann irgendwann
alle Exceptions in diesem Exception-Cache
zurückgeben, anstatt die zu raisen, die quasi in diesen
Exception-Cache rein speichern und
ganz am Ende alle Exceptions da drin sind
in eine Custom-Exception
zusammenfassen und raisen.
Keine Ahnung, wie das jetzt dann Leute gerade machen.
Wie sie damit umgehen.
Da gibt es unterschiedliche Ansätze wahrscheinlich, aber
jetzt geht es halt so, dass es cool ist und sauber.
Ja,
ansonsten hatten wir noch
iPython, erste
Major-Release seit drei Jahren oder so.
iPython 8.
Ja, okay.
ehrlich gesagt so wahnsinnig viel Neues ist da gar nicht
unbedingt, also außer Black ist irgendwie neu,
da mussten sie auch ein bisschen zurückrudern,
das hat Leute irgendwie auch böse
überrascht teilweise. Das haben wir doch letztes Mal noch gelobt.
Ja, ja, ja, aber im Prinzip
ist es eigentlich schon richtig
und
ja, ist es viel deprecated
worden von Dingen, die man nicht mehr
braucht und so und ich glaube, ich habe es auch schon,
ist es nur Beta, ist es noch nicht
stable, aber ich habe
es auch schon, also wenn man es einfach so installiert
man pinnt es nicht runter oder so, sondern
man sagt einfach nur pip install
ipad und dann kriegt man das halt.
Und funktioniert bei mir auch schon super.
Ich verwende es schon
die paar Tage, die es veröffentlicht ist,
auf jeden Fall. Und da hat es bisher immer getan.
Ja.
Genau.
Ja, ansonsten so war es.
Wir haben jetzt irgendwie
super viele
Episoden in letzter Zeit aufgenommen. Jetzt ist gar nicht so viel passiert.
Weil gar nicht so viel Zeit vergangen ist.
Ja, okay.
Ich weiß nicht, hattest du noch irgendwas?
Oder haben wir noch irgendwie...
Wir machen nochmal Werbung dieser Episode.
Oh ja, genau, das müssen wir dann jetzt auch machen.
Also, diese Episode
kommt wieder mit der freundlichen Unterstützung von NordVPN.
Ja, und
schnapp dir den Exklusiv-Deal
und ein Geschenk obendrauf
zum NordVPN-Geburtstag.
Geh auf
https.nordvpn.com
slash pythonpodcast
und sichere dir den Wahnsinns-Deal
jetzt auch komplett risikofrei mit 30 Tage
Geld-Zurück-Garantie. Also das ist
eine Geschichte, die man
durchaus mal machen kann. Also
NordVPN, VPN-Anbieter,
da
kann man sich zum Beispiel
irgendwie im Urlaub auch drauf verlassen, dass man dann
weiter Netflix gucken kann,
was man ja sonst irgendwie, manchmal hat man da so Probleme
zu Geoblocking und so. Und damit kann man
das irgendwie relativ einfach umgehen. Oder halt
auch, wenn man irgendwie sonst
Konnektivitätsprobleme hat, dann kann man aber auch
irgendwie da was gegen tun
mit. Und
ja, hat viele Server
in allen möglichen Ländern und so.
Also ist auf jeden Fall irgendwie
einer der größten Anbieter da in dem Bereich.
Und ja, kann man ja einfach
mal ausprobieren und auf
HTTPS-NordVPN.com
slash peißenpodcast gehen und
den Warnsignal sichern, der jetzt auch komplett risikofrei
mit der 30-Tage-Geld-Zurück-Garantie ist.
Wunderbar.
Ja, worüber
reden wir denn heute?
Ja, die ganzen Tipps, Tools
im Web und
CSS-Frameworks und
vielleicht fangen wir damit an.
Was für ein CSS-Framework benutzt denn du, Jochen?
Ja, irgendwie
gar nicht.
Ihr habt vielleicht gesehen,
Python-Podcast ist zu unserer Schande in
Bootstrap, weil das Einzige, was wir gemacht haben
für Styling ist Import CDN
vom, also Bootstrap vom CDN.
Ja, das weiß ich gar nicht mal. Ich glaube, das mache ich tatsächlich nicht.
Aber das mache ich.
Oh Gott, bin ich schlecht.
Tja, wir müssen das irgendwann mal anfassen.
Weil ich würde sagen, das sollte man natürlich
eigentlich auf keinen Fall machen, sowas.
Aber weil,
ja, das ist natürlich extrem unsicher. Das erinnert mich an was?
Mach ich das wirklich?
Ist das nicht so?
Ich meine nicht, aber
ich gucke mal gerade, ich mache hier gerade mal
an den,
das Netzwerk,
das ist ja auch,
das steht doch immer unter Sources,
ne? Und dann steht da drin,
äh,
oh ja,
und da sind die weißen CDNs.
Codejquery.com.
Oh mein Gott.
Bootstrap-CDN. Oh nein.
Ja, also, okay.
Ja, okay, das war mir gar nicht so klar,
dass ich das machen kann. Kontrolle ist besser als
Ja, ja, dankeschön. Dann ist mir das
jetzt auch bewusst. Ich dachte, ach, so was mache ich
aber nicht. Aber doch, mache ich schon. Kacke.
Naja. Ja, also
Bootstrap ist raus. Also
sagen wir so, das benutzt man halt natürlich
dann, wenn man keine Zeit für irgendwas anderes hat.
Dann macht man einfach Import-Bootstrap vom CDN
und dann sieht alles irgendwie ein bisschen besser aus.
Das hätte man jetzt gar nicht gestylt.
Aber auch nicht viel besser, ehrlich gesagt.
Ja, vor allen Dingen ist es halt das,
was in dem Django-Cookie-Cutter-Template mit dabei war.
Deswegen habe ich das vor allen Dingen.
Du benutzt ja kein Cookie-Cutter von ...
Eigentlich seit einiger Zeit nicht mehr,
aber ich habe es lange verwendet, ja.
Ja, also ich habe es auch ein bisschen mal ausprobiert.
Das war nicht so ganz mein Ding.
Ja, also inzwischen würde ich auch sagen,
also ich benutze inzwischen gerne irgendwie tatsächlich Start-Project
oder halt auch das, das habe ich jetzt letztens wieder verwendet,
das
Project Template, weil man kann ja dem Start Project
auch Project Templates mitgeben
von Johannes. Das gefällt mir eigentlich
tatsächlich auch ganz gut. Und
Cookie Cutter ist einfach, ist mir zu
viel Zeug, das ich irgendwie nicht
brauche. Also ich habe eigentlich meine eigenen
Skeletons einfach geschrieben, also so zwei, drei
Templates für Sachen, die ich manchmal brauche. Django
mit Postgres, Django Minimal
Farb-API und dann klone
ich die einfach.
Ja, kannst du halt auch machen, aber dann
Es bleiben halt manchmal nur so Reste übrig.
Ja, aber das ist nicht viel. Also ich weiß ja dann wo
und ich habe mir das ja so ein bisschen weggescriptet.
Dann kann ich einfach zwei Skripte ausführen.
Dann habe ich es einmal replaced und dann schmeiße ich
drei Dateien weg, die ich nicht brauche und dann ist es gut.
Das ist halt mein Zeugs. Ich kenne mich da ja auch aus
und das geht aber dann wirklich schnell. Und da ist halt aber auch
dann das bei, was ich will.
Ja, also es ist halt
irgendwie, also ich bin
da noch nicht bei null. Ja, andersrum ist, du fängst halt bei null an
und dann musst du aus allen alten Projekten, wo du das benutzt hast,
das jetzt mal reinkopieren. Das geht auch nicht schneller.
Ja, aber genau dafür, sowas hast du ja normalerweise
in einem Template, damit du das nicht
aber es ist wirklich, also ich
habe auch, ich würde jetzt nicht sagen,
dass es da irgendwie eine Lösung für das Problem gibt,
weil das ist irgendwie, ich
habe inzwischen auch, also
am Anfang fand ich
das tatsächlich hilfreich, weil
es gibt ja so viele Settings in
Django auch, es ist halt echt eine Menge Zeug,
dass man gar nicht weiß, wie man
das alles setzen soll und wenn man vor dieser
Aufgabe steht, ohne jetzt wirklich damit
schon lange Erfahrung zu haben,
dann ist man so ein bisschen, also jedenfalls hatte ich das am Anfang,
hatte ich das Problem, du stehst halt wieder
wie so ein Ox von Berg.
Ja gut, aber wenn er es von Fydenny nimmt, also tatsächlich das
Komplettprogramm.
mit Cookie Cutter. Das ist ja derselbe
Typ, der auch Two Scoops
of Django. Ja, das Buch geschrieben hat oder
die diversen Bücher, die es zu dem Thema gibt.
Aber
da ist so viel Zeugs drin.
Da ist so viel Zeugs drin.
Ja, die Hälfte brauchst du nicht.
Ja, aber das ist halt die Frage.
Am Anfang weißt du halt nicht, was du brauchst und was du nicht brauchst.
Ja, aber das ist halt so.
Gerade für Anfänger würde ich auf gar keinen Fall
Klar, weißt du noch nicht, was du nicht brauchst, aber
das würde ich auf gar keinen Fall machen, sondern ich würde Blank Django
nehmen als Anfänger. Ja gut.
also für mich war das
gar nicht so ein schlechter Weg, aber inzwischen
mache ich das halt auch nicht mehr, weil ich jetzt sagen würde,
okay, ich weiß jetzt, was ich alles nicht brauche und ich brauche den
meisten Kram nicht und vor allen Dingen ein Ding,
das mich von dem Cookie Cutter,
Django Cookie Cutter komplett weggebracht hat, ist halt,
dass die halt irgendwann, das war auch
nicht so, das war am Anfang nicht so,
am Anfang war das komplett ohne Docker
und dann haben sie irgendwann gesagt, okay,
das jetzt für unterschiedliche Plattformen,
das wird halt so stressig, das alles zu maintainen,
wir konsolidieren das jetzt auf Docker
und
dann habe ich ja auch eine Zeit lang das mit Docker verwendet
und jetzt würde ich sagen so, nee, ich will aber Docker gar nicht
mehr, also weg damit.
Und ja, jetzt
bringt es für mich sozusagen gar nicht mehr so viel, weil
ja, das ist halt hauptsächlich
Docker-Zeugs.
Okay, aber wir sind
quasi jetzt ja da hingekommen, also warum
Bootstrap bei dir? Genau, so ist
das Bootstrap da irgendwie reingekommen und
ich weiß auch nicht, ob das noch da
mit drin ist, bei den aktuellen
Geschichten, aber ja, also
genau, eigentlich ist das natürlich nicht so schön.
Ich habe jetzt auch letztens gesehen, wie groß
Bootstrap eigentlich ist, war mir auch nicht so klar, das ist ja
irgendwie alles ziemlich riesig.
Und dann eben hat das noch so
Dependencies auf jQuery und so, das sind ja alles Zeugs,
was man heutzutage im Grunde nicht mehr wirklich haben will,
braucht und so, aber es ist halt
irgendwie dann alles immer noch mit dabei.
Ja, also Foundation gibt es noch,
das habe ich von Johannes mal.
Ja, Foundation ist so quasi
so ähnlich. Ja, auch so, du musst halt
eigentlich, du schreibst halt nichts, importierst halt
einfach irgendwas vom CDN oder kannst es natürlich
auch vom Lokal. Und es sieht halt ein bisschen hübscher
aus. Man kann natürlich immer nachstylen, wenn man will.
Dann gibt es noch
Materialize und
UI-Kit.
Und das sind alles immer so große klassenbasierte
CSS-Sachen oder Post-SS oder so.
Wo man halt dann seine Klassen,
vordefinierte Klassen hat, die dann irgendwelche tolle Magie
machen. Ja, oder Semantic
UI habe ich jetzt auch gesehen, dass das viele Leute
verwenden. End-Design.
Das kenne ich nicht. Das ist
auch total schräg.
End, die Ameise?
Ja, ja, ja. End.design.
Das ist so was Chinesisches.
Das ist auch so, dass
es gibt, also das hat mehr
Stars aufgetappt als Django.
Und
irgendwie in China verwenden das
Millionen Leute. Aber hier
kennt man das gar nicht so sehr.
Ja, ist auch eigentlich.
Wahrscheinlich
verwenden es deswegen Leute, weil es gute Dokumentationen
auf Chinesisch hat. Man weiß es nicht. Ja, mag
sein. Dann gibt es noch Bulma.
Das benutzen zum Beispiel viel von den
VJS-Leuten, also wenn man irgendwie jetzt auf
Mastery oder so Kurse macht. Da gibt es so ein paar
Leute, die Bulma machen, fand ich, das hat mich
nicht so ehrlich begeistert.
Ist vielleicht eher so für...
Ja, aber ich glaube, ich fände die gleiche Kategorie wie eben
das habe ich ja auch unter Utility First
CSS-Frameworks
genauso wie Tailwind.
Ja, genau, aber Tailwind würde ich sagen,
so mache ich das.
Okay. Ja, also ich finde es sehr, sehr
toll. Ja, ich
habe auch viel Gutes gehört und habe aber auch
Leute schon stöhnen gehört, also ich weiß es nicht.
Ja, also wir haben im Vorfeld jetzt kurz drüber gesprochen
und du hast gesagt, so oben, Moment,
also ich habe es zwar nicht benutzt, aber ich habe ja gehört
A und B und C und die haben
gesagt, das ist doof und
Ja,
genau, aber das Problem ist halt immer so, bei diesen
Entscheidungen, ich meine wahrscheinlich ist einfach alles Unsinn,
muss man irgendwas anfangen, aber ich habe ja keine Ahnung davon,
ich habe aber jetzt, reden wir da schon
fünf Minuten drüber und ich habe ja auch eine Liste mir dann
gemacht, weil ich dachte irgendwie, vielleicht muss ich
da mal irgendwie von 20 Dingern,
die es hier irgendwie gibt, die ich mir alle mal angucken
muss. Ich denke jetzt so, ich habe noch überhaupt
nicht angefangen. Jetzt muss ich schon zwischen so vielen unterschiedlichen
Sachen aushalten. Ich habe absolut keine Ahnung, was ich da machen soll.
Oh mein Gott.
Und dann eben, genau.
Soll man jetzt das selber machen? Soll man BAM
machen? Soll man irgendwie Utility
First machen? Soll man ein Framework nehmen?
Soll man SAS nehmen? LESS nehmen?
PostCSS irgendwie? Was auch immer.
Ich weiß es doch alles nicht.
Und ich habe keine Ahnung.
Ja, ich würde da tatsächlich Table nehmen.
Ja, gut, dann fange ich mal mit Table an. Aber du hast ja gesagt, das ist ja alles noch für
low budget.
Und ich bin ja eher so,
persönlich, bin ja eher so der
high budget Typ.
Finde ich,
man muss sich da schon irgendwie so ein bisschen
positionieren, ansonsten
nicht, dass man da irgendwie
am falschen Ende rauskommt.
Das wäre nicht gut.
Aber ich, genau, also ich weiß
es halt nicht. Und es gibt so andere Sachen, es gibt dann noch
diese ganzen Mini-Dinger. Habe ich jetzt gesehen
bei, na,
wie heißt der noch?
Andrew Johnson hat das verwendet.
MVP, CSS.
Ja, das kenne ich noch nicht.
Super minimal. Und davon gibt es dann halt
auch wieder ein paar. Es gibt Mini-CSS
dort auch. Aber da muss man immer CSS sein.
Also ich muss jetzt nochmal
Tavent nochmal loben, weil
es sieht hässlich aus
auf den ersten Blick, weil das das
HTML so ein bisschen bloatet. Du hast halt
in deinem HTML ganz viel mehr Klassen
drin, die halt direkt das Styling machen. Aber
dafür hast du halt eben keine extra CSS-File mehr,
musst nicht hin- und herswitchen. Und eigentlich steht
es meiner Meinung nach genau da halt
die Definition des Styles drin, wo es halt hingehört.
Und zwar genau an dem
HTML-Element.
Und das finde ich super angenehm. Und da man
eh meiner Meinung nach ja immer so wieder
benutzbare Komponenten aktuell so
hat, ist das mit der Redundanz
hier auch nicht so schlimm. Und
ja, wenn du dann halt so ein
Hot-Reloading weit noch nebenbei anhast,
dann siehst du halt jede Änderung
der Farbe, schreibst halt
Red als Klasse hin
und dann ist es Rot und dann schreibst du
Red wächst mal Blau und dann ist es direkt Blau
und das ist einfach, das ist so
ein bisschen wie in den 90ern HTML-Coden.
Da musste man das ja auch
alles noch direkt hineinschreiben.
Und ich mochte das.
Okay, ich habe das weder in den 90ern gemacht, noch jetzt
oder dazwischen irgendwann, aber gut.
Naja, jetzt
muss ich wohl doch irgendwie mal.
Ja, das musst du auf jeden Fall mal angucken.
Wir haben ja auch eben noch über Winnie kurz gesprochen,
Das hast du ja auch noch gehabt.
Da gab es ja eine lustige...
Also über Tailwind, da gab es eine neue Release.
Ach, das hätten wir in die News packen können, ne?
Ja.
Siehst du mal.
Es gab eine Working Draft-Episode letzte Woche oder sowas
über Tailwind CSS3, wo auch irgendwie der Continuer war,
so eigentlich ist es ganz gut.
Und die Vorteile sind halt irgendwie, dass man jetzt nicht mehr...
Also früher war es so, im Default-Fall hat es halt irgendwie
immer die gleiche Größe an CSS ausgelegt.
Ja, man musste halt manuell purgen, die
CSS-Dinge, die man nicht haben wollte,
die musste man dann weg purgen, dass
die Falle nicht so groß wurde, ja.
Genau, und das passiert jetzt irgendwie alles
automatisch und man
muss auch nicht mehr Node.js verwenden,
sondern es hat irgendwie Standalone
Command-Line-Utilities irgendwie
für all die Sachen. Und das
ist ja schon sehr nett, also da dachte
ich auch so, oh, das klingt aber gut. Und dann
eben hieß es da auch, ja, das kommt aber von den Leuten
von Winnie oder so. Ja, also
Winnie hat ja Tailwind geklaut und dann
Sachen so ein bisschen halt faster gemacht vielleicht
oder so, so ein bisschen mehr Opinion reingebracht.
Jetzt haben sie das halt wieder zurückgeklaut.
Und dann haben sich die Winnie-Leute
beschert, dass sie nicht gecredited
werden für diese Geschichten.
Und dann hat irgendjemand anders gemeint, so, ah, aber ihr habt
das auch nur von mir wieder geklaut.
Verflüstert es auf einmal so, als wären das jetzt irgendwelche
Geheiminformationen, die...
Aber ich, keine Ahnung.
Also ich mag tatsächlich auch die
Bezahlsachen von Table & Can Scan. Es gibt ja so
vorgefertigte UI-Komponenten, die man sich kaufen
konnte. Und das Projekt zu unterstützen ist von denselben
Leuten, die das Projekt
geschrieben haben.
Es gibt ja auch so ein tolles Buch,
Refactoring UI oder so.
Habe ich mir auch irgendwann mal gekauft, aber habe ich
dann nicht gelesen. Vielleicht sollte ich das auch mal machen.
Vielleicht weiß ich dann mehr, wie das für die ganzen CSS.
Vielleicht sollte ich damit mal starten und irgendwie mal ein Buch lesen.
Das könnte vielleicht hilfreich sein.
Eine Geschichte,
die tatsächlich interessanter aussieht als diese
Myriade an unterschiedlichen CSS
Arten, Frameworks,
Minimaldingern, die man so benutzen kann.
die ich letztens gesehen habe, ist
Missing.Style
und zwar, weil
das halt aus dem HTMX-Umfeld
kommt und
da Leute sich überlegt haben, okay,
ja, es gibt, das fehlt halt noch. Also wenn man
HTMX macht, das mache ich jetzt auch relativ viel
und da bin ich eigentlich super
zufrieden mit und ja, aber wie macht man
das denn jetzt, weil da ist ja auch viel
Animationsgeschichten oder so
drin, die, dass dann Sachen verschwinden, wenn man
irgendwo draufklickt oder auftauchen und so
Transition-Effekte und so
und ja, da haben sie überlegt,
okay, dann brauchen wir eigentlich genau dafür
eins, aber wir wollen vielleicht nicht so ein super
so ein
all-in-one-riesen-Ding haben, sondern
nur für die Sachen, die wir da benutzen,
irgendwie so ein CSS-Geschichten
mitrahmen und sozusagen
der Missing Link irgendwie
soll das irgendwie so sein.
Das kann man sich auch mal angucken. Also da werde ich auf jeden Fall
auch mal drauf gucken, was die da machen
und das klang auf jeden Fall interessant, weil das
fehlt halt tatsächlich. Also bisher muss man dann halt
diese ganzen Transition-Geschichten
halt irgendwie in seinen CSS mit
reinfrickeln dann. Und wenn das halt
automatisch alles da wäre, wäre natürlich schon nett.
Ja.
Genau.
Ansonsten, ja, ich weiß
nicht.
CSS
haben, ja.
Ich muss mich
damit mal auseinandersetzen. Ich komme nicht mehr drum rum.
Ja, das erzählst du mir schon seit
Jahren.
Und dann habe ich doch immer wieder was anderes gefunden.
Und ja, es lässt sich aber, glaube ich, inzwischen echt nicht mehr vermeiden.
Ja, wie so ein bisschen.
Also deswegen empfehlen wir immer noch Tailwind.
Habt ihr das schon gesagt?
Ja, ich bin ein kleiner Fan davon.
Ich weiß nicht genau, warum.
Es war so ein bisschen, also ich konnte CSS sehr, sehr lange überhaupt nicht leiden.
Es war irgendwie mega hässlich.
Und dann fühlte sich Tailwind so an, wie ich es machen will.
Das ist so wie bei Python, wo ich relativ schnell wusste, okay, so will ich es machen.
Ja.
Das ist immer dann, wenn man gar nicht weiß, wie es geht
und dann findet man was, das irgendwie cool ist.
Ich weiß auch nicht. Vielleicht ist man auch völlig
auf dem Holzweg, weil man keinen hat, der einem erklärt hat,
wie es richtig ist. Aber vielleicht ist es auch manchmal gar nicht so schlecht,
wenn man da so ein bisschen seiner Intuition folgt.
Ja, am besten ist es wahrscheinlich,
man muss irgendwas machen und dann
schauen, ob man den
Kurs korrigiert, wenn es irgendwie nicht mehr gut
funktioniert. Ja, das sollte schon möglich sein,
dass man seine Meinung auch wechseln kann.
Das ist, glaube ich, schon...
Wir werden uns
weiter
Dinge angucken und dann sagen wir Bescheid, wenn wir
irgendwie das perfekt gefunden haben.
Ansonsten, ja, ich meine,
keine Ahnung, ich könnte ein bisschen was erzählen zu den
Sachen, die ich so mache. Warum gucke ich mir eigentlich
CSS-Geschichten an? Ja, erzähl mal, warum
guckst du dir CSS-Geschichten an? Ist ja langweilig,
auch wenn du es noch nicht benutzt hast.
Ja, ich habe ja diverse Projekte,
ja. Aber
genau, momentan
also
eine Geschichte, die ganz interessant ist,
ist halt, dass
Das beeinflusst halt so viele Sachen, weil das halt
Mit HTML-Sachen in den nächsten Trinkspielen, Jürgen.
Wenn ich das sage,
ja,
stimmt schon, aber
naja, so, weil
vieles, so gerade, ich hatte
mal irgendwann vor Jahren, also das ist zum Beispiel wieder eins von
diesen Beispielen,
so ein Bookmarking-Ding
angefangen und das macht halt auch so viel mit
Bootstrap und
so und jQuery und
ist halt alles ziemlich hässlich, was
Frontend-Geschichten angeht und
das
letztens nochmal angefasst, wieder auf aktuellen
Stand gebracht und da könnte man
wahrscheinlich mit HTMLX sehr viel machen und
dann ist halt die Frage, kann man dann nicht den ganzen
anderen Kram gleich mit rausschmeißen? Also sowas wie
dieses ganze jQuery-Graffel
und irgendwie Bootstrap und so, das wäre doch eigentlich
ganz nett. Und dann ist halt die Frage, okay,
was macht man in der Hand?
Genau, genau.
Dafür auch super geeignet.
Du hast ein Snippet, das du bei HTMLX
rausrennst und was schreibst du in dein Snippet rein?
Ja, genau. Also das wäre natürlich nett.
Das sind halt so Sachen, die Tailwind
nett machen, ist halt, dass es, wenn es im HTML
drinsteht, dann kann man es eben auch direkt mit
man muss halt nicht ein neues CSS mit ausliefern.
Genau, und du musst auch nicht jedes Mal in das
irgendein großes CSS, in das du schon ausgeliefert hast,
genau die Sachen reintreiben, sondern schreibst halt genau das, was du willst
in dein, ja.
Aber du hast eben auch gesagt, also ja, also
die großen Designer, die sich die ganz tollen Konzepte
überlegt haben mit ihren Styleguides, die könnten
eventuell sein, dass du dann einfach trotzdem
den Button kleiner machst, obwohl das verboten ist im Styleguide.
Ja, ich weiß
ich habe ehrlich gesagt keine Ahnung noch, wie man das alles
wirklich macht, aber naja.
Ja, aber genau, das wäre
so, das war so einer der Gründe,
warum ich da nochmal drüber nachgedacht habe.
Dann genau, aber auch sowas wie
ja, diese,
dafür würde ich gerne so eine Landingpage
bauen halt irgendwie, Podcast,
Hosting, Software as a Service
Geschichte und da
braucht man dann ja auch vielleicht ein bisschen mehr Design,
Wumms und dann ist Bootstrap vielleicht irgendwie
nicht das Richtige.
Nee, also was wir da machen, ist Designer
fragen, dann machen
die uns einen Entwurf, Design
und dann machen wir das in
Tablet. Ah, okay.
Ja, irgendwie
sowas, ne? Ja, da helfe ich dir gerne
bei. Ja. Was machst du noch?
Du hast noch ein paar Sachen entdeckt, so ein paar Pics fast,
ja, die... Ja, aber genau,
kann man auch einfach mal raushauen,
da gibt es ja genug Gelegenheiten für andere Pics.
Mermaid. Mermaid habe ich jetzt
letztens gesehen. Ziemlich
coole Sache, das kann ich noch nicht. Was man damit machen kann,
es Markdown-Enhancen um
sowas wie Diagramme.
Ja, genau. Und das kann halt auch diese Diagramme,
die Arten von Diagrammen, die man halt
zu rendern. Also das, was ihr von Draw.io vielleicht
kennt so ein bisschen oder so, wenn ihr so
ich weiß nicht, ob das in der Komplexität geht, aber
richtig coole Sachen, die man echt
gut dastehen kann. ERM-Diagramme,
Flowcharts, sowas.
Einfach als Markdown schreiben, so ein bisschen
runterschreiben und dann könnt ihr das auch
direkt rendern lassen. Auch von sowas wie GitHub.
Ja, also ER-Diagramme
habe ich auch oft irgendwie, da gab es so ein Plugin für
weiß ich gar nicht, wie das hieß,
auch in Django konnte man das irgendwie mit
einbinden und dann hat das halt
als Management Command und dann hat das halt
irgendwie ein ER-Diagramm rausgerendert,
aber das Problem ist halt, die sind halt wenig konfigurierbar
und wenn das halt groß wird, dann ist halt irgendwie
sieht man nichts mehr und wenn es klein ist, dann hätte man
gar nicht mehr Informationen. Du meinst Graphist?
Und das hat mit Graphist oder Dot
irgendwie hat das das dann gerendert, aber
das ist alles nicht so,
also da ist... Ja gut, also für das ERM-Diagramm
direkt rausrennen lassen aus den Models, ist das natürlich schon nett,
Wir reden ja gerade über Mermaid, dass das, glaube ich,
nicht macht. Nee, da machst du es von Hand, aber da hast
halt dann auch mehr Kontrollmöglichkeiten. Also insofern...
Ja gut, aber ich will jetzt natürlich nicht jetzt irgendwie,
wenn irgendjemand einfach kurz das ERM
sehen will, dann exportiere ich halt einfach aus meinen
Dango-Models kurz das ERM. Aber ja, du hast natürlich
recht, viel schöner, wenn man das vorbereitet
und am Anfang, bevor man die Models hat,
kann man das ja vielleicht bauen, so.
Naja, ist eher so, weil die Frage ist, was willst
du in deiner Dokumentation verlinken?
Und ein automatisch generiertes Ding
in der Dokumentation ist halt irgendwie
nicht so super.
Wichtigere Frage wäre, liest jemand die Dokumentation?
Ja, das ist
auch vielleicht nicht. Ja, wenn nicht,
dann mache ich es automatisch, weil dann brauche ich ja
keine Arbeitszeit reinchecken. Wenn doch, dann sollte
man es ordentlich machen. Aber das ist immer ein bisschen die Frage.
Einige Leute wollen die unbedingt haben, aber niemand
guckt rein. Dann ist es halt nur für einen selber
und dann weiß ich nicht, ob ich das dann...
Naja, aber also was mich
halt freut, ist, dass es jetzt auf jeden Fall ein Ding gibt,
wo man... Also sonst habe ich mich immer gefragt,
nehme ich Draw.io oder nehme ich irgendein anderes Tool
oder nehme ich halt irgendwie irgendein Desktop-Ding,
was ich halt habe. Und dann mache ich das als PNG
raus oder als SVG. Nehme ich lieber in SVG
oder weiß nicht so genau. Und dann
das sieht aber auch wieder ganz anders aus als alle anderen
Diagramme, die ich sonst so gemacht
habe. Also Mist, auf dem Hintergrund funktioniert das
aber nicht. Halt diese ganzen Probleme. Und das
ist man halt alles los, wenn man das mit Mermaid macht.
Ja, also vor allem, das ist wie gesagt Master. Und ihr
könnt auch sowas machen wie verschiedene Projekte.
Wie lange wollt ihr die denn schedulen?
Und dann nebeneinander. Das finde ich echt sehr geil. Also ich
müsste mir das unbedingt angucken, weil ich halt diese
Tasks, die hintereinander kommen, mit
wie lange brauchen die denn? So ein Ad-Gent
oder sowas für verschiedene Projekte bauen kann
in Markdown. Und wir benutzen ja eh
für alles jetzt Markdown, nicht wahr, Jochen?
Ja.
Ich weiß nicht so genau.
Nein, zum Schreiben, nicht?
Ja, meistens. Also, genau.
Ich habe ja jetzt auch MPR-Docs mehr dann angeguckt
und damit geht das halt auch.
Genau, Static-Page-Rendering geht auch.
Und da kann ich auch Markdown.
PDF geht, sogar so Richtung LaTeX-Templates geht.
Es geht,
was noch? Was brauchen wir noch? PDF natürlich,
Präsentationen geht.
Naja, oder Notebooks verwende ich halt auch
Markdown viel. Notebooks? Klar.
Aber, sagen wir mal so,
also für Python-Dokumentationen
traditionell verwenden Leute ja dann
Restructured Text. Ja, aber das ist so hässlich.
Ja, es ist hässlich, aber es ist halt,
es kann halt viel mehr als Markdown.
Und es gibt halt, die Leute sagen halt immer so,
ja, also Markdown nett,
aber es kann halt nicht die Sachen, die ich brauche.
Daher nehme ich lieber, also gerade was Links
angeht und so,
daher nehme ich lieber Restructured Text.
Ich glaube auch,
das ist immer noch das,
was am häufigsten verwendet wird.
Also wenn man irgendwie Dokumentationen von Projekten anguckt,
das ist meistens Restructured Text.
Aber ich habe es auch jetzt öfter mal
mit Twinks oder so versucht.
Ich verstehe, wo das Problem ist, ja.
Also das schlägt dann keiner mehr.
Also Markdown kann man irgendwie besser.
Ich weiß nicht,
Restructured Text wird es nicht schaffen.
Keine Ahnung, aber...
Bin ich mir zumindest sicher.
Also Markdown kann man so super viele Anwendungsfälle haben.
man kann das halt einfach, sein Github hochladen,
das ist direkt gerendert. Man kann, weiß nicht,
es gibt so Typora oder so, ich glaube, der ist leider,
der war tischendurch frei, ich glaube, der ist jetzt
leider auch
proprietär, aber da konnte man wie
so ein Schreibprogramm seine Eltern
überreden, wenn die irgendwas schreiben wollen und
kein Word brauchten, hey, schreib doch Typora, dann hatten die
Markdown-Files voll toll und die haben es gar nicht gemerkt,
weil das so ein Wolf-Misky-Editor für Markdown
hat das richtig schön und
sowas halt und ja, Obsidian
vielleicht noch und
das halt so eine grafische Visualisierung von einem Markdown
es macht, wenn du es möchtest. Und dann
kannst du so ein bisschen sehen, woran du arbeitest oder wie die Themen
untereinander verknüpft sind. Die Links können man...
Kennst du das Zettelkasten-Prinzip?
Luhmann ist das irgendwie, ne?
Ich weiß nicht genau, wie es heißt.
Zettelkasten habe ich.
Ach, jetzt können wir es nicht erklären. Jetzt müssten wir
Kollegen
hier haben.
Doch, ich glaube...
Also du kannst auf jeden Fall Sachen da richtig einsortieren und hast
durch die Verknüpfung direkt viel
schnellere Sachverhalte miteinander
gebündelt.
Ja.
Ja, Luhmann kann sagen, dass das richtig war, aber
wie genau das ging, weiß ich jetzt nicht genau. Jedenfalls
Y unterstützt auch das,
deine Ablage an dieser
Methoden.
Mein Notizblock, SimpleNote,
auch Markdown, Vendable
und so. Ja, also es gibt ganz viele Kleinigkeiten,
die in diese Markdown-Welt reinspielen und
diese Schlimmste sind alle
Entertainable und das ist,
ich bin auch ein großer Fan von Markdown, hab ich ja schon gesagt.
Nee, aber ich glaube, man kann das irgendwie
durchaus so raushören, wenn man da
ganz, ganz genau mit der Lupe
draufkommt.
Ja.
Ja,
ja, es läuft
momentan alles so ein bisschen auf dem Markdown hinaus.
Mal schauen. Genau, auch schön
ist, dass es halt auch in GitHub-Geschichten funktioniert.
Da ist auch irgendwie Standard-Integration,
Standard-Message-Integration an. Das heißt,
wenn man das einfach so reinschreibt, dann hat man das halt
auch in Issues oder halt in irgendwie
ja, Markdown, was halt auch von
Github gerendert wird.
Ja, überhaupt, aber
das ganze Dokumentationsthema ist ja auch
so in letzter Zeit, habe ich nicht...
Genau, ein bisschen
mit Make-Docs
beschäftigt, aber halt auch
überhaupt mit diesem Ding, dass man das halt
vielleicht mal tun sollte, weil
an sich dazu, bisher war ja eigentlich immer
so Dokumentation, ah, nee, lieber nicht.
Ist ein bisschen zweifelhaft
vielleicht und
inzwischen denke ich mir so, naja,
vielleicht ist es doch nicht so schlau und
genau, da hatte
Simon Willison auch irgendwie
diverse Artikel jetzt in letzter Zeit
in seinem Blog einmal irgendwie bessere
Release Notes schreiben.
Da versuche ich mich jetzt auch so ein bisschen dran zu halten.
Ja, das ist cool. Das finde ich schwierig.
Also bei mir steht auch in den meisten
Commits nur Schrott drin wie Fixed Something
oder Fixed Final oder Fixed Again
oder Typo oder, ja, also ich
versuche es immer. Also es gibt dann immer einen Commit,
der ist ordentlich und
15 dann, die sind irgendwie so Fixes
davon. Ich glaube, man kann die irgendwie
stacken.
Du kannst sie hinterher squashen,
wenn du das halt in einem
Pull-Request zusammenfasst.
Ja, aber das mache ich zum Beispiel nicht.
Ja, das würde man im Pull-Request machen.
Das ist bei mir relativ egal, wenn ich der Einzige bin,
der auf so einem Branch ackert, dann ist das völlig wurscht.
Ja, klar, klar.
Ja, würde ich auch sagen. Also normalerweise
mache ich das halt auch nicht, wenn ich da irgendwie
alleine... Aber, wenn man sich jetzt überlegt,
eigentlich möchte man ja vielleicht irgendwie
die Entwicklung auch skalieren können.
Und ja, das ist sehr sinnvoll, dass man gute Commit-Messages hat, wo auch was passiert und nicht nur zwei Leerzeichen gemittet werden, dann müsste man auf jeden Fall seine Commits alles squashen und die ordentlich machen und so, ja.
Aber also Commit-Messages ist jetzt bei mir so da.
die gehen eigentlich, finde ich. Die sind gar nicht so schlimm.
Aber das ist auch ganz okay.
Ich habe mich ja mal über die Zeit
mit euch unterhalten. Das ist auch schon ein paar
Jährchen her, glaube ich. Und zwar, ob man die
in Präsenz oder in
der Vergangenheitsform formuliert.
Ja.
Weiß ich auch gar nicht mehr. Das Ergebnis war,
Präsenz wurde bevorzugt. Präsenz, ja, kann sein.
Ich weiß jetzt gar nicht, was ich...
Dieser Komite fix, dies und jenes.
Anstatt dieser Komite hat das und das gefixt.
Ja.
Aber das ist ja nicht das gleiche wie Release-Logs.
Release-Logs ist immer eine andere Geschichte.
Ja, aber wann macht man das zum Beispiel?
Also wann schreibt man quasi sein, ja, die Fixliste.
Also das ist ja ein bisschen wie Bugs und Features.
Wenn du eine Release machst.
Also die, ja, aber auf Semantic-Versioning, auf welcher, auf meiner.
Semantic-Versioning ist halt so eine Sache.
Braucht man das? Nein? Warum nicht?
Naja, weil es ja auch nicht wirklich hilft.
gut, auch da gibt's halt
eine Menge Leute, die mittlerweile halt
irgendwie einfach fortlaufende
Geschichten machen. So ein bisschen Pseudo ist ja ganz okay.
Also wenn man zum Beispiel weiß, man hat jetzt nur ein bisschen
was gefixt oder arbeitet an so ein paar
Sachen rum, dann
macht man immer so die Patch-Version.
Wenn man jetzt quasi ein paar neue Features eingebaut hat,
würde ich sagen, ist schon Minor nach oben.
Machen wir einfach Minor ein. Neue Features,
Minor. Ja, also genau.
Und Major ist Breaking Change, also
es geht irgendwas nicht mehr mit früher, dann ist Major.
Ja, wenn man
das so machen will, klar. Aber die Frage
ist halt, ob das jetzt sinnvoll ist oder nicht.
Das ist halt nochmal eine andere Frage. Es gibt Leute, die machen es so,
machen es anders. Aber egal, wie man es
macht, also Release Notes
zu schreiben, ist wahrscheinlich immer eine ganz gute Idee.
Egal, wie man es macht.
Und auch da ein Datum
zum Beispiel dazu zu schreiben. Und dann halt noch,
da kann man sich auch die Artikel mal im Detail angucken.
Ja, stimmt.
Idealerweise sollte da die User-Story
beschrieben sein, die gefixt wurde oder die
dazugekommen ist. Zu viel ist auch nicht gut.
Es sollte so sein, dass...
Ein Satz zu dem Punkt.
Ein Satz, okay, das ist okay.
Aber es sollte halt nicht irgendwie, genau.
Man kann ja durchaus die Issues
und so reinschreiben.
Der User kann sich jetzt
auf unserem Backend einloggen.
Oder sowas wie, der User
kann jetzt den Filter
so bedienen, dass er alle möglichen...
Das ist halt die Frage, für wen schreibst du das?
Das sollte man sich vielleicht auch überlegen.
Ja, weil die interessiert das doch nicht,
was die User-Story ist. Also ich würde sagen,
aus einer technischen Perspektive sind die User-Stories
doch eigentlich komplett uninteressant.
Das wäre die technische Formulierung von, du kannst jetzt in diesem Formular
die Auswahl fehlen. Also technisch würde ich reinschreiben,
was tatsächlich passiert ist, was man geändert hat.
Oder es kommt mit
Messages aneinander kleben.
Nee, aber halt sozusagen
reinschreiben, was da passiert ist.
Aber aus Business-Sicht ist das
halt uninteressant. Aus Business-Sicht ist halt nur
interessant, was ist denn jetzt mit
unseren User-Stories passiert. Aber aus technischer Sicht
sind die User-Stories halt relativ irrelevant.
Das finde ich gar nicht.
Nee? Okay, gut.
Interessant. Ich weiß es nicht so genau.
Ich würde sagen, dass die meisten Open-Source-Projekte
sowas gar nicht haben. Die haben gar keine User-Stories
oder sowas. Ja, okay, aber
das, was damit gemeint ist vielleicht, weil tatsächlich ja das
Feature, das man baut, vielleicht das ist, was man dann
umsetzt und wie man das, also das würde ich
jetzt in so einen Release-Log reintreiben, welches Feature
jetzt umgesetzt ist.
Ja, wie gesagt,
aber ich glaube, es würde wahrscheinlich schon viel
helfen, wenn man sich überlegt, an wen richtet sich das eigentlich?
Wer soll das lesen?
So dass Manager lesen oder Kunde lesen
oder Nutzer lesen
oder die Devs lesen, ja.
Und zum Beispiel ein Ding,
das mich jetzt gerade interessiert,
deswegen beschäftige ich mich damit auch so ein bisschen,
eben wenn man jetzt Entwicklung skalieren möchte,
dann ist es vielleicht gar nicht so schlecht,
also zum Beispiel eben auch andere Artikel,
ich weiß jetzt gar nicht mehr,
wie der Titel von dem war,
das Simon Wilson geschrieben hat,
hat er so, ja, also er schreibt immer,
seit einiger Zeit immer,
macht er immer GitHub-Issues auf
für alles, was er macht.
Und einfach
um halt einen Punkt zu haben, wo er alles sammeln
kann, was zu einem bestimmten Ding gehört.
Auch. Und zwar nicht nur
Was ich ganz gerne
mache ist, das muss man halt immer
ein bisschen einstellen, ist
To-Do-Kommentare im Code.
Ja. Aber
die mit GitHub Post
Assessing, dass ihr halt einen Hook habt, dass ihr halt
automatisch aus meinen To-Dos im Code Issues erstellt
auf GitHub und die automatisch wieder
zumacht, wenn das To-Do da verschwindet.
Und dass ihr die automatisch auch nummeriert und das dann halt auch
in dem Commitment ergänzt.
Das heißt, er schreibt dann quasi an den To-Do
die Issue-Nummer mit dran und
dann kann man quasi darüber auch direkt
sich linken lassen, wenn man das einstellt, auf den
Issue, auf GitHub und sich den angucken und die Diskussion dazu
angucken und hat aber das im Code stehen und
muss halt nicht zwei Sachen pflegen, sondern du kannst halt einfach
im Code das dann bereinigen
und dann ist halt geschlossen
und sowas. Und das finde ich
der Wettbewerb. Ja, wenn du eine Stelle hast an einem Code,
wo du das hin, aber es gibt ja auch viele Dinge, die sind
kannst du ja nicht an einer Stelle festmachen.
Aber gut, ja, wie man es macht, ist ja letztlich gar nicht...
Du kannst natürlich auch ein Extra machen und dann halt referenzieren, ein Commit oder so, aber ja.
Genau, und das kannst du ja mit dem Issue auch super machen, also GitHub macht das ja gut.
Also es erinnert dich niemand daran, noch extra Issues aufzumachen, wollte ich da mal sagen.
Ja, ja, nee, klar, also ich weiß gar nicht, also wie man es jetzt macht, das kann man halt machen, wie man will,
aber was ich daran interessant fand, ist halt, also einmal sagt er halt irgendwie,
aber warum er das macht, ist halt,
dass er einen Punkt haben möchte,
sozusagen an dem alles andere hängt.
Und GitHub macht das ja automatisch für ihn,
das alles zusammenzuführen,
wenn er irgendwo dann halt die Issue-Nummer mit reinschreibt.
Und der andere Punkt ist halt,
er hätte gerne dann daraus einen Pull-Request
und dann sozusagen einen perfekten Commit,
der das dann halt irgendwie handelt.
Wo er dann halt sozusagen alles zusammen hat,
was an Änderungen an Dokumentation, Test, Code gemacht werden muss,
damit er das Ding zumachen kann.
Und dann ist der Issue sozusagen eigentlich auch so eine schöne Geschichte,
um halt da reinzuschreiben, was denn überhaupt passieren soll.
Auch eine gute Gelegenheit, um sich Gedanken zu machen,
was man eigentlich machen will.
Und allein, wenn man sich überlegt, okay, ich mache jetzt ein Issue auf
und schreibe mir erstmal auf, was denn jetzt dazugehört,
dann erledigen sich halt viele Sachen schon,
weil man dann anfängt, so ein bisschen gezwungen ist,
darüber nochmal nachzudenken und dann vieles
sich dann auch schon wieder erledigt.
Man fängt nachzudenken, ist ja manchmal so ein bisschen,
ist ja nicht so schlecht.
Oft ist es halt so, dass man das dann später merkt,
wenn man irgendwie anfängt zu entwickeln und dann später merkt man so,
oh, das hätte ich jetzt alles eigentlich gar nicht machen müssen.
Aber
also, das fand ich ganz
nett.
Vor allen Dingen, ich habe das jetzt zum Beispiel für ein Ding,
ich habe so einen Podcast-Client geschrieben.
Ich weiß nicht genau, warum ich das jetzt gemacht habe.
Könnte diesen Ding Jagni...
Ich weiß nicht genau, warum ich das nicht genau gemacht habe.
Ja, Jagni könnte sein.
Oder halt auch einfach so Standard-Jagdshaving.
Könnte auch gut sein.
Ja, eben.
Ich vermisse gleich vielleicht nochmal eine Abschweife.
Aber genau.
Und da habe ich mir dann gedacht, okay, das war dann halt auch das Richtige.
Das mit den Issues mache ich jetzt vielleicht auch mal so.
Ich lege einfach schon mal ein paar Issues an.
Wenn jemand vorbeikommt oder drauf guckt,
dann kann er das vielleicht einfach auch so machen.
einfach damit Leute halt einen Ansatzpunkt haben.
Wenn du halt einfach so eine Code-Basis hast, dann weißt du ja gar nicht,
selbst wenn du dann irgendwas machen wollen würdest,
was du denn jetzt da machen sollst.
Weißt du, das Problem ist ja auch, die meisten Leute, die gehen da nicht hin und gucken,
oh, was gibt es denn schon für Git-Apps, für coole Podcast-Clients,
oh, der ist auch total unfertig, das sieht doch cool aus,
da gucke ich mir in die iTunes rein, was ich alles machen kann.
Nichts.
Nein, sondern die fangen dann ihren eigenen Podcast-Client an.
Ja, so wie ich, das stimmt.
Ja, genau, vielleicht ist es ein bisschen zu enthusiastisch, optimistisch verblendet,
Aber wenn man das denn machen wollen würde,
dann ist es natürlich die Wahrscheinlichkeit,
dass jemand vorbeikommt und was macht,
vielleicht viel höher, wenn da schon sowas ist.
Ja, ich würde sagen, das macht tatsächlich dann Sinn,
wenn das Projekt schon so ein bisschen Drive aufgenommen hat.
Nee, klar.
So ein paar Stars gesammelt hat und man dann denkt so,
hey, es wäre jetzt vielleicht cool, so ein paar...
Nee, ich mache das vor allen Dingen deswegen halt,
um das zu üben, weil wenn man es dann braucht,
dann ist es ja immer schlecht.
Wenn man das dann erst lernt.
Genau.
Man muss ja immer schon alles direkt perfekt können.
Nicht perfekt, aber so ein bisschen besser,
was irgendwie man vergrattert.
Ja, es ist
manchmal nicht so einfach.
Ja, immer auf jeden Fall besser als alle.
Ja, ja, ich verstehe das.
Ja, das ist halt
aber tatsächlich so eins der Probleme, die
wir in unserer Gesellschaft, in unserer Kultur haben. Das sehen
andere Leute aus anderen Ländern überhaupt nicht so.
Die verstehen das überhaupt nicht, warum wir da so völlig
bescheuert sind. Und denen ist das,
die können das wirklich nicht nachvollziehen.
Ich finde das auch ein bisschen anstrengend immer.
Und ich finde das auch nicht so produktiv.
Und es ist tatsächlich nicht so
Business optimiert. Ja, das mag sein.
Aber naja. Aber
zu Glück muss ich auch nicht auf Business-Ziele optimieren.
Ja, gut für dich, Jochen.
Ja, genau.
Ja, genau, ich wollte
einfach mal ein bisschen Übung zu schreiben und
ja, das mache ich jetzt auch
so ein bisschen. Und ich habe einen kleinen, und ich, tatsächlich, ich finde
eigentlich Podcast-Client ist, also habe ich schon erzählt,
warum ich das interessant finde oder was mich da so dran
angesprungen hat.
Der Grund, warum ich das mache, ist, dass man
das ja sowieso irgendwie braucht.
Ich habe das Gefühl, ich muss es
sowieso früher oder später irgendwann tun
und der Grund, warum man das
irgendwie tun muss, oder ich das Gefühl
habe, dass ich das tun muss, ist, weil
da ja so viele
schöne andere Dinge dranhängen, wie zum Beispiel
wenn du jetzt irgendwie
wissen möchtest, wie zum Beispiel dein Podcast
aussieht in einem Podcast-Rosting.
Dann willst du den
vielleicht importieren. Wie machst du das? Naja, du sagst
halt, hier ist mein Feed, importiere doch mal.
Feed importieren irgendwo her
und einen Client haben, der
irgendwie sagen, das ist fast das Gleiche.
Das ist fast das Gleiche.
Ja, fast.
Und überhaupt,
ja, vielleicht willst du einen Katalog haben, vielleicht willst du
irgendwie, da brauchst du
auch die Dinger parsen können, Feeds parsen
können, Podcast Client haben, ist fast das Gleiche.
Ganz interessante Geschichte und dann wollte ich mal
gucken, wie funktioniert eigentlich diese Feed Parser Library
so, was muss man da für eigentlich alles machen.
Ja, dann habe ich das
irgendwie gestartet und ich dachte, ach, Rich
und so, das ist auch voll cool.
Ja, Rich finde ich ja tatsächlich gut, habe ich ja schon ein paar Mal gepickt.
ja. Rich gibt's die
Klee, Rich Klee, CLI. Genau,
das, ähm, genau, wollte ich eigentlich
gleich nochmal picken, aber können wir auch jetzt machen, ist mir egal.
Das wäre dein Pick gewesen, okay, Entschuldigung.
Statt Butt, hast du gesagt, nimmst du die Rich CLI,
weil es so wunderschöne
Dokumente darstellt und Markdown-Rendern und
Tabellen, CV. Genau, also das, was ich
bisher eigentlich immer verwendet habe, ist Butt.
Das verwende ich auch immer noch.
Ich finde das super. Ja, ist auch
ganz gut. Fast, Modern Unix.
Äh, ja, aber
bei mir. Konfigurierbar.
Man kann es konfigurieren, aber in der Default-Konfiguration
macht es halt irgendwie Zeilennummern davor.
Ja, das kann man nicht mehr copy und pasten, da hast du recht.
Das heißt, da kann man auch nicht mehr pipen, wie man das mit Cut gewohnt ist.
Und deswegen muss man die Konfiguration anpassen.
Das sind zwei Environment-Variablen, die man setzen muss.
Und dann muss man
machen, wie man das so haben möchte.
Also eine für den Style und eine für die
Zeilennummern und dann kann man das nach wie vor
in einen Pipes einsetzen und kann das
dann aliasen auch auf Cut und dann kann man Butt nehmen für
mit Zeilennummern.
Ja, aber wie gesagt, wenn man
Rich nimmt, dann ist das halt
Rich-CLI und auf der Kommando-Seile ist es dann einfach nur
Rich. Dann muss man
das eben nicht machen, sondern es funktioniert einfach so.
Und es kann auch ein bisschen mehr
Syntax-Highlighting-Geschichten machen als
Butt. Also insofern
kann man ja mal ausprobieren.
Ja, ich fand es auch ganz gut. Also ich mag ja
Rich auch. Ich mache mit Rich auch Konsolen-Anwendungen
teilweise.
Ja, gibt es jetzt auch...
Nein, das sag ich jetzt nicht.
Da müsst ihr jetzt warten
bis zum Schluss, dann picke ich nämlich das nämlich stattdessen.
Na gut. Ja.
Und genau.
Ja, und da dachte ich, so kommen halt ein paar Sachen zusammen,
die das aus unterschiedlichen Gesichtspunkten
interessant machen, deswegen habe ich damit mal angefangen.
Ich habe, genau, also eine der
Geschichten, also von diesem Bootstrap-Ding und
Jungle Crispy Forms und so muss man irgendwie weg. Ich habe jetzt
auch, das habe ich, glaube ich, relativ
aus anderen Gründen
und dann das jetzt nicht mehr in der privaten
Weise viel mehr zu tun gehabt und
Es gibt auch irgendein, ich weiß nicht mehr, ob das
mit Crispy Forms war oder sowas, wo man
einen Hook reinbauen kann und dann halt
die Forms mit Tailwind benutzen kann.
Ja, also ich würde sagen,
das wäre auch interessant, wenn da jemand eine Empfehlung
hat, wie man das, also ich habe mir jetzt,
Crispy Form habe ich auch immer so verwendet, ich habe es nie so genau angeguckt,
sondern immer nur so benutzt und es ist
ja auch, es hat ja einige ganz nette
Geschichten und es macht einige Dinge ja einfacher
und jetzt habe ich da so mal tief reingeguckt
und ich muss sagen, das muss alles weg.
Das muss alles,
das geht nicht, das ist alles ganz
schrecklich. Also das
ist halt irgendwie langsam, man
kriegt es auch nicht schnell, weil es ist furchtbar
und das ist alles
so, also das ist, nee.
Also ich
denke, man sollte das anders machen. Ich weiß jetzt auch
noch nicht wie, aber man muss das irgendwie anders machen.
Das geht so nicht.
Und das war mir nicht so klar vorher, als ich da noch
nichts reingeguckt habe.
Irgendwas mit Forms
muss man sich nochmal ausdenken.
Ja, wobei, wenn man
halt irgendwie, da ist jetzt wieder,
das ist halt das Problem. Ich meine,
wenn du das jetzt so machst,
dass du die CSS-Klassen in HTML setzt und so,
dann hast du halt beim Rendern ein Problem, weil
dann musst du das nämlich alles irgendwie setzen.
Unter Umständen, ne?
Wieso, du machst ein Template für ein...
Ja, aber das ist ja genau das Problem,
dass CrispyForms löst.
Du hast halt eine Form, jetzt kommen die Formfehler zurück.
Wie machst du das so, dass
jetzt deine Fehler ordentlich, dass da halt
so ein roter Kringel drumrum ist?
Ja, du benutzt den Default, den machst du
zum Beispiel mit CrispyTemplate, CrispyTable gibt's auch.
Und dann, also
dass das auch langsam ist, ja, weil das auch Crispy Forms ist.
Aber dann machst du halt einfach
in deinem Template, überschreibst dann halt den Default
und hast dann
einen schönen Style.
Du musst es ja in das HTML rausrendern, weil die Klassen müssen ja
im HTML drinstehen.
Das wird dann da reingerendert, wenn du einfach deine Form erzeugst
und die Form gibst du dem Django View.
So einfach geht das dann aber nicht mehr.
Also wie passiert das denn zum Beispiel, wenn
da halt die Fehler zurückgegeben werden?
Du hast jetzt eine Form, jetzt validiert das nicht, sondern das sind irgendwie Fehler.
Dann nimmt dir die Fehlerklasse
und in der Fehlerklasse hängt ein HTML-Element,
mit dran. Ja, aber das ist aber, ich weiß
das nicht. Das HTML-Element wird gestylt. Das ist nicht einfach
irgendwie eine Fehlerklasse. Doch.
Das ist nicht, das ist doch.
Da wird ganz kompliziertes Zeug gemacht. Da werden
diverse Klassen hinzugefügt, diverse Sachen
geändert. Und das musst du auch machen,
sonst geht das nicht gut aus hinterher. Ja, aber du kannst ja
überschreiben, glaube ich.
Ich hatte irgendwie mal ein paar Sachen customised,
das ging. Ja, man kann so ein bisschen
customisen, aber naja, okay, keine Ahnung.
Also wie gesagt, also dieses Problem hast du, wenn du
das halt, wenn du das HTML verändern
musst, wenn du jetzt einen Fehler renderst.
dann musst du das irgendwie machen, wie auch immer du
machst, aber du musst es ja irgendwie tun. Und das ist
nicht so, dass da irgendwas in Django drin wäre, was dir dabei
hilft, sondern da musst du halt dann irgendwie Crispy Forms
nehmen oder irgendwas anderes, was das halt für dich macht.
Und das ist halt nicht so ganz
einfach. Während wenn du jetzt, sag mal so, du hast jetzt
getrenntes CSS, ja, und
du hast halt da definiert, wie dein
ganzer Kram halt so aussieht und
da setzt du halt, dann sagst du ja
Fehler, rennst aber ganz normales
semantisches HTML raus, ohne
das, dann hast du sozusagen in deiner Applikationslogik
irgendwie kein Problem damit, dass
du da irgendwie komische Dinge,
Klassen auf HTML-Geschichten setzen
musst und so, sondern dann sagst du
halt irgendwie nur, das ist mein
Standard. Ich weiß nicht, was von Django
dann zurückkommt, was da für eine Klasse gesetzt wird oder wahrscheinlich
irgendwas. Und dann zahlst du das
in einem CSS und fertig.
Das macht es dann halt deutlich
einfacher. Aber ich weiß es noch nicht. Ich muss mal
gucken. Ich habe keine Ahnung.
Damit muss man sich beschäftigen.
Da muss man so ein Template wieder bauen für HTMLX und Django.
Also, eine
Geschichte.
Ist halt, ich weiß nicht, SQL-Model, sagt ihr ja vielleicht auch.
Es gab ja auch letztens eine Episode zu irgendwie wieder auf TalkPython2Me.
Und das versuche ich ja gerade zu entfernen, zum Beispiel aus dem Fast Deploy.
Und der Grund ist, weshalb ich das versuche zu machen,
ist, dass ich versuche, mal das so ein bisschen umzuorganisieren.
Dass halt so ein bisschen Software-Architektur reinkommt.
Ich weiß es auch nicht unbedingt jeder Manns Sache.
Ich habe auch früher mal schon gedacht,
das ist auch vielleicht jubiliert.
Das schnürt mir schon, wenn ich das Wort ausspreche,
irgendwie die Krawatte, die Luft ab.
Der Architekt, ein feiner Herr.
Aber vielleicht gibt es Situationen,
in denen das doch nicht so verkehrt ist.
Und ich wollte es einfach mal so ein bisschen ausprobieren.
Und deswegen mache ich das da jetzt.
Und genau, da ist ja immer so...
Was ist denn Architektur, Software-Architektur überhaupt?
Naja, es ist im Wesentlichen quasi die Beschreibung
für die Tätigkeit, die man halt
ausübt, wenn man
Software versucht zu modularisieren,
also so in Teile zu zerlegen, dass man nur noch
irgendwie, dass die
Gesamtkomplexität nur noch dominiert
wird von der Komplexität des
kompliziertesten, komplexesten
Moduls und nicht mehr alles mit
allem zusammenhängt, sozusagen. Und
die Art, was man macht, wenn man das jetzt
tut und versucht, das klein zu hauen, das
nennt man halt Softwarearchitektur, sag ich jetzt mal so.
Also, es gibt da,
das wäre jetzt meine aus der hohlen Hand
Definitionen. Es gibt ja Leute, die versucht haben, das ernsthaft
zu definieren, wie so Martin Fowler
und so, die würden sowas sagen wie
Software-Architektur sind alle die
grundlegenden
und schwer änderbaren Entscheidungen,
die
ich weiß nicht, ob ich die Definition richtig zusammenkriege,
die Einfluss dann halt
auf das Projekt haben und die dazu führen,
ob man jetzt irgendwie Dinge schneller ändern kann
oder nicht. Kann man auch kritisieren,
es ist so wichtig,
ob man Code hinterher ändern kann oder nicht.
was sind das denn eigentlich, wenn man weiß, dass es wichtig ist,
dann hat man ja schon den Teil der Software-Architektur
irgendwie erledigt im Grunde.
Man weiß halt vor allem bei den Entscheidungen halt dummerweise
leider vorher meistens nie, ob die jetzt wichtig sind oder
nicht. Aber das ist halt
eine Definition. Ich glaube, ich habe die von,
die haben auch andere Leute so ähnlich
auch schon gebracht.
Mir gefällt
die irgendwie, wie zerlegt man
eigentlich ein Programm in kleinere Teile
ein bisschen besser.
Aber ja gut, ist halt ein bisschen
Geschmackssache, aber im Grunde irgendwie so, man kann sich
das auch vorstellen, ja, wie wenn man ein Haus
Architektur hat, dann kann man auch für ein Softwareding
Architektur haben. Also Microservices
für so Häuser breitstellen, also jedes
Mal auf seinem eigenen. Microservices wäre
halt ein Ding, wie man
also, aber Architektur bezieht sich jetzt nicht
auf das, auf den
IT-Teil, nicht auf das System,
sondern eher auf die
Software. Also du kannst natürlich
auch, ich meine, das sind halt eher so die Dinge, wo ich
das Gefühl habe, das geht dann halt schief, wenn
Leute das
Software-Problem, weil sie es
irgendwie nicht lösen können, das sieht man
übrigens ganz oft, also mir begegnet das
häufig und es ist furchtbar.
Meistens,
also die Konsequenzen sind meistens furchtbar,
dass Leute halt
dieses Modularisierungsding in der Software
nicht gebacken kriegen, aus welchen Gründen auch immer
und dann hingehen
und das versuchen auf einer anderen Ebene zu lösen.
Also auf der Ebene zum Beispiel, was man häufig sieht,
ist, dass die Leute dann versuchen, es organisatorisch zu lösen
oder dass Leute versuchen, es mit
mit IT-Geschichten zu lösen,
wir nehmen jetzt die Cloud, oder
dass Leute es mit Microservices
versuchen und all diese Ansätze
sind eigentlich immer, das scheitert immer ganz
spektakulär, weil
an dem grundsätzlichen
Problem ändert sich dadurch nichts und du hast
dir das Leben halt irgendwie gerade noch mal
in Größenordnung schwerer gemacht, dadurch
dass du jetzt zum Beispiel
ein Park, ein Fuhrpark
ein Zoo
gerade Microservices gab es
auch letztens, habe ich auch letztens
eine Podcast-Episode darüber gehört, mit dem
es gibt ein Buch, das irgendwie alle immer
referenzieren, was Microservices angeht.
Und
der sprach dann halt auch so drüber,
der hat das Buch geschrieben und meinte so,
ich bin ein bisschen unglücklich, ich gelte jetzt immer als Experte
für Microservices, jetzt, weil ich dieses Buch geschrieben habe, na gut.
Und der meinte,
er macht halt viel Consulting irgendwie
und wird eigentlich immer dazu gerufen, wenn
irgendwelche Leute auf die Idee gekommen sind, wir müssen jetzt mal
auf Microsoft-Architektur umsteigen.
Und dann holt man sich halt irgendjemanden dazu,
der dann sagen soll, warum das irgendwie alles eine super
Idee war. Und dann sitzt
er dann immer und meint so, hm,
das ist vielleicht gar nicht so eine gute Idee
in eurem Fall.
Und das macht
ihn halt nicht unbedingt beliebt, aber er versucht das dann irgendwie
so diplomatisch zu verpacken. Aber er meint so, ja,
ganz oft ist es halt so, dass Leute das dann so
probieren, aber eigentlich
sollte man vielleicht andersrum anfangen und eher Monolith
nehmen und dann halt, wenn man
dann auf bestimmte Probleme stößt, die man
anders nicht mehr lösen kann, dann Microservice
ist dann vielleicht eine
Möglichkeit unter Umständen.
Aber damit anzufangen,
ohne zu wissen, was man jetzt eigentlich
machen möchte, das ist vielleicht nicht so eine gute Idee.
Also wenn man jetzt halt vorher schon
ein Problem mit der Modularisierung hatte
und dann auch noch
Microservices dazu nimmt, dann hast du halt hinterher
einen distributed ball of mud sozusagen.
Also das Problem
an
Modularisierung
kann sein, dass man verschiedene Stellen hat, an denen man Dinge
pflegen muss?
Ne, Modularisierung ist eigentlich eine gute Sache.
Aber wenn nicht, du hast gerade ein Beispiel gesagt,
du hast gesagt, wenn man Probleme nimmt.
Das ist gut, wenn man das hinkriegt, das ist gut.
Wenn man es nicht hinkriegt, das ist doof.
Also wenn du es nicht schaffst,
sozusagen modulisieren.
Die Dinge voneinander zu trennen.
Ja, wobei jetzt auch nicht Trennung beliebig super ist.
Also natürlich kann man das auch falsch machen,
in dem Sinne, dass man halt das an den falschen Stellen trennt,
irgendwie in der falschen Granularität trennt.
Das ist natürlich nicht schlecht.
Und wenn man jetzt sozusagen es aber gar nicht schafft,
das zu trennen und sagt, wir machen jetzt aber Microservices,
um die Sachen, wo wir es halt falsch getrennt haben,
nochmal zu zementieren, indem wir es auf andere Rechner packen
und in andere Repositories und so.
Und dazwischen halt jetzt Schnittstellen haben,
die wir schlecht ändern können und die, wo
wir Fehlerbehandlung machen müssen und das ist alles ganz, ganz
schrecklich, dann ist das halt
noch viel schlimmer als vorher. Also wenn du vorher das Problem
hattest, du hast es nur in deiner
in deinen Funktionsaufrufen nicht geschafft, das ordentlich
zu trennen und jetzt
hast du es halt irgendwie, diese Funktionsaufrufe
verteilt, aber
du hast es quasi nicht
wirklich modularisiert, sondern du hast ja
Abhängigkeiten immer noch,
dann hast du danach ein viel schwereres
Problem als vorher.
Du hast es nur dann
eine ganze Zeit lang nicht mehr gemerkt, weil
da warst du damit beschäftigt, irgendwie
Kubernetes zu konfigurieren, ja, so ein halbes
Jahr oder so. Und dann nach einem halben Jahr fällt dir
auf, so, das Problem ist eigentlich noch viel schlimmer jetzt als
vorher. Und das ist halt dann,
ja, da bist du in einer doofen Position,
weil da kommst du dann auch nicht mehr so leicht raus.
Und, ja, das ist halt,
genau, ja, das ist halt,
ja, Architektur,
genau, also jedenfalls
damit beschäftige ich mich halt
auch gerade so ein bisschen. Ich meine, da müsste man mal drüber
reden, wenn ich da irgendwie mehr zu weiß.
Ich glaube, da müssen wir auch eine eigene Folge zu machen zur Architektur.
Oder auch
Microservice versus Modulit.
Aufschreiben.
Wenn ihr mich nicht auskennt,
sagt uns Bescheid.
Genau.
Was ich halt gerade versuche, ist halt
mich mit diesem, was macht man
denn eigentlich so üblicherweise,
wenn man jetzt eine Architektur,
wenn man überhaupt so ein bisschen Architektur haben möchte,
wie macht man das denn?
Und zum Beispiel,
Ein schönes Zitat, was es
halt in dem Buch, diesem Software
Architecture Patterns with Python
Buch, das ich da so zu lese,
gibt, ist halt
und
ja, das fällt mir halt dazu,
dann auch allen, wenn man sagt, ja, super,
weil ich kenne das
ganz viele Leute, ah, super,
Microsoft ist voll gut oder sonst wie.
Ja,
das hatte mal, glaube ich,
der Autor von
Clojure,
der Programmiersprache Rick Hickey
oder Rich Hickey, ich weiß gar nicht,
wie heißt der nochmal, hat das gesagt,
meinte so, ja, es gibt immer
unter Ökonomen den Witz,
ja, so Ökonomen kennen irgendwie den
Preis von allem, aber den Wert von nix.
Und für Softwareentwickler
kann man das halt auch anpassen und sagen, ja, Softwareentwickler,
die kennen halt irgendwie
die Vorteile von allem,
ja, oder die Features und die,
aber sie kennen halt irgendwie die
Trade-offs und die Nachteile von nix, ja.
Und das ist halt, das ist so ein bisschen,
das ist halt, da ist was Wahres dran.
zum Beispiel, eben,
das ist da,
wir hatten ja letztes Mal diese Fast-API-Episode
oder so.
Also,
das ist so,
ich weiß nicht, würde
man, auch wenn ich das so,
auch bei TalkPython-Termin oder so, wenn ich das höre,
ich höre immer so, ja, das ist alles voll gut und so.
Aber,
es gibt ja auch Nachteile, die das hat, wenn man das
jetzt so macht. Also wenn man jetzt zum Beispiel sagt,
man nimmt jetzt FastAPI, nehmen wir mal
ein Beispiel, du nimmst halt FastAPI, SQL-Model
und so
und alles funktioniert
mehr oder weniger automagisch.
Was ist der große Nachteil an dieser Geschichte?
Erzähl.
Tja, da würde ich sagen,
eben, da bist du schon typischer Software-Entwickler.
Die meisten würden sagen, ja, das hat doch keinen Nachteil,
das hat doch nur Vorteile. Naja, es hat halt schon
Nachteile und der Nachteil ist halt,
Aber wenn du halt von SQL-Model erbst, dann kannst du das nie wieder ändern.
Wenn du jetzt auf die Idee kommst, wir machen das, oder du stellst halt fest,
du misst das, du hast viele kleine Sachen, die halt serialisiert werden müssen,
das ist halt zu langsam, das funktioniert irgendwie nicht.
Und das ginge besser, wenn ich das jetzt irgendwie mit einem Unpile machen würde
oder keine Ahnung, dann, das kannst du nicht mehr anpassen.
Das ist halt einfach, dann hast du halt mehr oder weniger verloren.
Naja, du könntest ja schon Export der Daten machen und Import woanders herstellen,
man muss dann eine kurze Downtime kaufen und so.
Conversion
dazwischen schreiten. Also irgendwie geht das ja schon.
Wenn dann eine Business-Logik
da drin hängt
und du hast von SQL-Model geerbt
oder von
Pidentic, irgendwie von den Base-Models, da kannst du
nicht mehr viel machen. Das ist halt
das Problem. Du hast halt, oder
sagen wir mal so, ich will gar nicht
auf Fast-API rumhacken oder so. Also ich meine,
dieser Ansatz ist ja durchaus verbreitet.
Bei allen Frameworks ist es halt so, du
erbst von irgendwas und dann
hast du halt viel mehr Fähigkeiten
und hast halt in kurzer Zeit sozusagen
in Anführungsstrichen viel geschafft, aber du kannst es halt auch
nicht mehr ändern. Wenn du das in Django machst, ist das das gleiche
Problem. Wenn du in Django irgendwie
erbst du ja von Models
Punkt irgendwas Model und
hast da deine Fields und so. Was ist denn
jetzt, wenn das aus irgendwelchen Gründen nicht mehr gut auf deine
Anforderungen passt?
Da musst du halt umziehen. Ja, aber das geht quasi nicht.
Endpunkt pro Endpunkt.
Funktioniert nicht gut. Das kannst
du praktisch nicht mehr ändern. Also da würde ich sagen, der
der große Nachteil, also du kaufst
dir eine Menge, du kriegst halt viel
Magie einfach so ganz schnell und
es funktioniert ganz viel. Der große
Nachteil, den du dir einkaufst, ist, du kannst
das nicht mehr ändern. Wilde Magie.
Du hast dich ganz eng an dein Framework
gekoppelt. Das ist die engste Kopplung, die es
überhaupt gibt, von irgendwas zu erben.
Und
jetzt eben sozusagen
diese klassische Software-Architektur
würde halt sagen, ja, Frameworks sind nicht deine
Freunde, sei vorsichtig, wenn du von
irgendjemandem erbst. Das ist immer,
du koppelst dich da ganz eng. Also all diese
Sachen von Sachen erben, Sachen importieren,
alles vielleicht nicht so gut,
weil das lässt sich hinterher alles verändern. Ja, aber alles selber machen
ist halt auch irgendwie ein bisschen Quatsch. Das musst du ja nicht.
Du könntest zum Beispiel stattdessen Software-Architektur machen.
Ist halt die Frage. Okay, du meinst, du kannst es krapseln
dann? Du machst, also da
kannst du es halt so machen, dass
zum Beispiel dein Kern, deine
Applikation halt von überhaupt nichts
abhängt, von nichts erbt und auch nichts importiert.
Aber es braucht einen Händler für
Speichern von Daten.
Ja, aber den kannst du ja reinreichen sozusagen.
Genau, aber das ist dann eine Dependency Injection.
Habe ich das jetzt richtig?
Ja, ja, ja, genau.
Du würdest die Dependencies umdrehen.
Du würdest halt sagen,
der Kern meiner Software basiert halt
oder hängt halt ab von anderen Sachen,
sondern du würdest sagen, man dreht das halt um
und sagst, die anderen Sachen hängen halt von meiner Software ab.
Und als Mittel, um das zu erreichen,
könnte man Dependency Injection zum Beispiel verwenden.
aber das muss man ja auch nicht automatisch, also Dependency
Injection oder
Dependency Injection Frameworks,
da wird das ja quasi
so ein bisschen automatisiert.
Man kann das ja aber auch manuell
machen. Also manuell heißt das
eigentlich, du machst das so, dass du
hast halt dann
quasi Schnittstellen oder irgendwelche abstrakten
Interfaces, von denen du
halt, die du halt sagst, okay, das ist halt
das, was hier, dir wird zum Beispiel
so eine
in eine Datenbank
ein Repository.
Das sagt gar nicht, was das für eine Datenbank
ist, sondern wird halt reingereicht,
dass es bestimmte Methoden
hat und eine bestimmte Schnittstelle hat.
Also quasi Abstract-Base-Class mit
Methoden zu implementieren,
die man dann verwenden muss als
Injection und die man dann, wo dann
klar ist, okay, das muss jetzt so und so implementiert sein,
egal wie du das löst, ist mir wurscht, aber Hauptsache, du stellst
diese Interfaces für mich bereit,
die benutze ich dann einfach und Input, Output sind vordefiniert.
Und man dependet dann eben auf diese abstrakte
Schnittstelle und nicht auf eine konkrete
Implementation. Das habe ich tatsächlich auch schon mal
gemacht. Ja, das ist ja
schon irgendwie so richtig, ist doch für Architektur.
Ja, genau. Und dann kannst du mich jetzt
Architekt nennen. Ja, ich glaube, das darfst
nicht jeder. Das ist gar kein Problem.
Hast du ja alles schon gesehen, welche Leute sich Architekt genannt haben.
Ja, Informatiker glaube ich auch nicht.
Ich glaube, du darfst dich nicht
Diplom-Informatiker nennen, aber
Informatiker ist...
Ja, ist auch wurscht.
Genau.
Jedenfalls, wenn du halt auf diese
Abstraktionen dependest und nicht
auf irgendwas Konkretes, dann kannst du halt das,
die konkrete Implementation
dieser Schnittstelle halt
austauschen. Wenn du ein Repository hast, das halt
irgendwie SQL-Alchemy war, kannst du sagen, okay, ich nehme
jetzt ein Django-Repository
stattdessen und dann merkt deine
Applikation gar nicht, dass das geändert wurde.
Der Nachteil ist
halt irgendwie Django-ORM und so, das ist ja schon
nett, du sparst ja halt viel Arbeit.
Du musst halt dann nochmal selber bauen, die ganzen Methoden,
die es da halt gibt quasi. Und dann halt quasi,
du musst einer die abstrakte Klasse bauen, die musst du dann
für deine Sache implementieren.
Wenn du das mit dem Django-ORM nutzen willst, dann musst du quasi den Händler
dafür schreiben für deine abstrakte Klasse, die dann
den Django-ORM benutzt, damit die Methoden,
die du dir bereitstellen willst, auch dann darüber gehen.
Ja, also sagen wir mal so, du verlierst halt
einen Großteil der Gründe, warum man
jetzt... Convenience. Der Convenience,
den verlierst du tatsächlich, das ist halt so.
Dadurch, dass du halt
Django austauschbar machst oder Fast-API
austauschbar machst, ich habe das
überlegt, zum Spaß könnte man eigentlich
noch einen Flask, irgendwie Entrypoint
davor hängen, sozusagen, wenn ich damit
fertig sein sollte. Und das wäre praktisch
kein Problem, das zu machen. Ich könnte halt
Flask gegen Fast API austauschen oder umgekehrt
oder Django, das wäre alles kein großes Problem.
Aber man hat halt auch die ganzen Vorteile dann nicht mehr.
Das ist halt der Nachteil.
Aber, ja,
ich wollte es einfach mal ausprobieren, deswegen habe ich da so ein bisschen
mit angefangen. Und,
ja,
aber man sollte sich halt,
wenn man jetzt ihm
diesen Weg geht und sagt,
ich nehme einfach ein Framework, dann ist alles schnell.
Ich wusste, dass man das Software-Architektur
nennt und so ein bisschen Hochtraben
überlegt.
Ja, aber man muss halt
entsprechend verfolgen. Ja, abstrakte Infrafaces
bauen, damit man so ein bisschen die
Dependency-Injection auslagern kann
und damit man reduziert die Abhängigkeit
in seine eigenen
Codes von anderen Dingen
und die einfach austauschen kann. Also dieses Pattern
der Dependency-Injection in diesem Fall, mit diesem abstrakten
Ansatz, ist glaube ich eine richtig gute Idee,
wenn man Skalierung möchte in irgendwann
Ja, es hat halt auch so Vorteile. Also es hat halt den Vorteil, dass du dann eben flexibel diese Sachen aushauschen kannst und so und dann halt nicht davon abhängst, dass wenn irgendeiner von deinen Defenses sich nicht so gut weißt und du willst was anderes machen, dann kannst du das halt tun.
Auf der anderen Seite ist es halt, wenn du weißt, dass du das nie musst und dass es auch egal ist, also wenn du zum Beispiel eben klassische Crud-Geschichte hast, die relativ einfach ist, dann macht das keinen Sinn, da viel Architektur zu machen, weil das ist sowieso egal.
genau, ich mache es jetzt auch nicht, weil es nötig ist, sondern einfach
nur, um zu verstehen, wie das alles funktioniert.
Ich habe genug Zeit und mache da so schöne
Sachen.
Genau, ich mache das nur, weil es Spaß macht.
Das ist auch ein Selbstzweck.
Ja, vielleicht noch erzählen
wollte, dass, weil
es tut mir gerade so, da ich
immer so viel Webentwicklung mache, fehlt mir
halt dieser ganze Machine Learning Teil
so ein bisschen. Ich bin da momentan auch nicht
so richtig auf dem Laufenden. Ich habe letztens wieder
einen Podcast gehört, da war so, oh krass, was da
alles so passiert, da wusste ich
ja gar nichts von, also
ich kann auch sagen, dass ich jetzt
ein bisschen Unsinn erzähle, weil ich da nicht mehr so richtig drinstecke,
aber vielleicht ist das ja interessant, also mich hat es auf jeden Fall überrascht.
Also einmal
gibt es halt jetzt die Bestrebung, also
das kennst du ja wahrscheinlich auch, es gibt so große Modelle,
die trainiert werden, auf irgendwie
self-supervised trainiert werden, auf quasi
im Internet zum Beispiel, Language-Modelle gibt es da,
diese GPT-3
und so was, ja.
Und
die machen ja alles irgendwie so ein bisschen
besser, wenn man jetzt irgendwie die verwendet
und
dann sozusagen
das eigene Problem darauf
feintunt irgendwie.
Und das dachte ich auch immer so,
das ist der Hauptvorteil, den man da hat,
wenn man den Kram verwendet, aber tatsächlich
können die halt noch eine ganze Menge mehr und das war mir
so gar nicht so richtig klar.
Zum Beispiel bei GPT-3
ist es halt so, du kannst halt auch so Dinge
machen wie Zero-Shot-Learning oder
Few-Shot-Learning, also gar nicht irgendwie, du feintunst es
nicht mit ein paar hunderttausend, was auch immer
Beispielen, sondern
du sagst zum Beispiel GPT-3 einfach so
irgendwie, dein Job ist jetzt
Übersätze von Englisch nach Deutsch. Und dann
tut es das einfach so, ohne dass du ihm irgendwelche
Trainingsbeispiele gezeigt hast. Oder du
sagst ihm, dein Job ist jetzt
Übersätze von Englisch nach Deutsch und
gibst ihm halt noch drei, vier Beispiele.
Und dann geht das auch schon ganz gut.
Und das ist halt schon krass.
Und für viele andere
Tasks geht das auch. Ich glaube, da gibt es dann auch wieder die Frage,
wie man das nennt, dann Instruction-Based
Learning oder Zero-Shot Learning
oder so. Die KI schon Conscious
ungefähr, ja. Ja,
das weiß ich nicht, aber
es ist auf jeden Fall beeindruckend, was damit geht
und es gab dann halt so, tatsächlich,
das wusste ich überhaupt nicht, dass das existiert,
was dann Leute, die dann meinten,
also, es gibt inzwischen so
den Job quasi mehr oder weniger von Leuten,
die sich halt überlegen, wie sie
Anfragen an das Modell formulieren, dass da irgendwas,
was sie dann hinterher verwerten können, dabei rauskommt, weil man muss
da auch so ein bisschen aufpassen und rumtricksen
und welche Beispiele gibt man dann, um das halt noch ein bisschen
zu verbessern. Und da kann man
halt solche, diese großen Modelle wohl
dazu bewegen, Dinge zu tun,
die ganz erschaunlich sind.
Genau, beim Co-Pilot ist das auch so ein bisschen so.
Co-Pilot ist auch so, ja.
Gute Beispiele gibt es, also gute Methoden und so, gute Namen,
gute Argumente, gute Docs, lernt er sehr gut
draus. Also, wenn man das in einem Projekt mal so konstant hat,
da ist es echt Gold wert.
Ja, genau. Und
ja, habe ich jetzt auch letztens gehört,
genau, ist die Frage, wie nennt man
das jetzt eigentlich? Weil all die
Sachen, wie man das früher genannt hat, das trifft es eigentlich nicht.
so Pre-Train-Modelle, das
klingt irgendwie so ein bisschen, als wäre dann schon alles
passiert,
aber das trifft's ja nicht,
weil man muss ja jetzt mit dem Ding noch irgendwie so lange
interagieren, bis man das dazu gekriegt hat, dass das macht, was man
eigentlich möchte, also
einfach nur
was waren noch die,
Self-Supervised ist halt auch nicht so ganz richtig, weil es ist
nicht immer Self-Supervised. Wir müssen dazu auch noch
eine Machine Learning-Folge machen, glaube ich, das hört sich sehr interessant an.
Ja, aber da brauchen wir auch jemanden, der sich damit
wirklich auskennt, nicht so der
ein paar Bauchklassen gehört hat, wie ich.
Und
also unklar, es gab jetzt den Vorschlag,
glaube ich, von Stanford oder so,
wo sie gesagt haben, lass uns die Dinger doch
Foundation Models nennen.
Weil das macht das ein bisschen
klarer, weil wir wissen auch nicht so genau,
wie das jetzt, es wird halt auch
für Bilder gibt es das noch nicht so richtig, aber es sieht
so aus, als ob das jetzt auch
in die Richtung läuft, dass man das irgendwann mit Bildern
und auch vielleicht mit Videos machen kann und dann
werden da auch mal sehr
interessante Sachen gehen.
und vielleicht ist es eben auch nicht nur
selbstsupervised, vielleicht kann man auch irgendwie bei ImageNet
oder so hat man ja rein supervised
irgendwie sozusagen, kann man ja auch benutzen
aber wir haben auf jeden Fall
irgendwie so eine Klasse von Modellen, die sind sehr groß und mit denen
kann man irgendwie interessante Dinge tun und das ist so ein bisschen unklar
aber es sind irgendwie die
Foundation für alle möglichen anderen Dinge, die man
damit macht, also lass uns die doch Foundation Models nennen
und sozusagen da irgendwie die ganzen
Themen, die halt jetzt da dran hängen
halt irgendwie mit
mit Abflussstücken
Und die Idee fand ich eigentlich gar nicht so schlecht.
Ich bin mal gespannt, ob sich das durchsetzt.
Ja, und
genau. Ja, und dann
ist es halt so, dass auch der
Fortschritt in dem ganzen Deep Learning-Bereich
war in letzter Zeit so stark.
Das konsolidiert sich jetzt auch alles so ein bisschen.
Finde ich auch ziemlich
cool. Da gibt es halt irgendwie
Leute, die auf
GitHub irgendwie
jetzt die ganzen Sachen polieren.
Also das hatte ich früher auch mal so, wenn man sich jetzt anguckt,
diese ganzen Leute, die in diesem
Forschungsumfeld tätig sind, also wenn man sich
den Code anguckt,
ist halt oft
theoretisch
sehr avanciert und irgendwie
Leute machen sich da viele Gedanken und so,
sind sehr kreativ und
machen irgendwie krasse Mathematik,
aber irgendwie jetzt so den Code, den sie
schreiben, ist manchmal schon so ein bisschen, also da geht
auf jeden Fall noch was.
Das ist jetzt lieb ausgedrückt. Ja, ich meine, klar,
man kann ja auch nicht in allem gut sein, das ist halt irgendwie so,
man muss sich auf irgendwas beschränken
und aber da ist auf jeden Fall noch nicht
so das Ende der Fahnenstange erreicht und
was ich jetzt interessant fand, ist
dass halt da jetzt Leute gibt, die
aus dem Softwareentwicklungsbereich kommen,
die sich das angucken und sagen, das ist ja, da kann man
ja noch was machen und das hat
jetzt wieder Einfluss auf die Forschung.
Zum Beispiel eben aus der
Kegel-Ecke kommen da einige,
also Competitive Machine Learning
oder halt auch aus der Industrie.
Es gibt da zum Beispiel einen, Ross Whiteman,
der
sich diese ganzen Standard-Image-Modelle
mal nochmal angeguckt hat
und der
dann im Wesentlichen rausgefunden hat,
so, naja,
also das, was ihr sagt, also
der State-of-the-Art sozusagen
für den Score auf bestimmten Problemen,
jetzt nehmen wir ImageNet oder so,
der
wurde ja ermittelt
für bestimmte Modelle vor ein paar Jahren.
So,
inzwischen hat es aber nicht nur Fortschritte
bei den Modellen gegeben, also wie ist die Architektur der Modelle
oder so, sondern halt auch bei den, ja,
das ist aber, das spielt alles nicht so eine große
Rolle, weil man kann eh nur kleine Bilder nehmen,
weil irgendwie die Datenmengen halt sonst
irgendwie schwierig für die Modelle werden,
aber, nee, wo sich
was getan hat, ist zum Beispiel sowas wie,
wie trainiert man die Dinger eigentlich, also
wie sind die Hyperparameter, mit
denen man, die man
benutzt zum Trainieren, wie,
da gibt es halt auch eine Menge Zeugs.
Es klingt wirklich so, also das ist ja super interessant
alles, aber ich glaube, wir sind jetzt in der,
so oft hin und her gesprungen, dass wir da
unbedingt nochmal genauer drüber reden müssen in einer eigenen
Episode, weil das, ja,
ich finde es sehr spannend und ich glaube,
das war aber komplett off-topic. Ich glaube, die Leute, die vorher
das interessant fanden bei CSS, waren jetzt bei Machine Learning
nicht mehr dabei und andersrum waren die
wirklich gespannt.
Ja, wir machen auf jeden Fall noch eine Episode
dazu, das ist versprochen. Ihr seht, Jochen ist ja auch sehr
belesen und ich finde das
auch super interessant. Ich finde das super interessant.
Vielleicht nochmal kurz zum Abschluss zu bringen. Also es ist auf jeden Fall
so, dass jetzt, dass man sagt, dass der
quasi gedacht hat, also wenn man jetzt die ganzen
Fortschritte, die es in anderen Bereichen gibt, jetzt nochmal mit
den alten Modellen zusammennimmt, dann stimmt
die Baseline nicht mehr. Es ist halt nicht so,
dass die Modelle von damals schlecht
wären. Es ist nur so, dass die Methoden, mit denen
wir die trainiert haben damals, sind halt vielleicht nicht so gut gewesen.
Wenn wir die heute mit den besseren Methoden trainieren,
dann upsala, für manche Probleme sind die doch
wieder state of the art.
Und dann, ja,
also sehr, sehr
coole Sachen und ja,
da gibt es viel zu erzählen.
Ja.
Ja, ich glaube, dann haben wir jetzt
quasi, das war das letzte Thema, glaube ich, was auf deiner Liste
stand, was du noch...
Ja, ich glaube, wir haben
heute genug Kuddelmuddel-Salat
aufgetischt. Ja gut, alles klar.
Genau, ja, ich weiß nicht,
jetzt haben wir das Problem,
aber jetzt bist du dran, jetzt muss ich erst mal meinen Pick wieder
nachgucken, den du mir ja versaut hast.
Was würdest du denn picken?
Ich muss was picken, in dieser Folge schon wieder.
Ich weiß nicht, wo könntest du?
Ja, ich picke Critical Role.
Das ist eine wunderschöne Serie, die auf
Prime läuft, über D&D.
Falls jemand
sich für D&D interessiert, es gibt ein
Vodcast von
Matthew Mercer dazu,
der Critical Role heißt und
der hat eine Kampagne mit seinen SpielerInnen
gespielt,
Vox Machina und diese Vox Machina
ist jetzt auf Prime Machine.
Es war eigentlich
gar nicht geplant, als Fernsehserie natürlich,
aber irgendwer sagt, ach, total toll,
was wir hier machen, also das sind alles so Voice Actors und so,
macht total Spaß, eigentlich sollte
mal jemand einen Comic draus machen, dann hat irgendwer gesagt,
ach, naja, kein Comic, ja, vielleicht doch,
ja, da brauchen wir doch irgendwie Geld für, ja, dann lass doch einen Kickstarter
machen, meint dann irgendwer, dann sagt er, ach,
hat irgendwer einen Kickstarter gemacht, 48 Stunden
später irgendwie 11 Millionen Dollar oder so eingenommen,
dann haben die gesagt, so, hey, yo, wir machen
doch so eine Serie
und dann hat Amazon gesagt, oh, wir kaufen's
und hat direkt die Staffeln da veröffentlicht
und die laufen jetzt tatsächlich auf Prime,
glaube ich, die erste Staffel gerade rum und das ist D&D,
Eine Abenteurergruppe, die es live gab quasi,
gibt es auf YouTube, kann man die echten Abenteuer nachholen.
Also eine Folge ist, glaube ich, so dreieinhalb
bis vier Stunden oder sowas und die haben, glaube ich,
150 Sessions abgehalten für diese Kampagne.
Es ist also ein bisschen verkürzt
dargestellt, aber
ja.
Wo wir eben bei
Jackshaving waren, was man alles
verbessern und optimieren kann und wie tief das
Material jeweils ist. Aber egal, nur ein kleines
bisschen was Privates.
Jochen, dein Pick?
Ja, ich habe jetzt versucht, den
gerade zu finden. Ich habe ihn nicht mehr gefunden.
Aber ich kann ihn beschreiben und ich
reiche den Link dann in den Show Notes nach. Es gibt
Rich, also es gibt ja
Typer, das macht auch schon eine Menge
so Command-Line-Geschichten. Es basiert
aber auch auf Click. Genau. Und es gibt
jetzt auch irgendwie Rich-Click oder ich weiß jetzt eben nicht,
wie man es hinschreibt, aber wo man
sozusagen Click und Rich
ganz nett kombiniert hat und das sah
sehr gut aus und das war dann mein Pick.
Interessant. Cool.
Ja, super. Dann vielen Dank, dass ihr wieder eingeschaltet
habt. Bleibt uns gewogen.
Ich hoffe, ich darf diese Episode nicht
ganz so verstören wie uns.
Und schreibt beim nächsten Mal wieder ein.
Und ja, wie gesagt, schreibt uns gerne
alles, was euch beschäftigt an
hallo-at-pyson-podcast.de
Bis zum nächsten Mal.
Bis dann. Tschüss.