#121 YAML: Mehr als Konfiguration! Aliases, Tags und YAMLScript mit Tina Müller

Wenn du glaubst, dass du YAML kennst …

„YAML Ain’t Markup Language“ (ursprünglich „Yet Another Markup Language“) kennen viele nur als Sprache für Konfigurationsdateien. Laut dem Gründer von YAML ist das Format aber nicht dafür gedacht. Und überhaupt nutzen sehr viele Tools nur einen Bruchteil der Fähigkeiten von YAML. Welche das sind, hat uns Tina Müller erklärt. Tina ist u.a. Contributorin zur YAML Spezifikation und gibt uns mal einen Einblick in das Serialisierungs-Format.

Wir sprechen über darüber, welches Problem YAML lösen wollte, wie es in der Realität genutzt wird, wie YAML selbst sowie die YAML-Parser in verschiedenen Sprachen weiterentwickelt werden, über die Flaws von YAML, wie zB. das Norway Problem oder die Billion Laughs Attacke und schauen mal welche Features nicht so bekannt sind, wie YAML tags, aliases oder YAMLScript.

**** Tue was Gutes mit deiner alten Hardware – Computertruhe.

Du hast noch alte Computer-Hardware rumfliegen? Anstatt diese zu verschrotten oder für 20€ bei Kleinanzeigen zu verkaufen - Tue was gutes und Spende diese an die Computertruhe

Die Computertruhe ist eine gemeinnützige Organisation, die Computer für bedürftige Menschen bereitstellt.

Alle Infos unter https://computertruhe.de/

********

Das schnelle Feedback zur Episode:

👍 (top) 👎 (geht so)

Sprungmarken

(00:00:00) YAML mit Tina Müller

(00:06:27) Was ist YAML und wie zeichnet sich YAML aus?

(00:09:19) YAML, JSON und die Abgrenzung zu anderen Formaten

(00:11:00) Computertruhe e. V. (Werbung)

(00:12:37) YAML, JSON und die Abgrenzung zu anderen Formaten

(00:28:56) YAML-Spezifikation

(00:33:22) YAML-Testsuite

(00:39:24) Das Norway-Problem

(00:44:39) YAML-Features: Aliases, Anchors und YAMLScript

Hosts

Wolfgang Gassler (https://mastodon.social/@woolf)
Andy Grunwald (https://twitter.com/andygrunwald)

Feedback

EngKiosk Community: https://engineeringkiosk.dev/join-discord
Buy us a coffee: https://www.buymeacoffee.com/engineeringkiosk
Email: stehtisch@engineeringkiosk.dev
LinkedIn: https://www.linkedin.com/company/engineering-kiosk/
Mastodon: https://podcasts.social/@engkiosk
Twitter: https://twitter.com/EngKiosk

Transkript

Das Transkript wurde automatisiert per Speech-to-Text erstellt und kann daher Fehler enthalten.

Andy Grunwald (00:00:03 - 00:00:59)

Wenn du glaubst, dass du YAML kennst, dann solltest du dranbleiben. YAML Ain't Markup Language, ursprünglich Yet Another Markup Language, kennen viele nur als Sprache für Konfigurationsdateien. Laut dem Gründer von YAML, ingi.net, ist das Format aber nicht dafür gedacht. Und überhaupt nutzen sehr viele Tools nur einen Bruchteil der Fähigkeiten von YAML. Welche das sind, hat uns Tina Müller erklärt. Tina ist unter anderem Kontributorin zur YAML Spezifikation und gibt uns mal einen Einblick in das Serialisierungsformat. Wir sprechen darüber, welches Problem YAML lösen sollte, wie es in der Realität genutzt wird, wie YAML selbst sowie die YAML-Parser in verschiedenen Programmiersprachen weiterentwickelt werden, über die Flaws von YAML wie zum Beispiel das Norway-Problem oder die Billion Love Attack und schauen, welche Features nicht so bekannt sind wie YAML-Tags, Aliases oder YAML-Skript. Also, bleibt dran, los geht's!

Wolfi Gassler (00:01:02 - 00:02:43)

Fendi, du kannst dich vielleicht noch erinnern, wir haben mal vor vielen, vielen Jahren gemeinsam einen Hackathon absolviert und waren zufälligerweise in einem Team. Vielleicht war das auch der Fehler damals. Auf jeden Fall kann ich mich noch gut erinnern, ich hatte damals die Aufgabe, ein YAML-Dokument zu schreiben, irgendwie ein Config-File oder so und hatte ziemliche Probleme damit. Es wurde irgendwie nicht akzeptiert, irgendwie durch den Linter kamen schräge Fehlermeldungen raus und dann kamst du und sagst, Lass mich mal hin, du hast keine Ahnung von YAML. Nach 20 Minuten konntest du das Problem auch nicht lösen und dann kam unser dritter Kollege aus unserem Team, der Senior Engineer, weil wir waren ja damals Engineering Manager, und der sagte, okay, ihr Managementleute, geht mal weg von dem Computer, lasst den Profi ran. Nach 20 Minuten konnte der auch den Fehler nicht finden und wir haben dann irgendwie teilweise Zeile für Zeile rauskopiert. Wir haben bis heute nicht genau verstanden, was das Problem ist. Vielleicht habe ich dadurch auch irgendwie ein Problem mit diesen Whitespace-Formaten. Also ich gebe es zu, ich bin kein großer Freund davon. Aber jetzt bei der FOSDEM, vor ein paar Wochen eigentlich, war ich bei einem Talk von der Dina Müller über YAML. Und ich habe mir schon gedacht, wie kann man einen Talk halten, nur über so ein Textformat, über ein Format. Und sie hat begonnen den Talk, indem sie gesagt hat, sie ist süchtig nach YAML. Vielleicht hat sie einfach eine Schwäche für falsch verstandene Sprachen. Und genau das hat mich dann interessiert, warum ich oder wahrscheinlich auch viele andere die Sprache falsch verstehen, missverstehen. Und dann habe ich mir überlegt, das Einfachste ist eigentlich, wir fragen die Tina gleich direkt selber und lassen uns erklären, warum wir die Sprache falsch verstehen. Und daher willkommen, Tina, bei uns im Podcast. Cool, dass du dabei bist und uns mal erklärst, wie YAML funktioniert.

Tina Müller (00:02:43 - 00:02:44)

Ja, hallo.

Andy Grunwald (00:02:44 - 00:03:42)

Ja, auch danke von mir, dass du dir die Zeit nimmst. Klassischerweise stelle ich die Leute vor und das möchte ich natürlich bei dir auch tun. Wer ist also Tina? Tina hat, wie gesagt, auf der Ausdäm 2024 ein Talk über Do you know YAML? oder How well do you know YAML? gehalten. Du wohnst in der deutschen Hauptstadt, in Berlin. Du bist Softwareentwicklerin bei SUSE und arbeitest da hauptsächlich am OpenQA-Projekt, was ein automatisiertes Testing für Operating Systems ist. Dadurch habe ich auch gelernt, es gibt eine .qa-Top-Level-Domain. Das war mir vorher auch noch nicht bewusst. Und im Vorgespräch haben wir auch herausgefunden, woher die Domain kommt, nämlich aus dem Land Katar. Wieder was gelernt. Du bist seit 1998 in der Perl-Community zu Hause. magst also in irgendeiner art und weise dann auch kamele du bist über 15 jahre open source contributorin und seit ein paar jahren beschäftigst du dich mit dem textbasierten dateiformat jammel jammel oder wie man es auch immer ausspricht schauen wir gleich.

Wolfi Gassler (00:03:42 - 00:03:46)

Mal bitte süchtig süchtig war das Und.

Andy Grunwald (00:03:47 - 00:04:15)

Du bist natürlich auch Kontributorin in diesem Projekt und da natürlich speziell auch in der YAML 1.2 Library bei Perl, unter anderem bei der C-Implementierung von LibYAML, in der Python-Implementierung PyYAML, aber auch zu der YAML Test Suite, zu der wir später auch noch im Podcast kommen. Und du bist Commentatorin der offiziellen YAML-Spezifikation und dadurch habe ich auch erfahren, dass es eine offizielle YAML-Spezifikation gibt. Stimmt das alles?

Tina Müller (00:04:15 - 00:04:24)

Das stimmt soweit alles, genau. Es gibt eine Spezifikation und die ist sehr lange, also man liest sie normalerweise nicht komplett, wenn man YAML nur benutzen möchte.

Andy Grunwald (00:04:25 - 00:04:30)

Da gehen wir gleich auch mal drauf ein. Meine Intro-Frage ist, und jetzt darfst du mich bitte nicht ganz ernst nehmen, und zwar...

Wolfi Gassler (00:04:30 - 00:04:31)

Das machen wir nie.

Andy Grunwald (00:04:31 - 00:04:48)

Perl ist für mich so die Kunst, das richtige Zeichen auf der Tastatur zu finden. Und ich möchte von dir wissen, welchen Tipp kannst du mir geben, sich in dem Dschungel von Sonderzeichen bei Perl zurechtzufinden? Weil ich hab das Gefühl, wenn ich Perl programmiere, hab ich zumindestens die Möglichkeit, jedes Sonderzeichen auf meiner Tastatur zu nutzen.

Tina Müller (00:04:49 - 00:05:17)

Also ich finde, so viele sind das gar nicht. Es gibt natürlich solche schönen Beispiele auch im Netz, da irgendwie ein Braindump und das führst du aus und das Pearl akzeptiert das als valides Programm. Das ist natürlich ein bisschen übertrieben. Aber diese ganzen Zeichen sind halt nützlich, mit Dollarzeichen und Ad und Hashtzeichen zur Unterscheidung der verschiedenen Typen und so weiter. Und ich glaube, da muss man sich einfach reinarbeiten.

Andy Grunwald (00:05:18 - 00:05:35)

Ich glaube, Perl hat eine große Daseinsberechtigung. Ich glaube, super viele Administratoren machen da immer noch sehr, sehr viel mit. Ich hörte immer mal wieder, dass Booking, glaube ich, komplett in Perl geschrieben sei. OpenQA ist ja auch in Perl geschrieben. Soviel ich weiß, also automatische Testing für Operating Systems ist ja auch jetzt keine Kinderaufgabe, würde ich mal sagen.

Tina Müller (00:05:36 - 00:05:47)

Also zumindest ist das ein Ding, was mir fehlt, zum Beispiel in Python, dass man da zum Beispiel bei der Interpolation oder überhaupt, dass man nicht so gut unterscheiden kann, was ist eine Variable und eine Funktion.

Wolfi Gassler (00:05:47 - 00:05:59)

Ich verstehe sowieso nicht ganz, Andi, weil du kommst aus der PHP-Welt, das heißt Dollar solltest du gewöhnt sein. Jetzt bist du auf der Manager-Ebene, da sollte das Add-Symbol in deinem Outlook ja auch irgendwie vertraut sein. Also eigentlich ist das ja die ideale Sprache für dich.

Andy Grunwald (00:05:59 - 00:06:26)

Ja, aber ich habe auch bei Bash zum Beispiel, hat das Add ja auch eine Funktion bezüglich Arrays oder so? Ich komme halt da auch immer ein bisschen raus und ich muss immer nachschauen, aber ich springe auch zwischen Sprachen und deswegen versuche ich ab und zu, wenn ich etwas in Python geschrieben habe und dann wieder nach Go wechsle, dann merke ich wieder, ah, okay, wir haben ja hier Klammern und dann und so weiter, also ich mixe da auch Dialekte deswegen. Aber ich habe auch, glaube ich, zu wenig Perl in meinem Leben geschrieben, aber ich muss da mal irgendwann wieder ran.

Wolfi Gassler (00:06:27 - 00:06:52)

Aber kommen wir mal von der einen missverstandenen Sprache zur anderen und zum eigentlichen Thema, zu YAML. Jetzt, wenn du die Spezifikationen ja auch in- und auswendig kennst demnach, wie wahrscheinlich wenige, aber wie würdest du denn grundsätzlich YAML jemandem erklären, der jetzt nicht Cloud Engineer ist und das acht Stunden am Tag irgendwie verwendet, irgendwelche Definitionsfälle schreibt? Also was ist für dich YAML und wie zeichnet sich YAML aus?

Tina Müller (00:06:53 - 00:07:37)

Also da kommt es natürlich schon darauf an, wem ich das kläre. Also ob es auch einen Entwicklerhintergrund gibt oder nicht. Also es ist erstmal eine Serialisierungssprache. Man kann im Prinzip alle Datenstrukturen damit ausdrücken. Es hat zum Beispiel auch noch bestimmte Features, die man jetzt nicht so kennt. Aber wenn zum Beispiel eine Sprache einen Tuppel hat, dann kann man das Alt in YAML auch ausdrücken. Da verwendet man dann noch spezielle Features für. Gleichzeitig soll es aber auch menschenlesbar sein. Man hat diese Mappings mit Doppelpunkten und dann hat man Listen mit Spiegelstrichen. Und wenn man sich jetzt vorstellt, ich mache eine Checkliste für die nächste Party, dann mache ich das auch oft mit Spiegelstrichen auf dem Zettel.

Wolfi Gassler (00:07:37 - 00:07:43)

Was sind denn Spiegelstriche? Für mich als Österreicher ist das ein deutscher Ausdrucksspiegelstrich. Das habe ich noch nie gehört.

Tina Müller (00:07:43 - 00:07:44)

Ja, einfach ein Minus.

Wolfi Gassler (00:07:45 - 00:07:52)

Bei uns heißt es immer klassisch Spindelstriche in Österreich, aber Spiegelstriche habe ich wirklich noch nie gehört. Okay, ist ja gut, dass ich auch mal was Neues nenne.

Tina Müller (00:07:52 - 00:08:04)

Ich bin halt bei dem ganzen Jammelthema eigentlich komplett im Englischen unterwegs. Deswegen ist es relativ ungewohnt, dass ich darüber in Deutsch rede und Spiegelstrich ist mir als erstes tatsächlich eingefallen.

Andy Grunwald (00:08:04 - 00:08:05)

Du kannst natürlich auch sehr gerne englische Wörter nehmen.

Wolfi Gassler (00:08:05 - 00:08:09)

Das heißt, im Englischen, in der Spezifikation, nennt sich es dann Dash oder?

Tina Müller (00:08:09 - 00:08:32)

Das ist eigentlich das falsche Wort, wie ich auch gelernt habe, sondern hyphen wäre der richtige Ausdruck. Aber die meisten sagen das und jeder weiß, was gemeint ist. Und ja, genau, das ist jedenfalls so das Intuitive von YAML, dass man eben gleichzeitig alle Daten damit ausdrücken kann, aber gleichzeitig soll es für den Menschen lesbar und schreibbar sein. Genau.

Andy Grunwald (00:08:32 - 00:08:38)

Jetzt stelle ich mir immer die Frage, wofür steht eigentlich YAML? Oder ist das ein Eigenwort, YAML?

Tina Müller (00:08:38 - 00:09:19)

Die allererste Abkürzung war tatsächlich Yet Another Markup Language, aber dann wurde das relativ schnell ersetzt mit YAML Ain't Markup Language, um halt zu sagen, dass es doch nicht einfach nur eine weitere Markup Language ist. Der Hintergrund, der Ursprung war so ein bisschen XML. Gab halt zu der Zeit, das war so 2001, als die sich zusammengesetzt haben, die drei Leute, und da gab es halt Und man wollte aber eine Sprache zum Serialisieren von Daten und jetzt kann man XML mögen oder nicht, aber ich glaube, es ist nicht so ganz so sinnvoll als Serialisierungssprache. Und XML ist halt Markup und ja, dann hat man eben gesagt, DML ist kein Markup.

Wolfi Gassler (00:09:19 - 00:09:33)

Jetzt Jason, habe ich gerade nachgeschaut, 1997 ist das Ganze herausgekommen, damals von Douglas Crockford, also JavaScript Universe. Warum hat man denn dann später noch wieder was Neues eingeführt und wie steht denn das Ganze zu Jason?

Tina Müller (00:09:34 - 00:10:19)

Also soweit ich weiß, wurde Jason zumindest 2001 veröffentlicht. Also ich weiß nicht genau, was jetzt 1997 schon da war und was nicht. Also soweit mir auch irgendwie einer der YAML-Erfinder erzählt hat, war das so ein bisschen zeitgleich, diese ganze Geschichte. Ich glaube, zu dem Zeitpunkt waren sie sich von JSON noch nicht wirklich bewusst. Aber JSON hat eben auch seine Grenzen. Also JSON ist ein Datenaustauschformat und man kann damit ja einiges an Daten austauschen. Hashes oder Objekte und Arrays und Zahlen und null. Aber dann ist es auch relativ schnell zu Ende. Und alles, was darüber hinausgeht, kann man damit eben nicht wirklich serialisieren.

Wolfi Gassler (00:10:19 - 00:10:25)

Und was wäre das jetzt als Beispiel, was darüber hinausgeht, wo YAML mehr Funktionalität hat?

Tina Müller (00:10:25 - 00:11:00)

Also zum einen schon allein, es gibt Sprachen, wo man zum Beispiel Zahlen als Hashkeys hat. Bei JSON gehen wirklich nur Strings. Und es gibt auch Sprachen, wo man als Hashkeys Objekte hat oder wiederum Arrays oder Hashes. Das ist alles möglich. Also ich glaube in Ruby, aber bin mir nicht ganz sicher. Und dann eben, wie schon gesagt, Tuple gibt es als Datentyp. und den kann man in YAML ausdrücken. Da muss man eben Tags verwenden, da kommen wir vielleicht später noch zu, oder eben auch andere Datentypen und auch Binärdaten kann man serialisieren.

Andy Grunwald (00:12:37 - 00:13:04)

Jetzt hattest du gesagt, dass JSON eigentlich ein Datenaustauschformat ist und YAML ein Serialisierungsformat. Jetzt meine Frage wäre, bedeutet das dann auch, dass YAML dafür gedacht ist, ich sag mal, nicht als Datenaustauschformat genutzt zu werden, um das von Service A nach Service B zu schicken? Offengesprochen, ich habe jetzt noch keine Microservices oder irgendwelche HTTP-APIs getroffen, die mir YAML zurückgeben.

Tina Müller (00:13:04 - 00:13:46)

Also es ist schon auch dafür gedacht, durchaus. Es kann halt, wie gesagt, ein bisschen mehr und was zum Beispiel auch mit in der Spezifikation ist, ist Streaming. Also nicht nur, dass du jetzt zum Beispiel einen HTTP-Request machst, Request und Response, sondern dass du auch Sachen streamst und deswegen gibt es eben auch das Multi-Document, Also die Eigenschaft, dass du eben wirklich mehrere YAML-Dokumente hintereinander einfach packen kannst und durch drei Punkte beendest. Dann sagst du eben der Gegenseite, okay, das Dokument ist jetzt fertig, kannst du verarbeiten. Und es ist schon auch dafür gedacht, Daten auszutauschen. Die Unterscheidung zwischen den beiden Begriffen ist natürlich ein bisschen, also kann man jetzt nicht komplett trennen.

Wolfi Gassler (00:13:46 - 00:13:54)

Sind solche Dinge dann in neuen Spezifikationen dazugekommen oder so Streaming war das schon von Anfang an eigentlich mit im Konzept?

Tina Müller (00:13:54 - 00:13:58)

Das war schon von Anfang an mit drin, ja.

Wolfi Gassler (00:13:58 - 00:14:07)

Das heißt eigentlich, wenn man es so einsetzt, wenn ich jetzt irgendwo ein simples Config-File schreibe, dann verwende ich eigentlich nur einen ganzen kleinen Teil von dem, was da eigentlich dahinter steckt.

Tina Müller (00:14:07 - 00:14:17)

Ja, tatsächlich. Und Ingi sagt auch immer, dass er eigentlich das hasst, dass die Leute einfach YAML für Config-Dateien verwenden, weil eigentlich für Config-Dateien gibt es ja Indie-Files.

Wolfi Gassler (00:14:17 - 00:14:19)

Wer ist Ingi, nur zur Erklärung?

Tina Müller (00:14:19 - 00:14:22)

Also Ingi, ingi.net ist einer der Erfinder von YAML.

Andy Grunwald (00:14:24 - 00:14:45)

Das finde ich aber mal ein geiles Statement. Die komplette Industrie nutzt irgendwie YAML zum primär Konfigurieren, offen gesprochen. Also zumindest ist es das, womit ich so in Berührung komme und weniger mit dem, wofür es eigentlich gedacht ist. Und der Erfinder bzw. Gründer mag das nicht. Auch eine schöne Sache. Also eigentlich müsste man doch froh sein, dass YAML doch so eine solch große Popularität hat, oder?

Tina Müller (00:14:46 - 00:15:07)

Das schon, ja. Aber es gibt für Config-Dateien, die keine wirkliche Hierarchie haben, ist es tatsächlich manchmal sinnvoller, INI zu verwenden. Die ganzen Features auch mit Datentypen und so weiter, das hat man oft gar nicht, das Bedürfnis für Config-Dateien. Und dann benutzen das Leute, die wenig Ahnung von YAML haben. Ja, ganz sicher.

Andy Grunwald (00:15:07 - 00:15:25)

Aber wie steht denn jetzt YAML? Ich meine, wir hatten schon JSON angesprochen, du hattest gerade das INI-Format angesprochen und dann schwirrt noch bei mir im Kopf dieses Format TOML rum. Ich glaube, das steht für Tom's Language oder so, glaube ich. Bin mir da nicht mehr genau sicher. Aber wie würdest du jetzt YAML im Vergleich zu den anderen Formaten einordnen beziehungsweise auch abgrenzen?

Tina Müller (00:15:25 - 00:15:55)

Ja, also Tommel ist, denke ich mal, noch ein mächtigeres Config-Format. Also das ist wahrscheinlich wirklich das Format, was man verwenden sollte, wenn man klassische Config-Dateien möchte. Und dort muss man zum Beispiel auch rings quoten. Und wenn man Zahlen hat, macht man keine Quotes drumherum. Und wenn man jetzt irgendwas drin hat, was eigentlich keine Zahl ist, dann sagt es einem, hey, das ist nicht valide. Und das ist sicher ganz praktisch. Da muss man sich halt weniger damit auskennen.

Wolfi Gassler (00:15:55 - 00:15:59)

Das heißt, die AMEL verzeiht mir mehr diesbezüglich?

Tina Müller (00:15:59 - 00:16:22)

Ja, verzeihen in dem Sinne nicht. Also es sagt dann halt, okay, wenn du das hast, keine Quote drumherum, aber es ist auch keine Zahl, dann ist es ein String. Aber es kann nachher was Falsches dabei rauskommen oder ein falscher Datentyp. Das ist, glaube ich, so das Problem. Oder es ist eben ein Datentyp, von dem du es nicht erwartest, wie zum Beispiel No ist dasselbe wie False und du wolltest aber nur die Abkürzung für Norway schreiben.

Andy Grunwald (00:16:22 - 00:16:27)

Zu den Flaws kommen wir gleich noch, obwohl es Flaws eigentlich sind.

Tina Müller (00:16:27 - 00:16:46)

Noch kurz zu Tommel, also das ist auf jeden Fall schon recht mächtig. Was es aber halt nicht hat, ist so eine hierarchische Datenstruktur oder man kann das damit abbilden, aber das wird dann sehr schnell hässlich, besonders wenn man eben Listen drin hat, dann muss man mit diesen doppelten Klammern arbeiten und das wird dann irgendwann nicht mehr schön.

Andy Grunwald (00:16:46 - 00:17:26)

Sprechen wir mal ein bisschen über die Verbreitung von YAML. Macht ihr euch in der, ich sag mal, engeren YAML-Community denn auch Gedanken, warum das Format beziehungsweise die Sprache denn jetzt auf einmal so einen Popularitätsboost hat? Also beobachtet ihr das Ecosystem und schaut ihr dann auch, wie wird denn YAML wirklich genutzt und was können wir denn jetzt wirklich zur Spezifikation schieben? Also du hast grad gesagt zum Beispiel Streaming. wird supported, Wolfgang sagt, das war mir neu. Wird da jetzt zum Beispiel mehr an wirklich Datentypen in der Spezifikation geschraubt aufgrund der Verbreitung in der Popularität und habt ihr das so im Auge oder wie beobachtet ihr die ganze Thematik?

Tina Müller (00:17:26 - 00:18:30)

Im Auge schon so ein bisschen. Es gab jetzt allerdings länger keine wirkliche neue Version und es gab mal den Gedanken, eine Version 1.3 zu machen. Das war aber ausgerichtet auf die Einfachheit des Parsings, weil es einfach ein paar Sachen gibt, die wirklich schwer zu implementieren sind und den Parser sehr komplex machen. Und da sind wir aber so ein bisschen hängen geblieben. Und eigentlich ist auch noch die Aufgabe, eben die 1.2-Situation zu verbessern. Aber ja, also ich beobachte schon verschiedene Communities, aber es ist einfach so viel. Also ich beobachte mehrere Repositories wie GoYAML und JSYAML und so weiter und versuche auch dort, Fragen zu beantworten. Und da sehe ich ja schon so ein bisschen, was reinkommt an Fragen und was die Leute auch wirklich benutzen. auch bei Payamel. Und dann kommen auch Leute in unseren Matrix-Channel und fragen dann aber Sachen, wie geht das in Ansible, was wir dann nicht unbedingt beantworten können. Das ist ein sehr weites Feld. Neue Features sind erstmal so nicht reingekommen, aber da ist auf jeden Fall Überlegung, was man da machen könnte.

Wolfi Gassler (00:18:31 - 00:18:53)

Jetzt frage ich mich natürlich, wenn es so ein einfaches Textformat ist, wenn ich das mal so abwertend sagen darf, warum brauche ich denn dann überhaupt neue Standards? Also was kommt denn da dazu, wenn es jetzt 1.1, 1.2 gibt? Also es ist ja immer noch irgendwie jammerl. Also gibt es da dann neue Features oder was ist in so einem Standard überhaupt drin, in so einer Spezifikation dann?

Tina Müller (00:18:53 - 00:19:28)

Also der große Unterschied von 1.1 und 1.2 war tatsächlich, also zum einen hat man gesehen, Jason ist da, so parallel entstanden, und dann hat man geguckt, diese Flow-Notation in YAML, dass man so in Klammern auch Dinge schreiben kann, das sieht ja eigentlich fast aus wie Jason. Und dann hat man geguckt, man könnte die Spezifikation anpassen und nur ein paar kleine Dinge verändern und dann wäre YAML automatisch ein Superset von JSON. Und dann hat man das tatsächlich gemacht, sodass die 1.1 ist noch kein Superset, aber die Version 1.2 ist es dann.

Wolfi Gassler (00:19:28 - 00:19:31)

Das heißt, ich kann JSON dann in YAML schreiben?

Tina Müller (00:19:31 - 00:19:37)

Genau, du kannst jedes JSON-Dokument mit einer YAML-Library auch lesen.

Wolfi Gassler (00:19:37 - 00:19:49)

Aber heißt das, dass das JSON dann in YAML drin, also dass ich das mischen kann, oder kann ich jedes valide JSON dann auch mit einem YAML-Bowser passen? Oder kann ich das auch wirklich dann mischen in irgendeiner Form?

Tina Müller (00:19:49 - 00:20:28)

Du kannst das auch mischen. Also einmal jedes JSON-Dokument ist automatisch auch YAML und dann hast du im klassischen YAML dieses Block-Format mit auf jeder Zeile ein Wert und dann kannst du aber anfangen mit Square Brackets und Curly Braces eben auch so eine Art JSON zu schreiben. Du musst aber die Dinge nicht quoten. Das heißt, es sieht ein bisschen aus wie JSON. Du kannst es auch alles quoten, sodass es dann wirklich JSON innerhalb eines YAML-Dokuments ist. Aber du musst es nicht quoten und du kannst auch Kommas am Ende dazu schreiben oder auch darin Kommentare. Das heißt, es ist eigentlich auch ein besseres JSON.

Wolfi Gassler (00:20:28 - 00:20:51)

Das heißt aber, die Umstellung ist dann auch super einfach. Das heißt, wenn ich einen YAML-Bowser habe, dann kann ich auch JSON damit pausen und verwenden und bin dann komplett flexibel. Also eigentlich, wenn ich auf YAML setze, können die Freaks, die da gern JSON verwenden, weil sie das Format halt so lieben, genauso das Ganze definieren und am Ende kommt eigentlich die korrekte Struktur rauszuladen. Das sind natürlich die, die in derselben Struktur irgendwie definiert wird.

Tina Müller (00:20:52 - 00:21:08)

Ja, kann man machen. Also ich würde es jetzt nicht machen, wenn ich zum Beispiel irgendwo JSON über eine API lese, weil YAML-Parser ist einfach von der Natur aus ein bisschen langsamer, weil er eben viele Sachen beachten muss. Also ist nicht unbedingt der effizienteste Ansatz.

Wolfi Gassler (00:21:08 - 00:21:21)

Aber ich könnte jetzt zum Beispiel, wenn ich jetzt an Docker denke und an so eine Definition von Docker Compose, könnte ich die in JSON schreiben und sofern Docker Compose jetzt den Standard 1.2 unterstützt, wäre das eine valide Definition.

Tina Müller (00:21:21 - 00:21:22)

Ja, genau.

Wolfi Gassler (00:21:22 - 00:21:23)

Cool.

Andy Grunwald (00:21:23 - 00:21:43)

Also, ich kannte den Flow-Style von YAML noch gar nicht. Und während ihr gesprochen habt, habe ich mir das mal ganz kurz angesehen. Und geil, das ist ja JSON mit Kommentaren, wie du schon sagtest. Warum schreibe ich eigentlich überhaupt noch JSON? Wahnsinn. Und jetzt brauche ich nur irgendwie so eine Art, weiß ich nicht, Präprozessor für meine JavaScript-Sachen, damit ich das dann wirklich wieder in JavaScript packen kann. Dann muss ich nämlich gar kein JSON mehr schreiben.

Wolfi Gassler (00:21:43 - 00:21:46)

Das nennt sich dann YAML-Parser, Andi.

Andy Grunwald (00:21:46 - 00:21:51)

Moment mal, gibt's denn YAML-Parser in JavaScript? Bestimmt, ja.

Tina Müller (00:21:51 - 00:21:55)

Es gibt mittlerweile auch einen, der wirklich 1.2 unterstützt.

Wolfi Gassler (00:21:55 - 00:21:59)

Wie neu ist 1.2? Wann ist es rausgekommen?

Tina Müller (00:21:59 - 00:22:36)

Das ist jetzt durchaus schon ein bisschen älter. 2009 ist es rausgekommen, aber es wurde halt nicht so richtig angenommen, weil es gab ja PyJML und LibJML. PyJML wurde geschrieben von Kirill Simonov, ich hatte es rausgesucht, 2005. glaube ich, oder 2006. Ich glaube, beim Google auf Code. Und der hat das dann auch noch nach LibYAML portiert. Und das war einfach so, damit hat er einen Standard gesetzt, so ein bisschen von der Spezifikation abgewichen. Und das wurde dann halt benutzt. Es kamen immer mehr Dinge, die YAML benutzen wollten, und keiner hat sich darum gekümmert, dass es jetzt eine neue Version da irgendwie gibt.

Wolfi Gassler (00:22:37 - 00:23:00)

Es ist immer schlimm, wie lange solche Versionen brauchen in der IT. Wir hatten gerade kürzlich das Problem, ich habe ein UTF-8-Zeichen verwendet und der Andi hat gesagt, bei mir wird das nicht dargestellt. Und das ist eigentlich ein Standard von 2007, aber Mac kann scheinbar diesen UTF, keine Ahnung was es war, 6 oder 7 Standard noch nicht von 2007. Also auch da, es braucht einfach alles lange, lange Zeit.

Andy Grunwald (00:23:00 - 00:23:03)

Sprechen wir mal nicht über die Bash-Version, die beim Standard Mac OS X mit ausgeliefert wird.

Wolfi Gassler (00:23:03 - 00:23:05)

Ja, das darf man sowieso nicht erwähnen.

Andy Grunwald (00:23:09 - 00:24:11)

Ja, aber die muss man ja aktiv installieren, also von daher. Lass uns mal ganz kurz über die Arten von YAML sprechen. Du hattest auch gerade schon gesagt, ja, dann war da jemand, der hat PyYAML implementiert und der ist ein bisschen von der Spezifikation abgewichen. Und so habe ich auch das Gefühl, wird YAML so ein bisschen in freier Wildbahn verwendet. Und zwar hattest du nämlich in deinem Talk bei der FOSDEM auch gesagt, Was viele Leute für YAML halten, ist eigentlich gar kein richtiges YAML. Du hattest drei Beispiele. Du hattest einmal Zollstack genannt und dann sogenannte SLS-Files. Die haben dann glaube ich auch Vorschleifen drin, also Loops generell. Ähnliches mit Ansible-Files. Alles was noch durch Jinda-Templating gegangen wird. Und dann glaube ich war dein drittes Beispiel GitHub. Wie seht ihr das? Schaut ihr euch diese Sprachen an und sagt, wow, das könnten wir mal nativ wirklich zu YAML machen? Oder sagt ihr, ist so eine Misconception, dass dann SoulStack, Ansible und GitHub das Format so ein bisschen, ich nenne es mal, freier interpretiert.

Tina Müller (00:24:12 - 00:24:56)

Ja, also eigentlich frei interpretieren vielleicht nicht unbedingt. Also bei SaltStack ist es halt wirklich, es ist einfach definitiv kein YAML, weil du eben vorher dieses Pre-Processing hast. Lässt ein Jinja-Templating drüberlaufen mit For-Loops, wie gesagt, wo dann irgendwelche Werte reinkommen mit Host-Namen und was man da in SaltStack typischerweise hat. Und erst danach ist es YAML. Das Problem dabei ist natürlich, dass so Du siehst diese Datei und kannst vorher überhaupt nicht sagen, ob das valides YAML ist und noch nicht mal auch, ob es nachher einem bestimmten Schema entspricht. Du kannst es nur, indem du die Daten durchlaufen lässt. Das heißt, Unit Tests kannst du damit auch nicht so einfach schreiben.

Wolfi Gassler (00:24:56 - 00:25:01)

Du hast auch keinen Support in der IDE dann natürlich, weil es geht natürlich genauso wenig.

Tina Müller (00:25:01 - 00:25:22)

Weil Solstack ja gar nicht weiß, was potenziell an Daten reinkommen könnte. Bei Ansible ist es halt so, dass es besser gelöst, weil da wird tatsächlich das Ganze erstmal geladen ganz normal und die Jinja-Templates sind in den Strings drin und dann wird Pyjama verwendet und dann hast du das in einer Datenstruktur und dann wird mit Jinja nochmal drüber gelaufen.

Andy Grunwald (00:25:24 - 00:25:32)

Okay, das bedeutet theoretisch wird alles, alle zusätzliche Logik wirklich in Quotes gepackt und das könnte somit auch ein regulärer YAML-String sein.

Tina Müller (00:25:32 - 00:25:58)

Ja, also die Ansible-Dateien sind auf jeden Fall alle, sollten reguläres YAML sein. Was halt nicht so klar ist, ist auch, welcher parser wird eigentlich verwendet und welche YAML-Version. Das findet man in der Dokumentation nicht wirklich und das wäre schon mal ganz interessant. Also ich fände es nett, wenn die Leute das da zuschreiben würden, damit man überhaupt mal weiß, worauf kann man sich verlassen, was funktioniert und was nicht.

Wolfi Gassler (00:25:58 - 00:26:58)

Ich habe ganz allgemein das Gefühl, es spricht jeder von YAML, aber es weiß eigentlich niemand so genau, was da dahinter steckt. Also auch ich verwende YAML tagtäglich bei Docker und überall, aber ich muss jedes Mal nachdenken, was eigentlich die Struktur ist, was jetzt dieser Spiegelstrich heißt, was er jetzt bedeutet, was ist, wenn du den Spiegelstrich weglässt, die Aufzählung, was wird da dann ein Objekt und was nicht und so weiter. Also es ist irgendwie so, man beschäftigt sich nie damit. ist so im Flow und man denkt nie darüber nach, was da überhaupt dahinter steckt, wie die Struktur ist. Und obwohl man das ständig verwendet, hat man keine Ahnung darüber. Und ich würde auch nie nach einer Version irgendwo suchen, was da unterstützt wird, weil ich eben eh denke, das ist Jaml. Und ja, Jaml ist Jaml, da gibt es wenig. Also ich glaube, man beschäftigt sich verdammt wenig damit. Ich glaube, das ist auch ein großes Problem. Aber ich habe selber, muss ich ganz ehrlich sagen, muss ich mir an der Nase fassen, noch nie darüber nachgedacht irgendwie mehr. Oder vielleicht auch mal einfach eine halbe Stunde zu investieren und mal ordentlich den Syntax einfach durchlösen.

Tina Müller (00:26:59 - 00:27:40)

Genau, das ist, glaube ich, so das Problem. Und wenn man jetzt JSON als Vergleich sieht, da ist das ja auch eigentlich gar nicht notwendig. Das hat man sehr schnell begriffen, was da passiert. Und dann trifft man halt auf Ansible oder SaltStack oder sonst was und da wird YAML verwendet. Und dann sieht man halt die spezifischen Beispiele für diese Anwendung und denkt dann, ach, das nennt sich YAML. Und es sagt eigentlich keiner, lern doch eigentlich mal vorher mal grundsätzlich, was YAML eigentlich ist, sonst hast du halt später ständig Probleme, wenn du dich fragst, was soll das denn jetzt hier. Ja, das sehe ich schon, weil es ist einfach komplexer, es ist halt mächtiger, aber du kannst halt auch viele Fehler machen.

Wolfi Gassler (00:27:40 - 00:27:58)

Jetzt hast du bei Andi schon gemerkt, Andi hat das ja auch schon irgendwie gesagt, das ist eigentlich YAML, aber dabei ist es Ginger Templating, was dahinter läuft. Passiert dir das öfter, dass Leute glauben, das ist Teil vom YAML-Standard und eigentlich ist es ein Templating-System, was irgendwie dahinter oder davor abläuft, pre-processor oder post-processor?

Tina Müller (00:27:58 - 00:28:24)

Ja, ich glaube, das ist schon einigen nicht so bewusst. Also es gibt schon mehrere Leute, die bei uns im IAC oder in Matrix reinkommen und einfach so ein Stück YAML posten und sagen, was muss ich jetzt da schreiben? Ich kriege da eine Fehlermeldung. Und die Fehlermeldung ist dann aber oft von der Applikation selber, die sagt, dass hier irgendwie irgendein Key nicht hingehört. Aber das YAML selber ist völlig in Ordnung. Das wird halt einfach nicht wirklich auseinandergehalten. Ja, kann ich natürlich auch verstehen.

Andy Grunwald (00:28:25 - 00:28:37)

Das führt mich eigentlich zu der Frage, ob diese großen Projekte wie Soulstack, Ansible und GitHub Actions sich eigentlich selbstbewusst sind, welche YAML-Funktion bzw. Version dort eingesetzt wird oder welche sie implementieren. Weißt du das zufällig?

Tina Müller (00:28:38 - 00:28:56)

Also auf jeden Fall bei Ansible haben wir halt einen Entwickler, der bei uns bei PyYAML mitmacht, der Matt Davis. Der arbeitet an Ansible und der ist sich da schon bewusst. Bei den anderen weiß ich es nicht wirklich genau. Ich habe noch niemanden von GitHub kennengelernt, der bei uns vielleicht mal reingekommen wäre und gefragt hätte oder so.

Andy Grunwald (00:28:56 - 00:29:22)

Sprechen wir mal ein bisschen über die EML-Spezifikation und dann auch über die Features. Wie kommt eigentlich ein neues Feature in die Spec? Also ich meine, gibt es da so eine Art Project Governance oder – ich kann das Wort jetzt nicht BDFL sowie Linus Torvalds bei Linus, also einer der darüber sagt ja und nein oder wie heißt das? Benevolent Dictator for Life. Ich kann das wohl nicht aussprechen.

Tina Müller (00:29:22 - 00:30:31)

Ja, also Ingi, den ich ja schon genannt hatte, der ist so derjenige, der noch aktiv an YAML arbeitet. Ich würde mal sagen, der ist so derjenige, der hat so das letzte Wort, aber er würde sich jetzt selber nicht als BDFL bezeichnen wollen. Und wir haben so in den letzten Jahren mit einer Gruppe von Leuten zusammengesessen und haben uns Dinge überlegt. Da ging es halt auch um die Vereinfachung. Beispielsweise kann man in YAML MT-Keys verwenden. Also da steht dann einfach der Doppelpunkt am Anfang der Zeile. Und das LibYAML und PyYAML haben gesagt, das implementiere ich nicht und wir brauchen das. Und dann haben wir halt überlegt, das würden wir gerne rausschmeißen, weil das ein Stück ist, was den Parser komplizierter macht und ein paar andere Dinge. Und dann haben wir darüber abgestimmt und wir haben das auch auf GitHub gestellt, unsere Vorschläge und Pro und Contra abgelegt. Und das ist so ein bisschen eingeschlafen, der Prozess, weil wir eben gleichzeitig eben auch noch die 1.2-Version, weil wir daran gearbeitet haben, die unter die Leute zu bringen, weil das ja auch noch nicht wirklich passiert ist. Aber das ist halt so ein halb demokratischer Prozess, würde ich sagen.

Wolfi Gassler (00:30:31 - 00:30:34)

Ist bei YAML eigentlich so die Referenzimplementierung?

Tina Müller (00:30:34 - 00:30:38)

Nicht wirklich Referenz, nee. Es ist halt die populärste.

Wolfi Gassler (00:30:38 - 00:30:40)

Oder gibt es eine Referenzimplementierung?

Tina Müller (00:30:40 - 00:31:13)

Genau, es gibt seit vielleicht jetzt drei Jahren oder so eine Referenzimplementierung. Und zwar hat INGI sich die Spezifikationen genommen und maschinell in ein Programm gegossen sozusagen. Und da gibt es jetzt auch, glaube ich, drei Sprachen. Also in Perl, in JavaScript und in noch einer dritten Sprache läuft es, glaube ich. Und es ist auch auf dem Layground zu sehen. Und ja genau, die Referenzimplementierung ist nach unserem Wissen korrekt, 100 Prozent. Es kann immer noch Sachen geben, die wir noch nicht entdeckt haben.

Wolfi Gassler (00:31:13 - 00:31:21)

Aber die Referenzimplementierung ist dann wirklich nicht zum produktiven Einsatz gedacht, sondern nur zum Überprüfen, ob dann eine andere LIB richtig funktioniert.

Tina Müller (00:31:22 - 00:31:45)

Genau. Und die ist auch einfach zu langsam. Also für fünf Zeilen Jammel ist das okay. Ansonsten wird es schnell relativ langsam und die Fehlermeldungen sind eben auch nicht, also es gibt im Prinzip keine wirkliche Fehlermeldung, sondern einfach nur ist nicht valide. Das ist tatsächlich auch eine sehr schwierige Sache, die Fehlermeldung wirklich gut zu gestalten. Das kannst du gar nicht automatisiert aus der Spezifikation machen.

Andy Grunwald (00:31:46 - 00:32:11)

Die meisten Sprachlibraries implementieren die eigene YAML-Parser in ihrer eigenen Programmiersprache oder nutzen die meisten Sprachlibraries irgendwie die libYAML als C-Binding. Weil ich meine, im Endeffekt müssen die ja dann alles, ich sag mal, nachimplementieren in ihrer Sprache, wo natürlich dann das Binding, klar, der Kompilierungsprozess vielleicht ein bisschen komplizierter wird, aber natürlich implementierst du den Parser einmal und hast dann eigentlich nur noch das Sprachbinding.

Tina Müller (00:32:12 - 00:33:07)

Ja, also es gibt ein paar, die LibJammel verwendet haben. Ich kann jetzt gar nicht sagen, wie viele das sind, aber ich glaube, die Sachen, die neu entstehen, die richten sich vielleicht auch danach noch. Aber es sind jetzt in den letzten Jahren schon einige neue Bibliotheken entstanden, die wirklich das komplett selber implementieren. Soweit ich weiß, gibt es jetzt auch eine Rust-Implementierung und der Autor sagt, es ist 100% grün. Die Test-Suite, ich bin noch nicht dazu gekommen, das auszuprobieren. Und das ist auch eine komplett eigene Implementierung. Und ja, wenn LibYAML verwendet werden sollte, dann wäre jetzt auch die neuere Alternative LibFYAML. Also einer von unserer Gruppe hat eben das Ganze in C nochmal neu implementiert und ist jetzt auch wirklich nach der Spezifikation gegangen. 1.2. Wenn man ein neues Binding schreibt, sollte man Libf-Yaml jetzt verwenden.

Andy Grunwald (00:33:07 - 00:33:13)

Wofür steht denn das F in diesem Libf-Yaml? Für foremost oder forward oder?

Tina Müller (00:33:13 - 00:33:15)

Nee, einmal darfst du noch raten.

Andy Grunwald (00:33:17 - 00:33:19)

Nee, ich hab keine Ahnung. Für fast.

Tina Müller (00:33:19 - 00:33:22)

Fancy.

Andy Grunwald (00:33:22 - 00:33:57)

Okay, den Lipp fancy, aber finde ich gut. Jetzt ist es natürlich so, jetzt ist einer der klassischen Programmierfingerübungen immer, ich baue mir mal einen eigenen Parser mit Lexa und allem drum und dran. Und dann habe ich zwar meinen einzelnen Testcase mit meinen fünf Zeilen YAML und der Pass dann auch, aber Ihr habt ja eine YAML-Testsuite entworfen, wenn ich das richtig recherchiert habe. Was ist die YAML-Testsuite und wie sieht die aus? Und wie viele Sprachlibraries passen alle Tests? Und gib uns doch mal bitte einen Überblick.

Tina Müller (00:33:57 - 00:35:51)

Ja, gerne. Also die Testsuite besteht momentan aus knapp über 400 Tests. Und so ein einzelner Test beinhaltet einfach ein YAML-Dokument und dazu zum Beispiel eine JSON-Datei. wenn dieses YAML in JSON überhaupt ausdrückbar ist, das ist ja nicht immer der Fall, und eine Event-Serie, sage ich mal. Also das ist dann halt auf der Parser-Ebene. Der Parser sieht, es wird eine Liste angefangen oder ein Mapping angefangen und Da wird dann in einer bestimmten Syntax so ein Event ausgegeben, also eventbasiertes Parsing. Und wenn die Leute eine Bibliothek implementieren wollen, können sie eben, wenn sie dieses Format so ausgeben, können sie gucken, stimmt mein Output genau mit der Test Suite überein. Ich glaube, das hat auch dazu geführt, dass in den letzten Jahren wirklich mehr Leute gekommen sind und gesagt haben, ich implementiere jetzt auch mal YAML. Und bei mir war das auch der Fall. Wir haben in Perl so ein bisschen das Problem gehabt, den Segen und den Fluch, dass Ingi damals für die Version 1.0 ein Perl-Modul geschrieben hat und noch nicht mal auch so richtig komplett implementiert. Die Perl-Community hatte dann ein YAML-Modul und hat früh damit angefangen, YAML zu verwenden, aber es war halt nicht wirklich richtig YAML, also weit davon entfernt. Und da haben die Leute 15 Jahre lang mitgearbeitet. Und ich habe dann irgendwann gesagt, 2017, ich baue jetzt mal ein neues Modul, das YAML parsen kann. Und zwar richtig. Und habe das, glaube ich, nur gemacht, weil es eben die Test Suite gibt. Ich habe aber während dieser Phase auch ganz viele Tests selber hinzugefügt. Man merkt dann irgendwie, Was ist denn jetzt eigentlich mit diesem Dokument? Das ist ja noch gar nicht in der Testsuite drin und dann muss man in der Spezifikation nachschauen oder fragt die Leute, die noch besser darüber Bescheid wissen. Und so sind dann die ganzen Tests zusammengekommen.

Wolfi Gassler (00:35:51 - 00:36:17)

Jetzt wenn du sagst, es sind über 400 Tests, also für mich persönlich klingt ja immer noch sehr einfach. Hast du da irgendwie ein Beispiel, was da so ein komplexer Test ist oder was da abgetestet wird neben den klassischen Dingen natürlich? Ich stelle mir vor, bei 400, das klingt nach extrem vielen Edge Cases und Zusatzdingen, die jetzt abseits von definieren String und eine Liste eigentlich ist.

Tina Müller (00:36:17 - 00:36:29)

Tatsächlich, ja. Also zum einen ist eben, was ich eben schon erwähnt habe, dass man leere Keys haben kann, also wo einfach Doppelpunkt vorne steht. Und LibYAML zum Beispiel hat das nie implementiert und andere Dinge.

Wolfi Gassler (00:36:29 - 00:36:36)

Also das meine ich, dass die, der variablen Namen sozusagen, wenn man es so sehen will, leer ist, also empty ist.

Tina Müller (00:36:37 - 00:37:23)

Genau. Whitespace ist so eine Sache, die man abtesten muss und dann eben auch in allen Varianten. Dadurch, dass es eben doch relativ viele Features hat, will man die auch in allen Varianten abtesten und einmal im Blockformat, also das, was ihr so kennt, und dann eben im Flow oder JSON-Style mit Quoting zum Beispiel. Es gibt ja viele Arten, um einen String zu quoten und die sind teilweise auch recht komplex zu implementieren. Es gibt auch Feature, wo Ingi sich bis heute darüber ärgert, dass es mit reingekommen ist, weil es eigentlich das Ganze noch ein bisschen komplizierter macht. Dann eben die Alias, um Referenzen oder Pointer zu bilden, oder die Tags, die eigentlich fast die wenigsten eigentlich kennen. Und da kommt dann schon einiges zusammen.

Wolfi Gassler (00:37:23 - 00:37:34)

Und wie viel unterstützen dann wirklich diese ganzen Features, also von den üblichen Lips? Oder gibt es überhaupt irgendeine Lip, die da komplett grün ist und alle 402 Test Cases schafft?

Tina Müller (00:37:35 - 00:38:31)

Also LibF-YAML ist tatsächlich eine, die alle Tests passt. Und dabei muss man auch beachten, dass es eben die validen Tests gibt und auch die nicht validen. Das heißt, wir haben auch YAML drin, was nicht valide ist. Und dann testen wir darauf, ob die Bibliothek dann auch wirklich sagt, das ist nicht valide, weil das ist eigentlich genauso schlimm wie umgekehrt. Soweit ich weiß, ist auch die JavaScript-Yaml-Library komplett grün. Allerdings auf der Matrix-Seite, die ich da verlinkt hatte, ist es glaube ich noch nicht grün. Ich muss da nochmal neu drüber laufen lassen. Das ist immer ein bisschen aufwendig. Und dann fängt es aber wirklich an mit kleinen Fehlern. Also da sind dann Bibliotheken, wo man sagen kann, die kannst du verwenden. Die sind zwar nicht komplett grün in den Tests, aber das sind so Fälle, da wirst du nicht drüber stolpern. So einen Jammel schreibst du nie im Leben. Von daher, ja. Aber es gibt auch noch viel zu tun.

Andy Grunwald (00:38:31 - 00:38:37)

Verteilt ihr eigentlich so einen TÜV-Gütesiegel? Diese Library besteht. Unsere Testsuite. Das wäre doch mal was.

Tina Müller (00:38:37 - 00:38:42)

Also wir haben auf jeden Fall die Matrix-Seite, wo die Bibliotheken aufgelistet sind.

Wolfi Gassler (00:38:42 - 00:38:45)

Wo findet man diese Matrix?

Tina Müller (00:38:45 - 00:38:51)

Matrix.yaml.info und die ist eigentlich auch verlinkt, wenn man auf die YAML-Testsuite auf GitHub geht.

Wolfi Gassler (00:38:51 - 00:38:59)

Verlinken wir natürlich in den Show Notes und da kann ich dann nachschauen, welcher Lib wie gut ist und ob meine Lib, die ich verwende, auch dementsprechend die 1.2 Specs erfüllt.

Tina Müller (00:39:01 - 00:39:22)

Genau. Also ich muss zum Beispiel die Rust-Bibliothek, die neuere, muss ich da auch noch hinzufügen. Und ja, das ist schon ein bisschen Arbeit. Das ist halt alles in Containern, was schon ganz gut ist. Aber ich muss halt rausfinden, wie baue ich diese Bibliothek und welchen Container sollte ich verwenden? Reicht mir ein Alpine oder soll ich lieber Debian verwenden? Und ja, die fehlende Zeit. Aber das kennen wir ja alle.

Andy Grunwald (00:39:24 - 00:39:43)

Gehen wir mal auf ein schöneres Thema. Gehen wir mal auf das Thema Urlaub. Skandinavien und im speziellen Norwegen. Und Leute, die sich mit YAML beschäftigen, kennen das vielleicht schon, das sogenannte Norway-Problem. Du hattest das auch schon erwähnt. Führ uns mal ganz kurz dadurch, was ist ein Norway-Problem in einer Serialisierungssprache.

Tina Müller (00:39:44 - 00:41:24)

Genau, wie schon erwähnt, da muss man ja ein YAML-Things nicht quoten. Und YAML hat das Feature, dass über reguläre Ausdrücke halt bestimmt wird, ist das jetzt eine Zahl oder ein Null oder ein Boolean. Und jetzt stellt man sich vor, ich mache eine Liste von Country Codes mit .de oder ohne Punkt natürlich, .de, .es, .no, so und bumm. Wenn du .no schreibst, dann wird das Ganze als dasselbe wie false interpretiert und dann landet ein Boolean in deiner Liste. Du merkst es dann natürlich irgendwann und die Frage ist, wann. Also wenn du jetzt deine Daten auch schön testest, dann merkst du das hoffentlich früh genug. Aber das ist natürlich was komplett Unerwartetes. Also No und Yes und On und Off gibt es auch noch. Und das natürlich auch in Groß- und Kleinschreibung. Und ich denke, man hat gedacht, das ist ganz cool, weil es in manchen Dateien, die man schreibt, wäre Yes. oder on, der passendere Ausdruck statt true. True ist so sehr technisch und YAML war ja nicht unbedingt nur dafür gedacht. Ja, und dann hat man sich später wohl überlegt, das war glaube ich doch keine gute Idee, so viele verschiedenen Booleans, also 22 an der Zahl, als Booleans zu erkennen. Und dann hat man das in der Version 1.2 ein bisschen eingedampft, genauso mit Zahlen, Die octal values wurden vorher mit einer einzelnen führenden 0 definiert, also 0,7 zum Beispiel. Das ist dann halt eine oktale Zahl. Und in der 1.2-Version hat man ja gesagt, es muss noch ein kleines o dazwischen stehen. Also 0, kleines o und dann die oktale Zahl. Weil sonst ist es auch sehr unerwartet.

Wolfi Gassler (00:41:24 - 00:41:32)

Wie viele values resolven wir jetzt auf true und false? 6 Stück. Von früher 22 und jetzt sind es 6. Okay, das klingt überschaubar.

Andy Grunwald (00:41:33 - 00:41:54)

Das bedeutet aber auch, ich sag mal, in der YAML-Version 1.1, wenn man dann auf 1.2 geht, das ist ja eigentlich ein Breaking Change, weil vielleicht gibt es ja Leute, die wirklich auf dieses Behavior mit On und Off, No für No Way in diesem Sinne jetzt, weil das nicht gequotet, wirklich, wirklich sagen, okay, das muss so, das hab ich jetzt so, das ist der Stand, also das kann auch nach hinten losgehen für einen Tierparser, oder?

Tina Müller (00:41:54 - 00:42:45)

Ja, genau. Also da sollte man auf keinen Fall jetzt sagen, zum Beispiel, also wenn Ansible jetzt sagen würde, wir nehmen jetzt einen 1.2-Parser und releasen das dann, da geht sehr viel kaputt, denke ich. Das muss man sich dann überlegen, wo man das einsetzt und woran man das festmacht, auch wenn man jetzt gemischte Versionen vielleicht einsetzt. Es gibt die Möglichkeit, eine YAML-Version oben anzugeben. Also mit dem Prozentzeichen und dann YAML und dann 1.1 oder 1.2. Und das implementieren eben auch manche Bibliotheken schon so, zum Beispiel die JavaScript Library oder auch mein Perl-Modul, dass es dann darauf reagiert, okay, das soll jetzt also 1.2 sein. Und dann nehme ich das neuere Schema mit den sechs Booleans oder eben die ältere und dann kann man den Default noch vorgeben.

Wolfi Gassler (00:42:45 - 00:42:56)

Das heißt, wenn ich jetzt alle meine Dateien einfach mal mit 1.0-Flagge sozusagen, dann kann ich jederzeit umsteigen und alles, was da neu ist, kann ich auf 1.2 machen.

Tina Müller (00:42:56 - 00:43:14)

Also 1.1 würdest du verwenden wollen? Oder 1.1, ja. Aber das können halt noch nicht so viele Parser. Das ist eben noch das Problem. Das wäre tatsächlich auch nochmal was, was man noch getrennt checken könnte. Welche der Bibliotheken, die in der Matrix aufgelistet sind, genau das unterstützen.

Wolfi Gassler (00:43:15 - 00:43:23)

Gibt es da eine Möglichkeit, dass ich einfach sage, okay, prüfe mir mal meine ganzen Config-Files in 1.1 und dann nochmal in 1.2 und vergleiche den Output?

Tina Müller (00:43:24 - 00:43:50)

Ja, ich habe auch mal überlegt, ob das vielleicht noch ein Feature wäre für mein YAML-Tidy-Programm. Du bist ja nicht der Erste, der nach sowas in der Art fragt und das will man natürlich auf jeden Fall automatisiert machen können. Ist natürlich nicht immer einfach, wenn du jetzt, genau, also den Output könnte man vergleichen. Ja, genau. Ansonsten kann man natürlich erstmal schwer entscheiden, soll on jetzt ein String sein oder eben nicht. Das weiß natürlich dann das Tool nicht unbedingt.

Wolfi Gassler (00:43:50 - 00:43:57)

Aber wenn ich natürlich die Unterschiede sehe, aufgelistet, dann kann ich halt manuell nochmal checken, okay, was war damals gemeint, was ist es jetzt.

Andy Grunwald (00:43:58 - 00:44:19)

Erinnert mich so ein bisschen an Static Analysis für YAML oder irgendwie so ein Upgrade-Check wie bei Postgre. Da gibt's zum Beispiel PG-Upgrade, der prüft dann, okay, kann ich meine Postgre-Version 15 auf 16 hochheben und allem Drum und Dran. Klingt so nach, zum Glück, aus Upgrade-Check und Shell-Check oder so, okay. Best Practice für YAML.

Tina Müller (00:44:19 - 00:44:39)

Das ist auf jeden Fall auch noch ein Feature genau für das YAML-Teil, die momentan kann es halt nur 1.2. verstehen sozusagen und sagen, okay, du hast hier einen String, der muss nicht gequotet werden. Aber das ist dir automatisch dann halt die Werte ersetzt. Das wäre tatsächlich noch ein Feature. Aber da gibt es noch sehr viel Luft nach oben, was die Tools so alles machen könnten.

Andy Grunwald (00:44:39 - 00:45:03)

Jetzt hat der Wolfgang schon mehrmals erwähnt, dass für ihn YAML eine relativ einfache Sprache ist. Meines Erachtens hast du schon mehrfach bewiesen, dass dem eigentlich nicht so ist. Nämlich, dass hinter YAML viel, viel mehr steckt. Was würdest du denn sagen, sind denn so die zwei, drei wenig bekannteren Features, wo du auch sagen würdest, die machen vielleicht auch die Implementierung eines Parsers einen Tick komplexer?

Tina Müller (00:45:03 - 00:45:20)

Also das Komplexe sind zum einen halt auch die Syntax-Sachen, muss man sagen. Die interessieren natürlich aus User-Sicht jetzt nicht unbedingt so. Aber von den Features her, es gibt durchaus einige, die Aliases, Anchors und Aliases nicht kennen.

Wolfi Gassler (00:45:21 - 00:45:22)

So wie ich zum Beispiel?

Tina Müller (00:45:22 - 00:45:58)

Ja. Damit kann man eben Referenzen oder Pointer beschreiben und sowas gibt es halt in JSON gar nicht. Wenn du jetzt eine Datenstruktur innerhalb einer Datenstruktur hast und die wird an zwei Stellen verwendet mit einem Pointer oder so, dann würde das in JSON einfach doppelt ausgegeben. Obwohl es ja eigentlich in der Sprache selber denselben Speicherplatz belegt. Und in YAML kann man das machen. Da hängt man dann einen Anchor vorne dran, wenn es zum ersten Mal auftaucht, mit einem ampersand Zeichen. Und dann kann man das später mit einem Sternchen und demselben Namen wiederverwenden.

Andy Grunwald (00:45:58 - 00:46:01)

Das Problem, was es dann löst, ist Copy und Paste vermeiden, oder?

Tina Müller (00:46:02 - 00:46:18)

Ja, und also Serialisierung, man hat ja eventuell solche Datenstrukturen und genau, also Copy und Paste, wenn man das tatsächlich in seiner Konfiguration oder wo auch immer man das ja beschreibt, wenn man da dasselbe eigentlich verwenden möchte, dann will man das nicht zweimal schreiben, genau.

Wolfi Gassler (00:46:19 - 00:46:34)

Ja, und du kannst halt wirklich auch Pointer realisieren, oder? Also wenn du jetzt irgendwie eine klassische Datenbank oder so hast, wo du halt einfach deine Rechnungen mit Kunden verknüpfst, dann könntest du das natürlich über sowas auch lösen. Und sonst hättest du halt tausendmal die Daten dupliziert unter Umständen.

Tina Müller (00:46:34 - 00:46:35)

Genau, ja.

Wolfi Gassler (00:46:35 - 00:46:38)

Gefällt mir schon dieses Feature. Finde ich cool. Als Datenbankler sowieso.

Andy Grunwald (00:46:38 - 00:47:08)

Wolfgang, du hast es gerade schon gut angesprochen, immer wenn ich mir an Pointer und Anchor denke, dann kommt so der Security-Mensch bei mir raus und sagt, ah, Moment mal, immer wenn ich Pointer und Anchor habe, dann kann ich zyklische Strukturen nachbilden und daraus könnte man eigentlich auch so eine Denial-of-Service-Attacke bauen, indem man da einfach, keine Ahnung, eine YAML-Injection macht. Also theoretisch kann ich eine endlose Baumstruktur bauen, oder? Also wirklich eine rekursive Baumstruktur, die dann eigentlich doch den Memory des Parsers irgendwie explodieren lassen könnte, oder?

Tina Müller (00:47:09 - 00:47:59)

Also man kann zyklische Strukturen bilden, genau. Da muss man in der Implementierung eventuell aufpassen, denn wenn man da nicht aufpasst, dann kann es ein Memory-Leak geben tatsächlich. In Perl muss man dann beispielsweise den Referenz-Counter manuell sozusagen runtersetzen, damit die Datenstruktur nachher auch wieder gelöscht wird. Das Problem ist aber noch, ja, also es ist lösbar, aber man sollte auf jeden Fall darauf aufpassen. Ansonsten ist es aber erst mal nur eine zyklische Struktur und zeigt auf dieselben Sachen. Wenn du natürlich jetzt unvorsichtig bist und willst die Struktur jetzt ausgeben mit einem JSON, in einem JSON-Format, dass das nicht beachtet, das ist natürlich dann schwierig. Aber ich denke mal, die meisten Ausgabetools, die achten dann auch darauf und sagen, okay, hier war ich schon mal an der Stelle.

Wolfi Gassler (00:47:59 - 00:48:03)

Habt ihr das in eurer Test-Suite drin als einen Test?

Tina Müller (00:48:03 - 00:48:09)

Da fragst du mich etwas. Ich glaube, wir haben die zyklische Datenstruktur nicht drin.

Wolfi Gassler (00:48:09 - 00:48:16)

Aber das könnte ja Andi dann contributen, damit Andi dann auch glücklich ist, wenn er das als DOS-Attacke sieht.

Tina Müller (00:48:17 - 00:48:55)

Wir haben erstmal den Fokus auf die Syntax gelegt und das ist kein klassisches Pasa-Problem, sondern eher eine Ebene drüber beim Bauen der Datenstrukturen. Aber was halt auch noch problematisch ist, ist die Billion Loves Attack und da ist es keine zyklische Datenstruktur, sondern einen Baum, der halt recht schnell sehr groß wird. Also man kann von einem String einen Anchor setzen und in der nächsten Zeile sagt man dann, ich verwende diesen Anchor jetzt zehnmal. Und darauf setze ich wieder einen Anchor. Und wenn ich das oft genug mache, dann habe ich eine Datenstruktur mit 1000 Entries.

Wolfi Gassler (00:48:55 - 00:48:59)

Also einfach ist das schon exponentieller Wachstum wahrscheinlich, oder?

Tina Müller (00:48:59 - 00:49:48)

Genau, mit einer Billion oder im Deutschen Milliarde. Und das ist eigentlich erstmal auch nicht problematisch. Also wenn ich das mit einem YAML-Modul lese, dann habe ich eben Alias in meiner Datenstruktur, die zeigen eben oft dasselbe. Das ist alles ganz harmlos. Aber wenn ich dann sage, ich schreibe mir das jetzt mal als JSON, auf die Festplatte, dann wird es sehr schnell sehr unangenehm. Oder ich laufe über die Datenstruktur rüber und dann dauert es endlos lange. Das heißt, das Problem ist nicht auf der YAML-Seite, aber es wäre natürlich schön, wenn man trotzdem in der YAML-Bibliothek irgendwas dagegen tun könnte. Und das geht halt nicht einfach, indem man die Alias erzielt, weil die Verwendung von Aliasen, das sind dann halt 100 Stück, aber es kommen tatsächlich eine Million Entries raus. Man kann da was gegen tun, ja.

Andy Grunwald (00:49:49 - 00:49:51)

RAM nachschieben, oder?

Tina Müller (00:49:51 - 00:50:15)

Also man könnte jetzt zählen, also ich habe das in meinem Vollmodul auch schon gemacht, aber noch nicht released, dass ich halt die Größe der Datenstruktur zähle beim Parsen. Also ich gucke halt, hier habe ich jetzt ein Alias und das Alias selber hat schon eine Punktezahl und dann rechne ich die noch mit drauf und würde dann tatsächlich am Ende auf diese Millionen kommen, ungefähr, und kann halt ein Limit angeben, was im Normalfall nie ausgereizt würde.

Wolfi Gassler (00:50:16 - 00:50:37)

Aber man muss ja auch sagen, das ist eigentlich das Behavior, was man gerne hätte, weil wenn ich daraus ein JSON machen will, dann ist es halt so, ist ja eigentlich eine korrekte Vorgehensweise. Also damit muss ich eigentlich immer rechnen, wenn ich meine Datenbank deserialisiere in irgendeiner Form und dann alle Referenzen auflöse, kommen auch ganz viele Daten am Ende raus. Also das ist halt die korrekte Vorgehensweise, würde ich mal sagen.

Tina Müller (00:50:38 - 00:51:22)

Ja, man muss halt nur vorsichtig sein, wenn man Wellen hat, denen man nicht wirklich vertraut. Und das ist ja heutzutage auch immer ein größer werdender Punkt, dass man YAML-Dateien liest von irgendwelchen GitHub-Pull-Requests oder sonst wo. Und dann kann man sagen, man kann immer rausfinden, wer denn der Böse gewesen ist oder die Böse, aber dann ist es vielleicht schon zu spät. Da muss man sich auf jeden Fall schützen. Also der klassische Angriffsvektor mit erstellen von Objekten und ausführen von beliebigen Code. Das ist mittlerweile, würde ich mal sagen, in allen Bibliotheken gelöst. PyYAML hatte als Default tatsächlich das mit drin als Feature, dass man beliebigen Code ausführen konnte. Und das wurde jetzt so geändert, dass man das Safeload als Default hat.

Wolfi Gassler (00:51:22 - 00:51:27)

Du hast schon YAML-Tags erwähnt. Kannst du mir das als YAML-Lion auch noch erklären?

Tina Müller (00:51:28 - 00:52:27)

Also Tags sind eigentlich ein Grund-, ein Basisfeature von YAML. Du siehst sie nur nicht. Die werden implizit benutzt. Also Strings und Integer-Tags, die sind implizit durch die regulären Ausdrücke. Man kann aber auch sagen, wie zum Beispiel das Beispiel mit dem Tuple. Wenn ich jetzt also einen Tupel in YAML haben möchte, dann kann ich bei Ausrufezeichen verwenden und Python slash Tupel schreiben und dann schreibe ich eine ganz normale Liste dahinter und dann wird das aber eben in Python als Tupel geladen. Also da gibt es eine ganze Reihe von von Tags, die halt in PyYAML so implementiert sind, sodass man alle Python-Datentypen damit auch sehr realisieren kann. Man kann aber eben auch sich eigene Tags definieren und Ansible oder AWS machen das, also in Ansible gibt es das Vault Tag, also Ausrufezeichen Vault und da steht dann ein verschlüsseltes Passwort drin und das wird dann beim Laden eben automatisch end.

Wolfi Gassler (00:52:29 - 00:52:39)

Das verwende ich sogar. Also hätte es mir ja wieder mal nicht gedacht, aber ich verwende es sogar. Aber das ist halt wieder so der Klassiker, copy-based irgendwo und man hat eigentlich keine Ahnung, dass da ein Feature dahinter steckt.

Tina Müller (00:52:39 - 00:53:16)

Genau. Und das lässt sich eben bei manchen YAML-Bibliotheken auch wirklich sehr einfach definieren. Du verwendest PyYAML und hast jetzt hier ein schönes neues Tag, was du verwenden möchtest. Und dann sagst du dem PyYAML einfach, den Tag-Namen und welche Funktion aufgerufen wird. Und dann funktioniert das. Und damit kann man eben, wie gesagt, bestimmte Objekte laden und in AWS wird das verwendet. Die haben auch die entsprechende JSON-Version, aber da muss man dann eben ein Objekt machen mit einem bestimmten, mit dem Objekt-Namen als Key und dann das eigentliche Objekt, was dann halt sehr verbose wird. Und mit Tags in YAML ist das ein bisschen schöner.

Andy Grunwald (00:53:17 - 00:53:38)

Ich habe gerade mal nachgeschaut, es wird wirklich bei AWS CloudFormation sehr viel in der Dokumentation erwähnt, in der Tat. Jetzt hattest du während deines FOSDEM Talks auch etwas angesprochen, wo ich noch nicht ganz genau weiß, wie ich damit umgehen soll. Und ich spreche von YAML-Skript. Was ist YAML-Skript und welches Problem löst YAML-Skript?

Tina Müller (00:53:39 - 00:55:28)

Ja, das ist noch relativ neu und das Problem, was eigentlich so immer von Leuten gefragt wird, ist, ich möchte jetzt hier irgendwas Programmatisches mit YAML machen. Ein klassisches Problem ist, ich möchte eine Liste wiederverwenden und merchen oder ein Hash wiederverwenden und merchen in einen anderen Hash. Das ist auch tatsächlich möglich. Das ist aber wirklich das einzige Feature, was man als programmatisch bezeichnen könnte in YAML. Und ansonsten ist es wirklich nur eine Serialisierung und keine Programmiersprache. Aber man möchte das eben haben. Und dann war halt die Überlegung auch, wollen wir eine neue YAML-Version, wo wir irgendwie sowas mit einbauen? Aber wie machen wir das? Und kommt dann auch schnell an seine Grenzen? Ist es dann eine richtige Programmiersprache oder nicht? Und dann hat Ingi sich gedacht, ich schreibe jetzt einfach mal eine komplette Programmiersprache in YAML selber. Und das ist dann wirklich, also das Skript selber ist eine valide YAML-Datei. Und es wird zu Clojure kompiliert. Und viel mehr kann ich auch gar nicht darüber sagen, weil das, also Clojure kenne ich auch nicht wirklich. Ist auf jeden Fall was mit Java. Also ein schöneres Java, sage ich mal. Und genau, mit YAML-Skript kann man also Daten und die Programmierung sehr gut vereinen. Also in dem Sinne, klar, man könnte alles auch mit einer normalen Skript-Sprache erledigen. Aber gerade wenn man eben Daten verarbeiten will, hat man mit YAML Script halt wirklich alles in einem. Man kann zwischen Daten und Programmierung in YAML Script hin und her wechseln. Man kann vom Datenmodus in den Programmiersprachenmodus wechseln. Und ich könnte mir jetzt zum Beispiel vorstellen, SaltDeck wäre so eine Anwendung, die vielleicht mit YAML Script besser lösbar wäre als mit Jinja Templating.

Andy Grunwald (00:55:29 - 00:56:20)

Du hattest schon die Frage aufgeworfen, die meine nächste Frage gewesen wäre. Warum brauchen wir jetzt YAML-Skript, wenn wir PHP, Perl, Python, JavaScript und etliche andere Skript-Sprachen haben? Du hast natürlich zwei gute Punkte genannt. Zum einen ist es, glaube ich, und den würde ich wirklich kaufen, das Argument, die wirkliche Verbindung, dass du alles in einem File hast, weil sonst hast du nämlich hier diese Daten und dann drüben in einem anderen Ordner, in dem Scripts-Folder, da liegt so dieses magische Python-Skript und du musst erstmal irgendwie in deinem Kopf verbinden, dass dieses magische Python-Skript da hinten mit diesem YAML-File funktioniert, beziehungsweise dass der Pre- oder Post-Prozessor ist. Und ja, du hast, glaube ich, auch den Mega-Use-Case von SaltStack rausgeholt, würde ich, glaube ich, auch sagen, okay, dann können die Jungs Mädels von Zork dann ein valides YAML schreiben vielleicht. Das wäre natürlich dann schon eine super Sache.

Wolfi Gassler (00:56:20 - 00:57:01)

Auf der anderen Seite muss man natürlich sagen, wenn ich jetzt zurückdenke, ich komme ja aus der Datenbankwelt, in den 70er Jahren war das die große Errungenschaft, dass man Daten von dem Code, von der Programmierung an sich trennt, mit dem relationalen Modell unter anderem und Jetzt geht man wieder eigentlich zurück und mischt das wieder alles. Irgendwie erscheint mir das auch sehr eigenartig. Aber ich kenne es natürlich selber von Ansible. Es ist teilweise so schwierig, in irgendeiner Form so eine For-Loop reinzubringen. Und für mich als Programmierer ist das eigentlich so schwerfällig. Und auch Debugging ist extrem mühsam. Ich verstehe, woher man da kommt. Und wenn man da eine gute Lösung findet, macht das meiner Meinung nach sicherlich Sinn.

Tina Müller (00:57:02 - 00:57:55)

Ja, also ich frage mich aber auch noch so ein bisschen, wo die Reise hingeht. Also gerade eben das Problem mit den Quellen, denen man nicht vertraut. Also ein YAML-Skript will man natürlich nicht von jedem annehmen und ausführen. Also das beschränkt sich dann wirklich nur auf den Teil, wo du eben selber Kontrolle hast. Und das ist eben auch noch ein Unterschied zu dem klassischen YAML-Ansatz, wo es verschiedene Sprachen gibt, die das implementieren. Und hier ist eher der Ansatz, Ingi hat diese Bibliothek geschrieben und es gibt jetzt eine Shared Library und in möglichst vielen Sprachen wird das als Binding implementiert. Also hast praktisch eine Implementierung als Shared Library. Und Ingi ist halt eher so der Erfinder, so ein Visionär. Und man muss vielleicht auch ein bisschen neu denken, um sich Anwendungsfälle auszudenken. Ich bin wirklich selber sehr gespannt. Also er hat da wahnsinnig viel Arbeit reingesteckt. Und vielleicht werden wir es in zwei Jahren alle verwenden.

Wolfi Gassler (00:57:55 - 00:58:01)

Das ist jetzt aber noch nicht im Standard, im 1-2-Standard drin? Oder ist das schon Teil vom Standard?

Tina Müller (00:58:01 - 00:58:17)

Nee, das ist also komplett getrennt, sag ich mal, vom YAML-Standard. Also das YAML-Skript ist in YAML geschrieben und muss valides YAML 1.2 sein. Von der Syntax gar nichts Neues. Du kannst also mit der YAML-Version einfach YAML-Skript schreiben, weil es die Syntax schon erlaubt.

Wolfi Gassler (00:58:17 - 00:58:26)

Also es ist dann die Interpretation des Inhaltes eigentlich. Das ist dann der Programmcode, der dann transbilliert wird oder wie man da auch immer dann sagt.

Andy Grunwald (00:58:27 - 00:59:05)

Auf yaml-script.org gibt es auf jeden Fall diverse Beispiele. Verlinken wir natürlich auch in den Show Notes. Und Humor ist auch dabei. Wenn man ganz runter scrollt, dann steht nämlich da, a stable release of YAML Script version 0 is expected in quarter 2 of 2024. Das finde ich, habe ich gerade zum grinsen gemacht. Schöne Nummer, jammelscript.org, schaut euch das mal an, falls ihr vor habt, Jammellateien zu modifizieren. Tina, was würdest du denn jetzt noch allen Leuten an die Hand geben, die in irgendeiner Art und Weise mit Jaml arbeiten? Welche Tools würdest du als dein Schweizer Taschenmesser beschreiben, ohne die man jetzt da eigentlich nicht mehr drum rum kommt?

Tina Müller (00:59:06 - 00:59:47)

Ja, also auf jeden Fall würde ich YAML Lint empfehlen, den Standard Linter für YAML. Und ich glaube, das verwenden auch schon wirklich viele. Das macht es einfach ein bisschen sauberer, dass die Einrückung gleich ist und überflüssige Spaces und so weiter. Und YAML Tidy ist ein Projekt von mir, was noch relativ neu ist und noch nicht so viele Features hat. Man kann das aber auch zusammen verwenden. Also YAML-Tidy kann dir schon mal Spaces rauswerfen oder unnütze Quotes, dann kannst du aber hinterher immer nochmal YAMLint drüberlaufen lassen. Und insbesondere, wenn man eben also Quellen hat, denen man nicht vertraut, ein Schema sich zu überlegen für die YAML-Dateien und ein, also zum Beispiel JSON-Schema drüberlaufen zu lassen.

Wolfi Gassler (00:59:47 - 00:59:53)

Das heißt, ich kann dann JSON-Schema verwenden, um YAML zu spezifizieren, also um die Struktur zu spezifizieren.

Tina Müller (00:59:54 - 01:00:02)

Genau, am Ende lädst du es ja auch in eine Datenstruktur und woher die Datenstruktur kommt, ist dem Schemachecker ja dann egal.

Wolfi Gassler (01:00:02 - 01:00:05)

Aber muss ich dann den Umweg über JSON machen?

Tina Müller (01:00:05 - 01:00:14)

Nö, also du lädst es einfach nur mit der Bibliothek, die du nehmen möchtest, in eine Datenstruktur ein und lässt dann den Validator drüber laufen.

Wolfi Gassler (01:00:14 - 01:00:25)

Also gibt es jetzt sowas wie JSON-Schema, auch YAML-Schema? Weil du hast ja gesagt, YAML ist umfangreicher. Das heißt, ich kann ja eigentlich mit JSON nicht alles ausdrücken, was ich in YAML definieren könnte.

Tina Müller (01:00:25 - 01:00:58)

Das stimmt. Also es gibt noch keinen Schema-Validator, der jetzt die speziellen Sachen validieren könnte. Aber das sind eben auch Sachen, die selten vorkommen. Und JSON-Schema sollte da schon für die allermeisten Sachen ausreichend sein. ich auch noch empfehlen. Da sind noch ein paar Basics erklärt und sich einfach ein bisschen mit Jaml beschäftigen, auch wenn es vielleicht weh tut am Anfang. Aber die Features sind gleichzeitig auch manchmal ein Fluch.

Wolfi Gassler (01:00:58 - 01:01:25)

Aber Jetzt eine persönliche Frage noch von mir, weil ich am Anfang mich auch beschwert habe. Ich glaube, es ist schon fast zehn Jahre her oder so, wie wir da mit Andi gekämpft haben. Und das waren irgendwelche unsichtbaren Chars, die wir nicht gefunden haben und so weiter. Obwohl wir alles probiert haben, unsichtbare White Spaces anzuzeigen und alles Mögliche. Hilft mir da Jammerlind in der Form oder sagt Jammerlind nur falsch? Oder gibt mir das auch irgendwie Hinweise, wo was falsch sein könnte? Und da mehr Informationen.

Tina Müller (01:01:25 - 01:01:51)

Also YAMLint sollte dir eigentlich die Stelle auch zeigen, die Zeilennummer und Column. Ich verwende persönlich auch noch YAMLpp-Highlight. Das ist halt ein Skript von meinem YAML-Modul und das macht halt das Highlighting vom YAML und sobald die Stelle kommt, wo das Ganze invalide wird, wird alles rot angezeigt. Das finde ich sehr praktisch. Da siehst du wirklich sehr schnell, an welcher Stelle der Fehler ist, ohne selber jetzt die Zeilennummer irgendwie suchen zu müssen.

Wolfi Gassler (01:01:52 - 01:02:01)

Ich glaube, das hätte uns damals Zeit erspart. Wir haben zwar irgendeinen Linter ausprobiert, glaube ich, aber wir sind da auch nicht wirklich weitergekommen. Aber ich hoffe mal, in den letzten zehn Jahren hat sich was getan.

Andy Grunwald (01:02:02 - 01:02:22)

Kennst du diese Leute in deinem Freundeskreis, die immer sagen, Wolfgang, damals, als wir im Kindergarten waren, weißt du noch dieser eine Tag, wo wir mit diesem Elefantenspielzeug irgendwie Rennen gefahren sind oder so? Ich so, nee, keine Ahnung. Und so ähnlich geht es mir gerade mit deinem Jammelproblem auf einem Hackathon. Anscheinend habe ich das so verdrängt, ich verstehe nicht, wann das war, ich weiß es nicht mehr.

Wolfi Gassler (01:02:22 - 01:02:35)

Ja, du hast das nur verdrängt, weil du unbedingt YAML verwenden wolltest und ich wollte ja nicht verwenden. Darum ist mir das natürlich so im Kopf gelegen. Aber ich sehe schon, mit den richtigen Tools an der Hand ist das alles beherrschbar. Also das ist kein Problem.

Tina Müller (01:02:35 - 01:02:38)

War vielleicht auch ein Parser, den ihr da verwendet habt, der irgendwie was falsch gemacht hat?

Wolfi Gassler (01:02:38 - 01:02:44)

Das kann natürlich auch gut sein. War sicher irgendwas in Go, wenn der Andi dabei war.

Tina Müller (01:02:44 - 01:02:45)

Vor wie vielen Jahren?

Andy Grunwald (01:02:46 - 01:02:53)

Damals gab's die Teststudio noch nicht. Also, ich glaub, die kam danach. Da hätten wir natürlich auf die Teststudio geguckt und uns den richtigen Parser rausgesucht.

Tina Müller (01:02:54 - 01:03:01)

Ja, aber da gibt's wirklich noch viel zu tun. Also, ich könnte jetzt, glaub ich, ein halbes Jahr Vollzeit an Dingen arbeiten, an YAML-Geschichten.

Andy Grunwald (01:03:02 - 01:03:10)

Ja, ich würd sagen, da hilft nur eins, eine YAML-Foundation gründen. Oder irgendwie Teil der Linux-Foundation zu werden und von da aus weiterzumachen.

Tina Müller (01:03:10 - 01:03:13)

Tatsächlich auch schon angedacht, so was. Aber mal schauen.

Andy Grunwald (01:03:14 - 01:03:46)

Dann wünschen wir dir natürlich viel, viel Erfolg dabei. Und für alle Hörerinnen und Hörer, die gerne etwas mehr über YAML erfahren wollen. Wir haben eine umfangreiche Linkliste in den Shownotes verlinkt. Da findet ihr auch das Gitterprofil von Tina und unter anderem dann auch natürlich die YAML-Libraries an, sie mitarbeitet, falls ihr Lust habt ein bisschen was für das YAML-Ökosystem zu tun, ich glaube Pull-Requests für die Test-Suite sind auch sehr gerne willkommen, anscheinend besonders im Container-Bereich und im Integrieren von neuen Libraries.

Wolfi Gassler (01:03:46 - 01:03:51)

Ja, Andy, du deliverst dann diese zyklomatische, den Check, oder, dafür, für dieses Problem?

Andy Grunwald (01:03:51 - 01:04:01)

Und ganz auf die Liste, genau, direkt nach Podcast produzieren. Und Tina, gibt's noch irgendwas von deiner Seite, was du den Hörerinnen und Hörern zum Thema YAML mitgeben möchtest?

Tina Müller (01:04:02 - 01:04:05)

Oh, jetzt haben wir schon über so viel gesprochen, jetzt die Frage.

Andy Grunwald (01:04:05 - 01:04:09)

Du kannst auch einen Kriegsaufruf machen, nutz YAML, das ist das bessere Jason oder sowas.

Wolfi Gassler (01:04:10 - 01:04:12)

Das ist ja ein Superset, das ist schon erledigt.

Tina Müller (01:04:13 - 01:04:31)

Ihr könnt auch tatsächlich gerne Tummel verwenden und damit macht ihr bestimmt Ingi glücklich, der sich ärgert, dass YAML für einfache Config-Files verwendet wird. Also ärgert euch nicht über YAML, sondern denkt einfach, es ist einfach so mächtig und es hat Vorteile und Nachteile. Es kann vieles und es kann auch Spaß machen.

Wolfi Gassler (01:04:32 - 01:05:09)

Vielen lieben Dank. Du hast mir auf jeden Fall aufgezeigt, meine Schwäche, obwohl ich ja jeden Tag verwende, wie wenig Ahnung ich eigentlich habe. Es ist ja meistens nur eine halbe Stunde, die man investiert, um den Syntax richtig zu verstehen. Alleine das ist eigentlich schon peinlich, muss ich sagen, dass ich das nicht auf die Reihe bekomme. Aber das werde ich auf jeden Fall mal machen und die ganzen neuen Features schaue ich mir gerne auch mal an, weil das klingt schon nach sehr coolem Zeug, was man auch damit realisieren kann. Abschließend, würdest du jetzt eine API noch wirklich mit YAML bedienen, wo man heutzutage ja überall JSON verwendet, oder würdest du sagen, es macht dann weniger Sinn, wenn man in die Richtung geht?

Tina Müller (01:05:10 - 01:05:24)

Das kann schon sinnvoll sein, eine YAML-Option zu haben. Also die meisten API-Sachen lassen sich mit JSON ausdrücken, aber eine YAML-Option zu haben, einfach um es lesbarer zu machen, finde ich schon ganz praktisch. Sonst muss ich immer irgendwie mit JQ noch drübergehen.

Wolfi Gassler (01:05:24 - 01:05:36)

Du fährst mit JSON-Buzzer eigentlich, um es lesbarer irgendwie zu machen. Das stimmt, wenn da so ein Zeug daherkommt, ja. Also das sehe ich jetzt auch, könnte natürlich ganz cool sein, da was menschlich Verständliches zu haben, lesbares zu haben.

Tina Müller (01:05:36 - 01:05:47)

Und wir freuen uns auch, das wollte ich noch erwähnen, wir freuen uns auch, wenn ihr in unseren Matrix-Channel kommt und da Fragen stellt. Das ist jetzt noch nicht so überlaufen. Ja, kommen ab und zu mal ein paar interessante Fragen.

Andy Grunwald (01:05:47 - 01:07:08)

Diese Episode zeigt mir immer wieder, wie viel man eigentlich durch die Produktion eines Podcasts und durch so interessante Gäste wie dir, Tina, lernen kann. Am Anfang des Podcasts, also hättest du mich vor zwei Jahren gefragt, lass doch mal über Jammel reden. Hätte ich gesagt, ja, sorry, aber da kriegen wir doch keine halbe Stunde mitgefühlt. Es ist wirklich faszinierend, wie tief diese einzelnen Themen gehen und ich habe gerade auch nochmal die Test Suite aufgemacht und auf der Test Suite gibt es nämlich oben links einen Link, der nennt sich Test Case Sheet und da klickt man da auf Valid und dann kriegt man eine ellenlange Browserseite über alle validen YAML Cases. Ich habe gedacht, ich verstehe was von YAML und jetzt habe ich aufgegeben, nein, ich tue es eindeutig nicht. Ich habe auf jeden Fall eine ganze Menge zu lernen, nicht nur YAML Flow Style, wie wir besprochen haben, sondern auch Tags. Man kann anscheinend mit .binary Datentypen entforcen, wie ich gerade gesehen habe. Wahnsinn. Ja, ich habe ein bisschen Angst, dass ich jetzt YAML overengineere und dann meine Parser in den ganzen Tools auf die Mütze fallen. Aber nun schauen wir mal, wo ich dann lande. Tina, vielen lieben Dank für deine Zeit. Grüße aus dem Ruhrgebiet in die Hauptstadt. Vielen lieben Dank für deine Zeit und habe noch einen schönen Tag.

Tina Müller (01:07:08 - 01:07:11)

Ja, vielen Dank fürs Zuhören und dass ich hier sein durfte. Danke.

Wolfi Gassler (01:07:11 - 01:07:13)

Danke. Ciao.

Tina Müller (01:07:13 - 01:07:13)

Ciao. Bye-bye.