JSON Schema für Struktur und Validierung von JSON-Daten #79

Moin, hier ist wieder euer Liebling. Software und IT Podcast einfach komplex zu Folge 80 nein Scheiße, das hatte ich jetzt falsch im Kopf von Burkhardt. Gerade meinte ich so 80 OK lassen wir vielleicht drin also Moin zur Folge 79 natürlich von einfach komplex und heute geht es um Jason Schema genau und ja hier spricht Gerrit hab ich vergessen und Burkhard ist natürlich auch da. Ja Moin, aus Hamburgs Vorigerit für die Folge 80, die ich dir

jetzt noch. Ins Gehirn gedreht hab ja 1 vor der 8080 klingt irgendwie gut, ja, aber n schönes Thema heute.

Richtig heut n schönes Thema und wir sind auch wieder zu zweit in der kleinen Podcastfabrik hier kurz vor knapp am Montag Nachmittag, also lass uns nicht lange rumreden machen wir eigentlich nie und über Jason Skema reden bei Jason, da hab ich schon mich erinnert das ein oder andere Thema was wir da schon hatten, wir haben Jason als Datenformat schon verglichen mit XML und auch mit anderen datenformaten, ich meine sogar

auch jammel. Und sowieso ist Jason eigentlich so n so n so n Dauerthema und Dauerbrenner auch bei uns bei der Heisenware. Aber Jason Kemer hab ich noch nie gehört, vielleicht zum Start kurz mal ne Einordnung und was hat das dann mit Jason zu tun? Ist Jason Kemer? Mhm, also für die Einordnung mach ich nur einen Satz, den man vielleicht jetzt noch nicht versteht, weil wir müssen noch mal glaub ich rekapitulieren, was Jason genau war, um Jason Kemer zu verstehen, weil sich darauf aufbaut.

Ja, aber vielleicht in einem Satz vorweggeschickt, das soll man ja können, wenn man auch Pitcht, der der Elevator Pitch sag ich mal. Json ist ja ein Dateiformat oder ein Datenformat, nicht Dateiformat. Ein Datenformat, in dem ich beliebige Daten sehr, sehr beliebige Daten nämlich speichern kann und das json scemer ist quasi ein eine Art Rezept, eine Anleitung, die es ein wenig eingrenzt, was ich an technischer Flexibilität hab, weil ich nämlich zum Beispiel Anwendungsspezifisch nur eine

bestimmte. Untermenge von Konfigurationen oder von Daten, die ich in meinem Jason drin haben will, sehen möchte. Und das möchte ich quasi vordefinieren auch als festes Datenstück, also ohne sich ne Anwendung schreibe will ich ausdrücken, was sind die möglichen validen Jason Dokumente sag ich mal oder Daten die ich sehen möchte gegeben meine Anwendung ne das ist das ganz grob gesprochen klingt sehr nischig, ist auch irgendwie gefühlt n Randthema aber wir machen ja gerne mal Randthemen.

Aber wenn man es wieder jetzt genau anguckt, wird man merken, dass dieses Randthema doch voll relevant ist und überall wichtig ist. Dazu kommen wir glaub ich in der Folge. Ist denn so n Jason Skemer dann irgendwie Teil von einer Anwendung? Also irgendwo im Code dann auch zu finden oder oder verlinkt als Abhängigkeit oder wo taucht das eigentlich auf? Ja, also erstmal muss man ganz wichtig vorwegschicken, dass ein Jason Skemer auch n Jason ist. Mach jetzt mal kurz ne Pause,

muss einmal kurz verdauen. Ja also das. In mit dem Jason Scemer drück ich ja was aus, wie andere Jasons auszusehen haben, aber ich schreib es auf in Jason.

Also es ist Jason konform, ja, insofern genau kann ich es im Code haben und wenn wir wenn wir sagen Jason, jetzt machen wir jetzt gehen wir mal kurz ins Recap rein ne ja das war jetzt war noch mal Jason gerade ist ja die javascript Object Notation dafür steht es entlang JSON und javascript sagt schon ne also in der wenn ich jetzt javascript programmiere dann ist quasi der.

In der Programmierung der Datentyp Objekt entspricht exakt dem Jason Objekt, dem worüber wir heute sprechen und so nen Jason Objekt. Das kann ich auch serialisieren sagt man und Serialisieren heißt ich kann es quasi als Pfeil auch abdrucken, aufschreiben aufspeichern ja man kann es richtig angucken, man kann es lesen als Mensch. Ne Maschine kannst du sowieso lesen und ist hochoptimiert. Vor allen Dingen wenn ich in javascript bin ne. Es ist aber nicht an javascript gebunden.

Als Programmiersprache ist es ein sehr sehr generisches und generelles Austauschformat und das schick ich auch noch mal kurz vorweg als Recap fast, ich weiß nicht, will mich nicht festlegen, aber fast jede moderne Rest ABI Schnittstelle tauscht ihre Daten nach dem Aufruf der Endpunkte und so weiter aus im Format Jason Ne es ist einfach überall das Jason ne. Und wenn wir jetzt noch mal kurz rekapitulieren, wir haben die Folge, wer da noch mal richtig

tief rein will, der kann die Folge über Jason noch mal hören. Ich denke, wir verlinken sie noch mal, aber noch mal ganz kurz die wichtigsten Sachen gesagt, ich hab im Jason 6 verschiedene Datentypen die ich benutzen kann, das ist erstmal wichtig und die kann ich auf verschiedene Arten und weisen nutze, aber welche 6 Datentypen sind es?

Es ist das 00 heißt ich hab irgendwie nichts gesetzt ja es Datentyp 0 gibt es. Habe ich einen Wahrheitswert Bolien, der kann also nur die Werte true und false annehmen, dann habe ich den String, kennen wir also Hello World oder Burkhard Heisen zum Beispiel als Name und so weiter ist alles ein String, sind typischerweise auch dargestellt durch diese doppelten hochkommata Anführungszeichen heißt es glaube ich auf deutsch Doppel, Ticks auf Englisch und dann habe

ich den Datentypen Nummer Nummer ist alles was ne 1 ne 23,4 ist. Also alles numerische. Ist einfach number.

Das ist sehr vereinfacht. Es gibt in den meisten Programmiersprachen deutlich verschiedene Typen für Nummern, also zum Beispiel integer als Ganzzahlen und Floatings für für Gleitkommazahlen und so weiter so nicht in JSON, da gibt es einfach nur die Number und dann hab ich die 2 wichtigsten weiteren Datentypen, das Array und das Object Array ist quasi ne Abfolge von Einträgen. Ich sag es mal so platt, die Einträge sind noch nicht mal limitiert auf den gleichen

Datentyp, sondern ich hab quasi ne Abfolge von Items. Es kann sein One, Two, Three als 123 geschrieben, also als number. Ja das könnte ich, könnte aber auch schreiben als String One Two, ausgeschrieben im English Three und machen ne Array davon. Ja das ist nicht definiert, ist frei wählbar und dann hab ich noch das Objekt und dann haben wir das Objekt als Container von Key Value Pairs.

Also im Gegensatz zum Array, wo ich quasi nur Values mit Kommas hintereinander aufschreibe, hab ich beim Object immer nen Key zu einem Value. Also das das ist so n typisch, wenn man sich jetzt, wenn man so n typisches Analogum dazu ist. Wenn ich ne webform hab zum Beispiel First Name, Last Name Age, dann kann ich jetzt das Objekt speichern, dann hab ich tatsächlich den Key First Name doppelpunkt und dann halt der jeweilige First Name last name. H wert dann Beispiel Typ Number.

Ja und genau hier gilt es wieder die die Keys sind Strings, die haben Strings zu sein, die Values können wieder irgendein Datentyp sein. Ja und jetzt noch ganz kurz und das ist sehr sehr wichtig aus diesen 6 Typen nalpuline String Number Array und Object sind 2 besonders das Array und das Object, nämlich weil die sogenannte strukturgebende Typen sind, weil die erlauben es quasi ne Nesting aufzubauen. Ja ich hab ja gesagt es kann einem Array.

Und in einem Objekt kann der Typ beliebig sein, beliebig, aber halt wieder nen Jason kompatibler Typ natürlich, aber ich kann also quasi Objekte von Objekten haben. Ja, der Value von einem Objekt könnte wieder n Objekt sein mit Key Values und so weiter und dann fang ich an zu Schachteln ja oder ich kann haben nen Array von Objekten und sofort und damit wird es grenzenlos groß, grenzenlos frei wie das alles aussehen kann. Ja ich kann riesige Jasons

aufbauen mit. 56 Siebenfacher verschachtelungsstufe und so weiter ja, und das wird auch gemacht, ja. Bei uns ist das doch auch in der in in unserer Low Code Entwicklungsplattform schwer im Einsatz. Json Files an der Stelle, oder? Ja, genau, also wir benutzen ja wir, wir arbeiten ja mit Daten in der in der in der also alles arbeitet, ja irgendwo mit Daten jede Anwendung, und wir stellen die immer als json dar, ja genau wir, wir haben uns festgelegt.

Unsere Low Code Plattform auch genau diese Typen zu unterstützen und auch wenn irgendwas rankommt wenn wir ne API aufrufen zum Beispiel man das sieht in der Low Code und sich das anschaut, dann sind das quasi Hingeschriebene auf dem Bildschirm gedruckte Jason Objekte.

Guthaben wir es verstanden was das Jason ist und wo es eingesetzt wird. Jetzt ist es so, jetzt machen wir heute den Sprung zu dem Jason Schema und das hat man jetzt schnell erklärt. Ich mach es an einem Beispiel, da kann man es immer am besten sagen, sagen wir mal ich nehm jetzt Jason. Um in einem webformular Daten rauszuholen, und zwar so was ganz klassisches wie ne Person.

Da will ich also Abfragen Firstname, Lastname, Age und Adresse sagen wir mal ja und diese Information verpack ich in den json ne jetzt könnte das JSON aufgebaut sein und hat n Key also außen kann es jetzt erstmal n Objekt das ist wichtig, das hab ich damals schon gesagt, das ist ganz cool, das weiß immer keiner jeder denkt. Jason müsste immer von außen her n Objekt sein.

Ja, also Anfang mit so einer geschweiften Klammer, das das Zeichen für Objekt ja und dann Key Values haben, das stimmt nicht, also selbst true, also einfach das Wort true ist n validis Jason ja dann hab ich halt einfach den Wahrheitswert hingeschrieben ja oder leeres Objekt ist auch n Validis Jason Leeres Array ist auch n also jedes jedes dieser Datentypen kann alleine für sich n Jason bilden.

Ja das soll ich noch mal vorweg Vorwegschicken, das weiß noch mal die Hälfte der Welt nicht, aber es ist so.

Aber jetzt sagen wir mal, wir nehmen jetzt diese Daten, diese Webformdaten auf in Ian json Objekt außen, dann könnt ich jetzt zum Beispiel hinschreiben Name und da steht da drin Gerrit Meyer Age, das musst du mir helfen, ich weiß nicht ob du es verraten willst von Gerrit 35 das geht schon um 30, da hab ich mich nicht getraut im Podcast jetzt hier, weil ich daneben Gelegenheit oder als Ärger gebe, nicht so gut OK age nee 30. Dann hab ich nicht so viel über mein Alter, das passt schon.

Dann ist gut ja ich auch nicht genau und dann könnten wir bei Adress haben. Auch einfach nur nen langen String, so wie das gerne Google macht. Ja also schulterblatt, Hamburg und so weiter und sofort ja hinten dran oder aber wir wir bauen das ganz anders auf ne also das wär jetzt eine Möglichkeit.

Ja ich hab halt den Name, da hab ich den Gerrit und den Meyer ja Vornamen Nachnamen zusammengeschnitten ja beim Age und dann hab ich n Adress auch wieder als String ja und hab die Information gespeichert jetzt könnt ich aber ich kann aber auf die Idee kommen, dass ich sage dieses Jason die sieht ganz anders aus wenn ich die Information abgefragt hab von Gerrit da steht halt so ne First Name Gerrit dann hab ich noch n

Key last name. Meyer jetzt hab ich vielleicht immer noch den H Key, der ist relativ klar und danach hab ich den Address Key und in dem Address Key hab ich gar nicht als Value in String wie ich das gerade vorher angeteasert hab wo ich alles in einer Reihe nach Hinschreibe sondern jetzt drösel ich das wieder auf sage Address Doppelpunkt ist vom Typ wieder Objekt und da drin hab ich den Key Street zip Code City und so weiter und sofort ja so und warum mach ich jetzt dieses

Beispiel? Ihr merkt schon also während ich. Das gleiche Ding nehme nämlich Jason, um die gleichen Daten zu beschreiben, hab ich es aber

doch irgendwie anders gemacht. Ja, weil die innere Struktur und der Aufbau von dem ersten Beispiel Jason und von dem Zweiten ist ja relativ unterschiedlich, ja und wenn man das jetzt weiterdenkt und wenn wir jetzt über API sprechen und über Anwendungen, verschiedene Anwendungen, die sich Informationen teilen, weiterverarbeiten, dann ist das schon n Problem, ja weil es müssen ja irgendwelche Annahmen geben, wie ich diese Daten dann bekomme. Hast du es für n Computerprogramm ja relativ.

Schwer zu sehen von außen, was da jetzt los ist, wie das weitergegeben wird. So und jetzt kommt das Schema ins Spiel und das Schema, das wird glaube ich ganz klar das Schema gibt vor wie dieses Jason auszusehen hat in diesem Beispiel. Ich schreibe also im Schema hin pass auf, ich brauche jetzt hier auf dem obersten Level ein Objekt und ich erwarte folgende Keys First Name Last Name Age address. Und jetzt lege ich auch zu jedem Key den Datentyp fest und das ist total wichtig.

Ich will den Punkt noch mal machen, also wenn wir über Jason sprechen, sprechen wir halt ganz wichtig, aber es ist n paar mal gesagt mit Datentypen, airray, String und so weiter aber das strikt verhandeln von Datentypen ist 1 der wichtigsten Dinge die das Jason überhaupt erledigt. Ja und das Jasons Klima dann auch mit ja es ist nämlich n riesen Unterschied zum Beispiel ob Age halt einfach n String ist. Und das ist es nicht, sondern h wird halt ne Nummer sein.

Ja ne number ja und dann kann ich mit dem HMV auch anfangen zu rechnen, das ist später total wichtig.

Ja und Average machen und so weiter ja kann dann ne statistische Auswertung über meine Person machen kann ich sagen, ja die sind alle zwischen 10 und 30 Jahre alt und so weiter ja ich kann aber in der Informatik nicht addieren wenn ich n string hab, das funktioniert nicht so und das ist halt wichtig ja das ist das schon mal, die ist ist das erste essentielle was das Schema vorgibt welchen Key von welchem Datentyp ja also da steht in dem Schema drin First Name muss

string sein. Last Name muss drin sein, muss auch String sein, Edge muss drin sein und ist vom Datentyp Number und Address wenn ich es jetzt so festlege ist vom Datentypen da steht im Schema drin, muss vom Datentyp her Objekt sein und dieses Objekt muss wieder die folgenden Keys haben, nämlich City Street, Postal Address oder irgendwo was. Ja das leg ich alles fest und deren Typen ne.

Das versteh ich soweit und ich verstehe noch nicht so ganz, was es jetzt in der Praxis. Bedeutet, weil jetzt könnte man das ja einerseits als so ne Art Read me oder Dokumentation

verstehen. Ha, da gucken wir jetzt mal rein und da steht das jetzt so genau drinne wie jetzt zum Beispiel diese diese diese persönlichen Daten da die Du genannt hast zu verarbeiten sind, wo man halt als Entwickler reinguckt oder sorgt das dann dafür, dass wenn jemand versucht zum Beispiel in Adresson String über ne AP reinzuschicken, dass da ne Fehlermeldung dann aufpoppt oder so? Also es ist das was hilft bei der automatischen

Datenverarbeitung dann. Kannst du das noch mal ein bisschen in den Kontext setzen oder erklären? Ja, genau, wir. Haben sie noch nicht übers

Tooling gesprochen? Aber ja, genau, wenn ich, also ich, wenn ich quasi n Schema hab, dann hab ich ja ne Vorschrift wie mein Jason auszusehen hat und hab ich ne Vorschrift und ist das standardisiert, dann kann ich das auch validieren, das ist dann der nächste Punkt ja also ich hab ne Horde von unsere Tools, die gibt es in allen möglichen Sprachen, da kann ich jetzt nehmen.

Ein erzeugtes Jason. Man spricht auch manchmal von einer Jason Instanz. Ja, also dein Personaleintrag Gerrit mit deiner Namen und deiner Adresse, das ist quasi eine Instanz von einem Jason von der Sorte kann es ja ganz viele

geben, ja deswegen sagt man Instanz ja, die Struktur ist immer gleich, die Struktur steht im Schema First Name Last Name Age Address als Objekt ja und davon kann ich dann ja dann je nachdem was ich für ne coole Anwendung hab 2000 Personaldaten aufnehmen ja die sehen immer gleich aus so jetzt ist aber wichtig wenn diese Daten halt reinkommen. Und die Frage ist noch, wo kommen Sie rein und wann tue ich

das? Aber erstmal ganz grundsätzlich gesprochen, ich kann das Validieren, ja, ich kann jetzt sagen, dieses Jason was ich hier hab und das Jason Schema was ich hier in der anderen Hand hab die 2 die pack ich jetzt in den tatsächlich in den Tool weil das sind nämlich 2 Datenstrukturen, keine Anwendung keine Programme das noch mal festzuhalten das Schema schreibt sich genauso auf mit einer das gibt es ne Anweisung wie man das zu schreiben hat wie das Jason das

sind also quasi 2 Objekte oder 2 Files ja und die kann ich in den Tool geben, das ist n. Jason Scema Validator also n Jason Jason Validator gegebenen Scema und der guckt einfach. Ist dieses Jason was da jetzt reinkommt, valide? Ja ist dann Key zu viel drin, fehlt da einer und so weiter oder ist das alles passt das alles? Ja und wenn das alles passt, dann bin ich halt fertig, dann schreib ich halt danach business Logik und da muss ich mich nicht mehr drum kümmern ob das alles richtig ist.

Weil wenn man Software schreibt und nicht. Und das ist immer das Problem, wenn man Eingaben hat. Ja hast du nur ne Software die für sich lebt auf dem Planeten die nie von außen ne Eingabe bekommt, dann ist alles safe weil dann weißt du was du tust. Ja in dem Moment wo n Nutzer dir ne Eingabe macht, dann weißt du ja nicht mehr was der tut.

Ja du hast irgendwelche Felder so an irgendeiner Stelle in deinem Code musst du ja halt irgendwie mal glatt ziehen was der eingeben kann, ja sonst kommst du ja, sonst musst du ja alles programmieren was der da eingeben könnte, du kannst ja alles da eingeben in so ne Webform mehr oder weniger ja. Gilt das jetzt nur für ne manuelle Eingabe oder auch. Andere Form von Input Ja auch über ne AP zwischen reinkommt also. Genau also die manuelle Eingabe

ist am schnellsten verstanden. Aber nein, es geht natürlich über das über hinaus, ja und ja und und jetzt ich schließ jetzt kurz mal vorweg n Kreis ja ich hab ja ganz am Anfang gesagt zum Beispiel Jason ist de facto Standard beim Austausch der Daten, wenn ich rest APIS aufrufe so ne Rest API. Ist ja auch wenn ich sie benutzen will, muss auch

dokumentiert werden. Ja, entweder für mich als Entwickler, damit ich sie verstehe, oder mindestens aber für wenn ich dann so n cooles Tool hab für für den Klienten und der ist jetzt nicht mehr der Mensch. Ja, also normalerweise sind es ja, wenn ja Rest API sind ja andere Computerprogramme, sogenannte API Clients, die die zur Verfügung gestellte AP verdauen und da steht, wenn die ordentlich dokumentiert ist, kommen wir später auch gibt es auch ne Standard für da steht halt drin.

Wie muss die Request sein? Ich mach ja immer 2 Sachen bei einer IP, ich frag ja was an und ich bekomme was wieder und sowohl die Anfrage als auch das als auch die Response der der der Rückgabewert werden in Jason formuliert. Ja und damit ich aber weiß was ich überhaupt n Jason dahin schicken muss weil ich kann ja viel Jason machen, das haben wir gerade gesehen, steht in der API Dokumentation von der Rest Server Schnittstelle dran in Jason Scemer oder einer Unterart

kurzes Disclaimer für später. Da steht steht quasi dran, wie das auszusehen hat und wie das aussehen wird, was ich

zurückbekomme. Ja, von der Struktur her, nicht vom Inhalt. Der Inhalt ist ja dann, das sind ja die Daten selber, inhaltlich weiß ich nicht so, ja, das ist spannend, das kommt dann meine Datenbank oder so, aber von der Struktur dieses Jason Objektes ist es festgelegt und definiert, ja insofern brauch ich das ja genau das, das führt uns glaub ich Gerrit n bisschen zu dieser Entstehungsgeschichte, das gab es nämlich. Tatsächlich, und da hast du dich

besser aufgegleist, glaub ich. Als ich, aber es ist es gab das Jason wurde erfunden quasi und da muss man jetzt auch noch mal kurz sagen, eigentlich als nach Burnout zum XML früher, es gab mal ne Zeit lang, da gab es eigentlich nur XMLXML ist ja ähnlich wie Jason, wer da jetzt noch mal genau hören will, der hört wirklich noch mal die Folge wo es komplett auseinander genommen haben ja und im XML gab es auch schon und das auch schon

lange und vorher bevor es Jason gab wahrscheinlich nagelt mich jetzt hier nicht fest ein sogenanntes. XSMXXML Schema also quasi inhaltlich und logisch genau das gleiche, was ich jetzt erzählt hab, bloß alles für XML. Ja und man hat dann mit Jason angefangen und dann wurde es ziemlich schnell ziemlich berühmt glaub ich geredet ne und dann hat man ne ich glaube Schema gab es nicht von Anfang an soweit ich weiß. Ich weiß jetzt auch nicht, wann es Jason gab, aber das Thema Jason Schema.

Also wir brauchen jetzt auch ein Schema für Jason, ähnlich wie wer ein Schema für XML schon oder beziehungsweise wie es ein Schema für XML schon gab. Irgendwann 2009 2010 kamen diese Ideen auf. Ich glaub, die Entstehung ist da auch nicht so wichtig und wer genau und wo, da gibt es jetzt keine einzelnen Personen oder sowas mehr.

So ne Community zumindest nicht dass ich wüsste was ich mir nur gefragt habe ist, was war denn vorher und du hast jetzt gerade schon sehr stark die Beziehung zur zu Rest AP eigentlich auch hergestellt Rest AP ist 99% vielleicht sogar mehr ja wir nutzen dann noch JSON zum Datenaustausch und vorher schien es ja nicht so klar zu sein. Und dementsprechend konnten apis dann auch nicht so genau beschrieben werden und

dokumentiert werden. Vielleicht, und da hab ich nur den den Begriff hier und da mal gelesen von einem API Chaos hast du da Erinnerungen dran oder Erfahrungen gemacht gemacht wie das so war, das ist ja Welt entspannend. Tatsächlich hab ich keine Life gefunden mehr aus dieser Zeit, weil ich eigentlich schon nachdem es Jason gab und so weiter so richtig hart in die Webwelt eingestiegen bin. War vorher quasi mehr in der. Ja, in der Skadawelt. Und die hatte ihr eigenes ohne Internet live.

Aber ich kann schon mal sagen, ich hab ein großes Skadasystem gebaut und deswegen mach ich auch diese Folge. Ich bin ja totaler Fan von Skemas. Ja und damals haben wir tatsächlich auf XML basiert, weil XML war Halt The Shit ja in der Zeit und es wurde alles mit XSDS also XSD ist das file XML skema Definition oder ist das glaub ich und wir haben quasi diese ganzen Eingaben diese

ganzen. Konfiguration Du hattest ganz am Anfang gesagt, Gerrit Konfigurationspfeils und so weiter ja, das ist halt auch so n Ding. Immer wenn du irgendwas konfigurieren willst, ja ob das jetzt ne Webform ist im Internet, es aber steht egal. Wir hatten so n Skalasystem, da musstest du halt irgendwelche

Motoren einstellen. Ja und irgendwelche Excelerations und so weiter du hast ja immer ganz 1000 Sachen zu konfigurieren, ja das ist das gleiche Problem ja ne Konfiguration von einem Motor ist am Ende nichts anderes als unser Personaleintrag den wir jetzt hatten ja technisch ja, da stehen halt zig Keys und zig Values drin oder vielleicht genestet und so weiter ja. Und manchmal brauchst du ne Ära.

Ja, weil du irgendwie ne, weil du irgendwie ne anfahrkurve irgendwie beschreiben willst, wie Beschleunigung sich ändern über die Zeit oder Irgendsowas ja sind alles komplizierte Dinger. Ja und und wenn du jetzt jemanden das eingeben lassen möchtest, nämlich demjenigen der das Skatasystem bedient, da komm ich her, ja dann dann willst du den eigentlich auch zwingen, dass der keinen Quatsch da eingibt, ja weil sonst validierst validierst du dich im

Einzelnen zu Tode in deiner Business Anwendung. Also das haben wir gemacht, die haben diese ganzen Konfigurationen aufgeschrieben. Als XSDS ja, also als als Schemasprache für XMLS. Ja, und dann haben die Leute das eingegeben auf irgendeine Art und Weise, meistens in der Desktop Anwendung mit irgendwelchen Eingabe Masken und so weiter und HERAUSPURZELTEN XML Files, die ging erst mal schön durch so n Avalidator, den gab es da auch. Ja und dann hast du nämlich von vornherein homogenes Bild.

Ja jetzt kommt eine eine wichtige Sache, die sag ich jetzt schon mal so eine Key Erkenntnis in der Folge. Und das hat jetzt was mit Softwarearchitektur zu tun. Ne wir wir brauchen Validierung, viel Validierung ja wenn wenn ne Software gut funktionieren soll, dann musst du input Validierung machen und überhaupt datenvalidierung ja und du machst es am besten so früh wie es irgendwie geht, weil wir wollen ja Dry sein, das haben wir auch mal gehabt Downt repeat

yourself. Und du willst eigentlich, und das ist immer mal das gleiche Pattern, du musst, du willst, eigentlich möglichst früh wissen, das, was jetzt kommt ist geprüft, des Saubers validiert, ich kann mich darauf verlassen und jetzt kann ich viel einfacherem Code schreiben, weil ich die Annahme machen kann im Code, dass dieses Objekt, was jetzt in meine Funktion reinkommt, auch wirklich so aussieht, wie ich es denke, da fehlt nicht einfach der Key Age

und Age ist nicht auch irgendwie nicht irgendwie ausnahmsweise mal n String und mal n integer, nee. Es war validiert und ich weiß, was es sein wird. Ja, und dann kann ich sehr kurzen, sehr knackigen und eleganten Code schreiben und eine Möglichkeit, um Früh zu validieren, um den wirklich tiefen Businesscode freizuhalten

von Unsinn, der validiert ist. Alles, was an dynamischen Daten reinkommt, sei es jetzt über den Human Nutzer oder über irgendwelche Klienten, die es zu spielen sauber durchzuvalidieren ja, und das tue ich, indem ich es mit dem Scemer Aufschreibe, was los ist, ja. Das jetzt. Ob das jetzt XML war oder Jason ist da mal dahingestellt. Heute ist halt Jason der Datentyp der überall genutzt wird, deswegen muss es auch Jason Scemer sein.

Als Validierungssprache sag ich mal um auszudrücken was da los ist oder und es ist hochaktuell Hochwichtig. Das heißt, dann mach ich validierungen und ich nehm jetzt mal an. Genauso wichtig ist an der Stelle dann auch NN Error Handling, ja wenn nicht validiert werden konnte oder wenn falsch validiert wurde.

Oder beziehungsweise wenn festgestellt wurde, während der Validierung, dass falsche Daten injiziert werden, dass dann auch entsprechend Fehlermeldungen hochkommen und dem Nutzer des Programms oder dem Entwickler hier Bescheid geben, ja. Genau, und das passiert vor allen Dingen automatisch.

Ne, also diese Tools sind halt sehr gut, wenn die da halt n Fehler feststellen, dann dann dann packen die das natürlich mit dem Errorcode raus, für die für die Klienten und so weiter aber die packen dann auch richtig schöne, in Englisch formatierte Nachrichten raus. Die dir genau sagen, was jetzt fehlt oder was du zu viel hast oder warum halt jetzt quasi dein Jason irgendwie nicht gültig ist. Ja, das ist nämlich sehr frustrierend.

Es haben nicht alle APS, ja gerade ältere, Du machst irgendeinen Request. Du benutzt irgendwie ne AP und du kriegst da irgendein irgendein irgendein 40 irgendwas zurück, ja 401 oder was ich jetzt weiß ich gerade nicht auswendig, also Bad Message request gibt quasi nen ne HTML response Code dafür, dass du irgendwie das shittig Shittig formatiert hast, so dass deine Eingabe irgendwie kann halt irgendwie so nicht aufgenommen werden so.

Ja, aber dann fängst du an zu raten, ja, was hab ich denn falsch gemacht? So ja und wenn derjenige der die der dir die Schnittstelle zur Verfügung stellt schon das alles mit dem Schema hinterlegt hat und einfach nur n normalen Validator nimmt, dann und dann einfach die Antwort des Validators und so, insofern errorhand Link quasi dir mitschickt, weißt du ganz genau was du falsch gemacht hast.

Ja, man kann es beim nächsten Versuch besser machen das essentiell ne. Gibt es noch weitere Gründe? Außer diese frühzeitige Validierung und Erkennung von falsch formatierten Daten, die für Jason Skema sprechen? Ja, ich hab n Paar aufgeschrieben, also wir gehen sie noch mal durch, also die Kleinseitige Inputvalidierung ist mal das allererste was ich wichtig finde.

Was heißt denn das Kleinseitige Inputvalidierung, das heißt in dem Moment wo ich wo der wo ich im Client, also im Browser bin, wenn ich n Mensch bin geb ich ja Informationen ein, ne über den einen oder anderen Weg normalerweise über so webforms ja und da gibt es Checkboxen und Radioboxen und Inputfelder und Texterias und ich weiß nicht was ja.

Und was passiert noch auf dem Client, also in deinem Browser, in dem Java Script deines Browsers wird quasi diese Eingabe, die werden wird quasi schon zusammen formuliert in den JSON und bevor und das ist das schicke weil json scemer ja auch nur ein Objekt ist, kann ich das quasi schon mit der Form selber Mitschicken zum Client, das heißt ohne dass ich je mit dem

Server sprechen muss, kann ich. Weil ich das Jason Skema hab und den Validator auch. Ja den der der steckt im Code drinne den den deine Seite aufmacht. Ja das heißt ganz lokal bei dir als Client validier ich schon mal deinen Shit weg den du mir da eingeben willst.

Ja und das hat noch nie n Roundtrip zum Server gesehen, das passiert clientseitig ja warum weil ich das Schema hab ja das Jason bekomme aus den Eingaben und n Validator laufen lasse und den Validator zeig ich dir direkt wieder live an die Fehlermeldung. Blende ich dir quasi in die in

die Boxen rein. Sag hier, das hast du falsch gemacht und so weiter weil auch im Skemer nicht nur stehen kann was für n Datentyp, sondern du kannst auch sehr genau sagen, zum Beispiel Telefonnummer und dann kannst du ne regular Expression hinterlegen und sagen das und das will ich sehen und das und das will ich nicht sehen, die und die Länge von den Strings OK und nicht und so weiter das drückst du alles aus und im Skemer machst komplette input Validierung auf der Client

Seite und schickst dann schon sehr krass gebürsteten Kram. Nur noch zurück zum Server ja. Wir haben ja bei uns in der Software die Möglichkeit, auch Formulare.

Zu bauen, ohne zu Coden und auch dort in dem Formular definier ich halt den Datentyp pro Feld, also ist es Berlin, ist es eben n integer also oder da nur ne Zahl oder ist es n Text array oder was auch immer und wenn ich Zahl auswähle Number Number Box ist bei uns der Begriff, dann kann ich gar nicht als Buchstaben reintippen ist das noch mal n Schritt vorher sogar schon oder hilft da auch Jason Skemer?

Ja, das gilt, da gibt es, jetzt kommt es auf die Feinheiten an, wie man das implementiert so. Da gehen jetzt die Welten dann da über, da gibt es ja die Web. Die Web wird jetzt sag ich mal, die lassen dich das noch nicht mal tippen.

Ja, das ist noch davor, ja, das ist noch davor, das stimmt schon, ja, das ist dann noch schicker, ja, dass du, dass du schon, also aber das ist das gleiche, das gleiche Konzept, was ich eigentlich erzählt hab, nur jetzt über das Klima hinaus und es ist schön, ja, weil die UX wird halt. Umso besser, je früher validiert wird. Auch für den, für den für denjenigen, der da was eingibt. Ja, weil n Roundtrip zu machen, der möglicherweise n Fehler rausgibt, ist ja immer schon mal nervig.

Ja im besten Falle wirst du so hart eingezwungen, dass du gar keine Fehler machen kannst bei der Eingabe und das ist das was du sagst, ne. Also wenn du wenn ich dir vor hab irgendwie n string in Numberfeld einzugeben und ich es einfach nicht kann, dann muss ich nicht nachher mir noch n blöden Error angucken, dass ich darin die Scheiße eingetippt hab ja, also das ist schon so, ja man versucht es halt gerade bei

der human. Also bei der mit der menschlichen Eingabe soweit schon vorher abzufangen, dass halt möglichst früh möglichst saubere Daten entstehen. Ja genau an an der Stelle sind es quasi Web Widgets die das noch mitmachen. Ja und und nicht jetzt ins Klima jetzt aber jetzt, aber das ist ja der perfekte Einsprungspunkt warum warum jetzt wie das Klima doch da auch cool ist.

Jetzt muss ich jetzt muss ich was sagen was ich richtig richtig cool finde es gibt ne jetzt mache ich Werbung von der Library. Ich weiß nicht, ob es die in der einen oder anderen Art für andere Programmiersprache macht, gibt es aber auch nicht so wichtig, weil gibt es für javascript und da wird sie gebraucht.

AJSF heißt das Ding, also RJSF findet man NPN steht für REACT, json Schema Form und ist ne Bibliothek für das nicht ganz unbekannte React Frontend Framework und das funktioniert so, das ist richtig cool, da geb ich quasi dieser Bibliothek nen

Schema hin nen json schema. Voll nach Spezifikationen und dann kann ich noch ein zweites g mal mitgeben, wo ich so UI Tweaks machen kann wo ich sagen kann hier hier will ich das noch mal anders, aber das muss ich gar nicht, es reicht erst mal ein lasing Scemer zu geben und das Ding rendert mir automatisch die komplette Form Krams hin, ne es rendert mir die Eingabemaske hin gegeben weil da steht ja alles drin.

Das Wichtige ist einmal zu erkennen und das war das Problem glaube ich in der Vergangenheit auch noch mal in die Historie zu gucken. Ständig haben die Leute an den unterschiedlichsten Stellen immer wieder irgendwelche Sachen beschrieben, die irgendwas sein zu sein hat und so weiter wie irgendwelche Konfiguration zu gehen haben und so weiter ist immer wieder das gleiche Problem. Ja und immer wieder brauche ich eigentlich nichts anderes als n Schema. Ich schreib es einmal ordentlich

auf n Schema auch nur einmal. Ja und dann generiere ich alles daraus ja und diese Diary ist so cool, da kann ich auch verschiedene ob ich jetzt Material UI hab oder ob ich das mit mit Tailwind benutze oder ist es shit egal wie ich das dann quasi anmale ja was kann das alles? Aber der sage ich, hier ist mein Skemer und die macht das, was du sagst, Gerrit. Die Rendert nämlich jetzt die

richtigen Eingabeinputs hin. Ja, bei der Numberbox halt ne numberbox ja und wenn es halt irgendwie wenn da steht, das ist n langer Text, dann das ja oder wenn oder wenn das irgendwelche komplexen Dinger sind so mit mit Arrays von Objekten und so weiter da bekomme ich die Elemente hin, dass ich so modulare Blöcke ausfüllen kann und so weiter ultra cool da. Und ich will das eigentlich gar nicht jedes Mal neu

programmieren müssen. Ja, und das ist genau der und und wenn ich jetzt mal ne große Anwendung machen will, wo es nicht drauf ankommt, dass ich irgendwie eine Eingabemaske irgendwie mit CSS animiere, die sich dann dreimal rückwärts dreht und viermal da vorne und so weiter, dann kann ich das

nicht nehmen. Ja wenn es mir aber drauf ankommt, dass ich irgendwie sehr eleganten, sehr sauberen Code hab, der früh validiert, der trotzdem schick aussieht, dann nehm ich halt solche generischen Tools, weil dann innen drin meine Codebase total aufgeräumt ist und die ganze Softwarearchitektur richtig überschaubar ist.

Ja, also das ist der zweite. Jetzt, ich hab einmal von den ich hab jetzt mal von der input Validierung gesprochen, jetzt hab ich von dem Tool gesprochen was gleichzeitig noch webforms mit Rendert, das ist quasi noch mal n Punkt wo es Jason Skemer spannend wird und jetzt hab ich noch 1 was jetzt wieder ganz modern ist gab es gab es lange nicht KI so was wir da heißen jetzt mit KI und Jason Skemer jetzt macht er aber echt Bewegung stimmt nicht kann man nachgucken und kann ja zu open A

einmal auf die Webseite gehen es gibt bei der KI ja das sogenannte Function Calling hat jetzt vielleicht auch noch keiner gehört der es gerade zuhört aber ja man kann ja prompten und so weiter. Aber es gibt auch die Möglichkeit, dass KI Funktionen aufrufen kann, die da sind. Ich kann, ich kann da KI im prompt sagen, hier sind bestimmte Funktionen ne die kannst du noch als Antwort mit Aufrufen und das Ergebnis mit Einschleifen in die Antwort.

Ja so wird das typischerweise gemacht, wenn KI irgendwas rechnen soll oder irgend so was irgendwelche Ingenieursformel ausrechnen, das kann die nämlich nicht sehr gut ja aber da da gibt man quasi den ganzen Haufen Funktionen hin wo das alles drin steht und dann ruft die KI, die musst du noch raffen, welche Funktion muss ich jetzt aufrufen ne? So und welche Funktion, die muss noch raffen, welche Funktion sich aufrufen, was kann die, welche Parameter bekommt ihr,

was kommt da raus. Ja, hier wird das gerade wieder beschrieben bei KI ganz Modern Jason Skema so weil ich ich muss halt, ich muss halt der KI sagen so das ist das Schema nachdem das aufgeschrieben wird hier muss so n bisschen aufpassen weil wir und das bringt mich auch gleich noch mal zu einem anderen Thema also Jason Skema ist im innersten Sinne eine eine so ne Art Daten. Datenbeschreibung und nicht eine Vertragsbeschreibung also jetzt muss man an der Stelle noch mal

aufpassen, nämlich jetzt die KI funktionsbeschreibung mach ich auch als json skemer und hier ist es n Schluck mehr weil normalerweise haben wir n json skemer nur um nen Datenformat festzuzurren n bestimmtes Datenformat und nicht n datenvertrag also ich meine mit Vertrag sowas wie wie kann ich Funktionen aufrufen und so weiter ja. Das ist jetzt bei diesem KI Thema wichtig und das ist eigentlich noch viel essentieller.

Später, wenn wir angucken für apis, ja, das will ich jetzt auch noch mal ganz genau sagen, wenn wir Rest APIS haben, haben wir 2 Sachen, wir haben, wir haben auf der obersten Ebene so ne Art datenvertrag, also wir müssen ja erstmal definieren was sind meine Endpunkte, ja und ist es n lesender Endpunkt oder n schreibender Endpunkt ja und dann hab ich dann noch Metadaten dazu kann ich dann weiter kann ich da hab ich n Pagination und

filtering und wie sehen meine KI parameters aus und so weiter und sofort ja. Das ist erstmal nicht das, wo man sagen würde, das ist Jason Skemer, sondern es wird eher nen Level tiefer angewendet wenn man sagt, OK das ist der Endpunkt und so weiter und sofort und hier kommt jetzt die Request die ich stellen kann und die request wird ja tatsächlich n Jason Rübergeschickt ja und dafür wird n Jason Skemer gemacht eigentlich und für die Response genauso, aber nicht für die also

ich man könnte auf die Idee kommen und man ist es auch. Dazu sag ich gleich was. Man könnte auf die Idee kommen, die gesamte API irgendwie als so ne Art json scemer zu

beschreiben. Ja stellt sich raus, dass das, dass man dann ja auch relativ eingeengt wird, wie man diesen Datenvertrag, also diese ganzen Endpunktbeschreibungen und so weiter, die muss ich dann ja auch als json scemer vorhalten, ja kann man machen, aber da gibt es quasi nen Tool, das muss man einmal wissen, das heißt, es hieß früher als Swagger und so kennen es die meisten noch, das heißt aber heute Open API.

Und Open API ist auch eine Art Standard, eine Art Vertrag, eine Art Dokumentation, in der ich große Rest API Interfaces dokumentiere. Und es ist nicht ganz kompatibel, also es nutzt ganz viele von den Ideen von Jason Kemar und es und es beschreibt aber beides, es beschreibt die Endpunkte und den Vertrag, was kann ich alles machen.

Ja, und und die ganzen Dokumentationen und auch sowas wie authorization und so. Und es beschreibt aber auch quasi die die Requests und die Responses und es beißt sich leider nen bisschen. Ich weiß nicht ganz, aktuell hab ich es jetzt nicht mehr gemacht, es nähert sich wieder an, es war wieder n bisschen zwischendurch weg und das war natürlich Paint für Entwickler weil die json skema Keywörter die ich nutzen kann und die Open API keywörter die da benutzt werden müssen

nicht ganz kompatibel waren. Ne es war also. Sub und Subset gleichzeitig, also sub und superset glaub ich. Sagt man also ne Erweiterung und ne Einengung und so weiter und es war nicht ganz ganz klar wie die beiden miteinander arbeiten, jetzt versucht man das aber wieder aneinander zu bringen, ne es passiert immer dann wenn wenn sich ein Standard nicht ganz

glatt durchsetzt. Das haben wir leider auch, also in der echten Welt, das gibt es ja auch nicht, ist ja auch nicht alles mit dem ISO Komitee versehen und so weiter und sofort ja die Ideen sind aber sind aber sehr gleich sag ich mal. Also die die die inhaltlichen ja. OK, jetzt bist du aber bisschen weg vom KI Thema auf den Datenvertrag und dann auf auf Open API. Geschwungen hast du richtig

erkannt, aber ich bin ich. Jetzt könnte man mich noch fragen, ich weiß woher herkommen, wir sind ins ins KI Thema gegangen weil wir noch Anwendungen angucken wollten wo Jason Scemer wichtig ist und da hab ich gesagt hier pass auf function Calling und so wir müssen also quasi der der KI

auch sauber n bisschen strukturiert mitteilen, was gibt es hier für Funktionen, welchen Parametern können die aufgerufen werden, was kommt da zurück von dieser Liste hab ich jetzt auch nicht mehr so viel ich sag noch 1. Erleben ja nicht nur in Rest API Schnittstellen vor allen Dingen

wir nicht. Gerrit gibt ja auch noch die ganze Welt des IOT und des IOT und der Broker Message Broker und so weiter und Messages sind ja auch nichts anderes als heute, als im Prinzip ja Blöcke von von von Daten ne die Daten werden heute oft auch in IOT, also da gibt es natürlich noch ganz viele andere Protokolle und mal ganz oft kannst du auch einfach Jason nehmen. Packst das zusammen und schickst das ja unter einem bestimmten Topic.

Ja, also da gibt es nicht sowas wie ne Restschnittstelle. Ich schicke halt irgendwelche Sensordaten, ja und auf einmal und auf einmal muss ich, möchte ich aber vielleicht trotzdem auch beschreiben, wie sieht denn so n Temperatursensor aus, wenn der Daten schickt? Also wie sehen wirklich die

inneren Daten aus? Heißt das Value oder heißt das Temperator oder oder hab ich da noch n Timestamp drin oder nicht und so weiter und schon kannst du wieder n Jason Scream annehmen und das da dran dengeln ne und dann bist du bist du wieder n Stück weiter gekommen. Ne, machst du das dann auch? Dort, wo der Datenpunkt entsteht und abgeschickt wird oder irgendwo zentral. Das ist jetzt ne gute Frage, das würde ich jetzt erstmal nicht beantworten.

Das ist immer ne Anwendung zu lassen, da muss man gucken wer ist das für die System und so weiter wer macht das ja, wer hat sich da wie ihm zu beugen mal. Gerade weil wir es jetzt ja letzte Woche vor 2 Wochen mit MQTT hatten, was immer hieß, die die die Clients sind grundsätzlich ziemlich dumm in Anführungsstrichen. Dumm. Und der Broker, also der ist, der die Serverrolle in einem Fall von Imptity übernimmt, hat eigentlich die ganze Logik drin, oder? Der Großteil der Logik.

Ja, aber man muss trotzdem, also die können ja dumm sein, und das sind sie auch irgendwie quasi technisch so und von dem, was sie so schicken und vom Protokoll, aber also auch da wird es Leitstrukturen geben, weil wenn sich Systeme und Daten miteinander austauschen müssen und Sinn sinnmäßig irgendwie sinnstiftend irgendwie weiterreichen sollen. Muss es so ne Art von von Definition geben auf die ein

oder andere Art? Ja und ich will das mal so sagen, es gibt ja also, dass die Idee irgendwie Daten zu beschreiben wie es sein muss, gibt es ja millionenfach, ja, also das wurde tausendmal gemacht, es ist als Softwareentwickler brichst du schon die Tastatur, weil es andauernd wieder n zig System auf irgendeine andere Art und Weise immer wieder das Gleiche passiert, ja und immer es ist n bisschen unterschiedlich und manchmal denkst du so ja boah.

Und wenn du dann Jason Skemer kennst, was die haben das relativ gut gemacht, finde ich ja relativ umfassend. Ja, und dann siehst du sowas wie OPCUA ja, musst du halt auch n Informationsmodell fest. Hackern, was ist denn das wenn du wenn du NOPCA sa warst? Da wird ja auch beschrieben in welcher Art und Weise muss ich da irgendwelche Sachen, das ist genauso frei definierbar wie Jason selbst.

Ja, und da gibt es dann auch wieder die eigene Art und Weise, wie man das festlegt, ja dann gibt es RPC Protokolle von Google GHPC. Dann gibt es die hatten wir

gerade 90er Jahre IDL. Ja, was ist denn IDL, diese Interface Divinition Language ja Interface Divinition language sagt schon ja, also ne Schema für Funktionsaufrufe ja und immer wieder muss ich weil die weil das funktioniert Computer die die müssen halt wissen relativ strukturiert wissen was sie da aufzurufen haben, also andauernd andauernd beschreibe ich irgendwie alles mögliche an die Entitäten ja und und deswegen mache ich Jason Skemer heute in der Folge, weil weil

wir weggehen von diesen erstens diesen ganzen verschiedenen Protokollen, die irgendwie Legacy sind und so.

Hinzu relativ standardisierten Übertragungsmethoden, PMQTT und Rest APIS und vor allen Dingen hinzu sehr standardisierten Datenaustauschformat. Das ist nämlich json, wenn wir das erkannt haben, dann können wir nämlich auch auf einmal die Beschreibungsart von dem, was ich da erwartet oder was ich da durch die Gegend schicke, relativ hart standardisieren und das Halt in das json scemer und deswegen find ich jeder der irgendwie anfängt zu programmieren, der soll auf

jeden Fall und es gibt auch coole Website von json scemer selbst ich glaub es heißt json-scemer.org. Da steht alles drin, da kann man schon mal richtig cool starten. Und dann gibt es halt den Tool so ja für was ich so hab, da sollte man sich auf jeden Fall mal angucken.

Ja, weil wenn man das man ne Software schon von vornherein so aufbaut, dass ich mir skimas hinlege und die Datenstrukturen ausdenke, das ist sowieso auch das hat mir auch meine Folge, ist sowieso n guter Advice ja mich erstmal über die Datenstrukturen klarzumachen ist immer sehr gut in der Architektur und das dann gleich festhalten in einem Schema haben wir ja schon gleich mal n Lichtjahr weiter an meiner Softwarearchitektur. Da damit hilfst du das Thema

natürlich auf n ganz anderes Level. Das ist ja was Grundsätzliches, ja Schema Schemata zu benutzen auf Deutsch. Ich glaube in altdeutsch Schemata. Wahrscheinlich darfst du jetzt Schemas sagen, aber die Kommata glaub ich ne. Und du hast Grad ganz kurz OPCUA erwähnt. Ich glaub wir haben ja auch Zuhörer und Zuhörerinnen aus dem Bereich Produktion und so, den dürfte OPCUAN Begriff sein, ganz kurz, es ist n sich immer mehr verbreitender Standard.

Um um Maschinendaten auch zu erfassen oder in der Automatisierungstechnik und Produktion und Daten auszutauschen zwischen Maschinensteuerung und anderen Systemen. Da kannst du also sowas wie n Jason Scemer einfach nicht. Nutzen, weil Jason spielt da keine Rolle oder? Mir spielt da keine Rolle, kommt

nicht vor, ist nichts. Hätte man sich aber überlegen können, dass man das ja, dass man so Sachen vielleicht auch da benutzt hätte, man ja hätte, aber ich glaube es gab es da noch nicht, als sie angefangen haben. Also ja, war jedenfalls noch nicht so durch. Durchdringend, irgendwie Standard.

Ja, das sind halt auch diese Überlegungen, die man halt führen muss, ne wenn man, wenn man jetzt so ganz abstrakt spricht, so mit so Experten, dann machen wir boah, wenn wir, wenn wir jetzt irgendwie die Industrie standardisieren, so basieren wir das auf OPCUA oder auf irgendwas anderem, dann kann ich auch immer sagen, das ist ja alles schön und gut so mit OPCUA, aber das ist halt Technologie, das die kann halt nach den.com, das ist halt nach dem.com Modell der 90er

entwickelt so, das ist jetzt und genau aus solchen Gründen zum Beispiel, weil da einfach kein Jason benutzt wird und kein Jason Scima und so weiter und weil diese ganzen modernen Tools die 90% der Arbeit erledigen, die die halt alles in ihren eigenen Stack verwalten müssen, ne das kommt da alles mit, also musst du alles noch mal als dependencies reinkleben es ist halt ist eigentlich alt ja also was modern ist. Im Moment weißt du wenn ich den in 10 Jahren hör.

Diese Folge würd ich auch sagen, Gott sind Sie da Eisen erzählt Jason Jasons geh mal, aber im Moment ist halt das modern ne

und im Moment gibt es da viel Tooling und dann kannst du viel Validierung machen was extrem wichtig ist. Also wie ich bin ja jetzt, ich rede ja immer nicht so aus Security Aspekten, aber das ist natürlich Key. Für auch sichere Systeme. Ja, dass du weißt, was du reinbekommst. Ja, und du kannst validieren, schon beim Client. Du kannst natürlich noch mal selber validieren auf der Schnittstelle an der HP und du kannst ganz unten an deinen Codes noch mal validieren.

Ja genau, und dann kannst du sogar mit solchen Schema Sachen kannst du noch wildere Sachen machen, wenn du deine Funktion ordentlich dokumentierst und da ist nämlich wieder jetzt ich mach jetzt noch mal eine Sache aus privatem Anliegen, aber wenn dann jetzt Quellcode aufschreibt, dann hast du irgendwann diese Funktion, die wirklich mal von außen aufgerufen werden sollen, ja. Eventuell noch mal über ne Schnittstelle von deinem Server oder irgend so wie, aber die

willst du halt aufschreiben, so dass sie halt von außen lesbar sind und dann schreibst du normalerweise nen Kommentar dran, toxician zum Beispiel. Also du schreibst quasi auf was ist das ne Funktion, was macht die ja was weiß ich, bekommt bekommt irgendwie beliebig viele Bilder und und kombiniert ein

sie zu einem PDF. Ja also schreibst du das auf was soll die machen die Funktion ja was erwartet die an Eingaben schreibst du auch auf relativ genau, auch welche Datentypen und so ja. Und schreibst auch auf was kommt da raus? Ja, aus der Funktion und Du schreibst auch auf was können für Fehler eventuell passieren und so schreibst du ja schon alles hin.

Ja und auch wieder aber nicht standardisiert ja halt, das heißt jetzt halt JS stock und ist so ne Art Schemasprache für Funktionsdokumentation am Ende. Wenn du jetzt aber mal 10 Schritte zurückgehst, das ist genau das gleiche ja du beschreibst halt dein Interface und man könnte das halt auch in json skemer kippen ja und das tun wir auch demnächst auf der Roadmap. Wo man dann sagt, OK funktionsdokumentation, egal welche, welche Art J Talk oder

inline oder was weiß ich, nehm halt einfach die Dokumentation die ich finden kann im Code, forme daraus n json scemer, leite das hoch an den Server und was kann ich jetzt auf einmal machen. Jetzt kann ich den Nutzer für die Funktion direkt ne webform hinrendern, weil wenn man das Weiterdenkt was ich gerade gesagt habe, dass ich json scemer nehmen kann um mit einer Bibliothek dynamisch ne richtig coole Form hinzurendern. Da bin ich fertig.

Dann kann ich jede Funktion der Welt, egal wie sie ist, ja muss nur gut dokumentiert sein von demjenigen, der sie geschrieben hat, den ich überhaupt nicht mehr kenne, kann ich ne super tolle Eingabemaske hingenerieren ja und jeder kann das bedienen.

Ja ich find sowas find ich elegant ja so über sowas muss man nachdenken und sowas kriegt man halt hin, wenn man nicht nicht auf zu viele Player setzt und wenn man die Standard Sims die es gibt ja und und das dann sauber durchzieht im Code ja und früh genug quasi und früh genug heißt hier an der Quelle selbst ja, also direkt an der Funktion die ich mal aufrufen will. Da ist eigentlich die Single Source of Truth. Ja, und die leite ich durch das ganze System weiter und kopiere

das nicht. Ja, dabei geht es immer kaputt, das ist natürlich, aber das ist jetzt nicht stand der normalen Technik, das ist jetzt stand von was wir bei Heisenberg versuchen, um Softwareentwickler auf das nächste Level zu bringen, aber gut, egal ja, aber man kann es ja trotzdem mal sagen, das sind so die Ideen, wenn man die glatt sieht, dann dann kommt man da halt irgendwie durch, ja durch dieses dickichter sag ich mal. Ja, das bedeutet jetzt in diesem

Beispiel, was du gemacht hast. Wenn man einfach Code.

Oder Funktionen ist. Der Code ist so gut oder so standardisiert dokumentiert, dann sind sie super einfach nutzbar, am Ende ja und aufrufbar ja und automatisiert durch das Tunning was da. Ja, und das Geheimnis ist ja, das ist eigentlich schon, weil jeder Entwickler kriegt das Eingeschärft, die sind immer gut dokumentiert, ja bloß, dass diese Dokumentation da rumsteht und wird halt nur dafür verwendet, dass ich in meiner IDE als Entwickler davon nen

Mehrwert hab, der ist ja auch nicht, der ist auch nicht gering, der ist auch beträchtlich, ja. Aber vielleicht können ja noch kann ja sogar entern, wenn er davon Mehrwert haben. Wie teuer wäre das denn? Ne, ja absolut, du hattest vorhin noch so n ich glaub du hast gesagt wir müssen noch mal hier ne Fußnote machen oder Disclaimer oder sowas. Irgend ne Unterart hast du die

abgedeckt? Jetzt ja ich hatte das gesagt mit dem das meint, damit meinte ich, dass dass Jason Skemer nicht alleine verantwortlich ist um moderne Rest APIS zu schreiben heutzutage, sondern es konkurriert mit diesem Produkt was sich Open API nennt, was früher Swagger hieß. Wo, glaube ich aber ganz starke Bestrebungen sind, dass es vereinheitlicht wird oder einheitlicher wird.

Und wie gesagt, da davon wird der Jason Skemer an sich immer nur den Teil der Request Response Beschreibung vermutlich bleiben und der also die Beschreibung des Services der Art der API, das wird schon Open API noch machen mit ihren eigenen Keywordings, da gibt es auch n Produkt asynchroner apis, das kommt ja auch immer mehr also für das was Message Brokers ist und so weiter Async API ist es glaube ich das Projekt ja

genau und dann gibt es noch. Die JSON API muss man aufpassen, es gibt relativ viele Wörter, relative Begriffe, die die hören sich alle ähnlich an, sind alle sehr unterschiedlich.

Ja, json APIS, jette Nutherway wie ich halt quasi Rest APIS beschreiben kann, die aber jetzt bei JSON API auch noch mit gewissen Standards Unterart folgen und so weiter und sofort ich will das aber nicht, ich will das aber nicht ausexerzieren das ist verwirrt ja aber json Schema darüber, darüber haben wir gesprochen das definiert.

Die Daten, die ich wie die Daten strukturiert sein müssen innerhalb eines Jasons ja und diese Jason API und Open API Sachen, die definieren etwas mehr, die definieren halt auch den Vertrag, den Service, die Art des Interfaces, die Endpunkte wie sie aufgebaut sind jetzt bei zum Beispiel an der Restschnittstelle, ja, da muss man n bisschen aufpassen, dass man sich alles in einen Topf schmeißt, so ja, und deswegen ist Jasons Klima von der Generizität jetzt auch weiter

und deswegen hab ich da auch KI gesagt und deswegen hab ich so Sachen gesagt wie formvalidierung und so weiter weil das. Ja, weil das ein generischeres Konzept ist, dass es quasi mit ihrer mit der Datenvalidierung weiter generischer als jetzt diese diese sehr speziellen API, was heißt sehr speziell, aber diese spezielleren API beschreibungssprachen, wie sie jetzt in Open API genommen werden, ne? Cool haben wir es dann.

Wir haben es, wir haben. Ich habe komplett weggelassen, wie das aussieht, wenn man so eine, wie man so ein Schema schreibt. Ich glaube aber, dass das relativ irrelevant ist, weil das kann jeder schnell klicken, das ist, das ist auch auf der Tonspur echt ein Mist. Wenn ich jetzt hier irgendwie Keywords durch die Gegend gebe.

Vielleicht gibt es dazu Best Practices oder aus deiner Erfahrung, wie man es wie man es macht, also nicht nicht so wie im Detail, sondern nur so allgemein. Ja also ich würde, ich würde mal raten, dass man schon n bisschen

kurzspezifikationen liest. Also man jetzt wirklich vor hat ins Schema Business einzusteigen, würde ich mal dieses Jason-schema.org lesen, so n Schluck vom Standard er ist und er ist relativ unverdaulich wenn es ins Detail geht, aber für ne Übersicht und dann gibt es dann dann kann ich dann empfehle ich wirklich AGAJSF als Bibliothek gibt es haben wir ne coole Webseite und da gibt es n playground.

Da kann man spielen, da kann man quasi Schemas aufschreiben und da kann man beliebig viele Jasons mal entwickeln und da kann man mal validieren und vor allen Dingen kriegt man schon diese Form. Star Life, Hingemalt und so weiter das ist ziemlich cool, da kriegt man n ziemlich großes aha Erlebnis was da los ist. Und an der Stelle will ich eine Sache noch erwähnen, was ziemlich ziemlich mächtig ist bei auch bei diesen Skimas und in den Skimas in der

Spezifikation mit eingebaut ist. Ich hab sogenanntes Konditionales auswerten. Das ist ja was, was ständig passiert, wenn man sich überlegt.

Ja, ich hab ne webform so und dann irgendwo hab ich n dropdown und wenn der Dropdown halt auf b ist, ja dann hab ich halt ganz andere unteroptionen ja weil ich bin irgendwie was weiß ich ich fahr ab ich bist du angestellt oder selbstständig ja so wenn ich jetzt selbständig auswähle dann krieg ich halt ne dann geht auch noch diese ganze Anfrage von dem Form noch mal ne ganz andere Richtung ja ich hab noch ziemlich viele andere Sachen die ich auswählen muss ja. Während wenn ich irgendwie

angestellt bin, ist es was ganz anderes oder sowas. Also das nennt man also quasi konditionales formatieren, Konditional in dem Sinne der weitere Verlauf der Auswertung der Validierung ist abhängig von einer Property, von einem Key, von einem Value eines Keys, den ich vorher eingestellt hab.

Ja, und das ist ja, wenn man alleine wenn man drüber spricht, ist es schon komplex, ja und das kann ja auch wieder genestet sein und so weiter und sofort, ja, das ist alles mathematisch sauber abgebildet im Standard, dann kann man tatsächlich trotzdem alle diese. Ich sag mal alle diese möglichen

Wege durch. So ne Validierung kann man in einem großen Pfeil abspeichern und das ist dann richtig richtig cool und richtig mächtig, weil ich dann nicht gefangen bin in meiner statischen Welt, sondern nicht sogar ja diese diesen ganzen dynamischen, das ist so ne Art if than else.

Ja und von der Sorte gibt es noch n paar andere Kniffe, da komm ich relativ weit mit ja ich benutze das wirklich selber in unserem Code die ganze Zeit, weil ich hab noch nie gesehen, dass mir das irgendwie im Weg stand, wir machen alle alle Webforms machen wir auf auf Klima basiert, das funktioniert eigentlich immer. Was du jetzt gerade erklärt hast, das Konditionale, das geht einfach im im Klima mit der

entsprechenden Syntax da quasi. Also da brauch ich jetzt keinen Tooling. Genau das ist vorgesehen. Du du hast tatsächlich du schreibst so du schreibst im Jason so ne Sachen wie If doppelpunkt, denn da gibt es so Keywords und so du schreibst das auf als Jason. Ja es ist tatsächlich Teil der Skimasprache ziemlich ziemlich mächtig also die haben sich, die haben sich n paar Gedanken gemacht, das entwickelt sich auch weiter, es wird auch geprüft von der Community. Halt quasi.

Erfährt den Live Check, die ist was Softwares halt so machen und die veröffentlichen auch neue Standards. Ja es gibt dann immer so vorläufige Standards und so und feste Standards und die Tools weil es n Standard ist muss man

mal n bisschen aufpassen. Was benutze ich hier gerade und so, aber die Tools sind normalerweise Standard, Compliance steht immer dran mit welchem Standard geht was und so weiter das ist jetzt auch nicht so, dass die das dann andauernd voll über den Haufen werfen und sondern da sind kleine Änderungen und und die Weiß kommt man voran ne. Dann hab ich noch eine kurze letzte Frage für dich. Hat entfernt mit dem Thema zu tun. Hast du schon mal von der neuen E Rechnung gehört, die in

Deutschland Pflicht ist? Seit 1. Januar beziehungsweise gibt es ja noch n Übergangsteil von 12 Monaten aber sagen wir mal ist. Es Pflicht. Ja, das hab ich natürlich gehört, aber ich hab mich, aber ich kenne keine Details, aber das ist, dass es geben wird, das weiß ich ja. Ja, das Detail ist quasi das, das ist, selbst wenn es NPDF ist, muss es dazu in der Lage sein. Also das ist so n spezielles PDF, was quasi auf XML basiert. Also letzten Endes sind es.

Also man hat sich entschieden, Rechnungen im XML Datenformat zu beschreiben, damit sowas wie nen Liefererschuldigungen sowas wie nen bezahldatum oder nen Preis oder nen Steuersatz oder was auch immer maschinenlesbar ist. Letzten Endes und von Maschinen und und Computerprogrammen verarbeitet werden kann. Macht Sinn ne also grundsätzlich.

Na ja, ich komm halt von unstrukturierten Daten, weil ich kann ja in so ne in so NPDF rein, also sind unstrukturierte Daten, weil ich schreib halt hin wo ich es will und wann ich es will und nenn es so wie ich Bock hab ja. Kommen dann halt hin in n strukturiertes Datenformat.

Das ist jetzt XML. Leider schade, Jason nicht getraut war ne Frage, die Mühlen malen halt langsam, aber die haben sich wahrscheinlich vor 20 Jahren irgendwie das Thema schon gestellt und dann irgendwie entschieden weiß ich nicht ich. Das wäre auch meine Vermutung gewesen. Ich dachte nur vielleicht. Also muss es ja sein, oder?

Wenn man jetzt heute das noch mal neu ersetzen würde, würde man vielleicht gucken, Mensch, vielleicht würde man vielleicht Jason nutzen an der Stelle. Ja, wenn ich da am Kommentier gesessen hätte, hätte ich dir gesagt, ja, lassen wir mal das noch mal n modernes Fallformat nehmen. So ja, aber ich weiß tut nicht weh, mein Gott, ja es. Funktioniert ja ne. Es funktioniert ja, es gibt die Tools auch noch, aber es nervt natürlich auch.

Ja, ich finde für was Neues muss man keine alte Technologie verwenden, aber das ich will jetzt auch hier keine Politik machen, vielleicht gibt es auch gute Gründe es so zu tun, die mir nicht bekannt sind. Also die meisten, also unsere. Rechnungsstellung und so weiter Abstriert das auch schon wieder weg. Also es hat sich überhaupt

nichts geändert. Also für mich jetzt ich Tipp da den Kram ein die Rechnung entsteht oder sie entsteht automatisch und umgekehrt genauso wenn wir einen Empfang ich dieses System reinlade dann fling liest es daraus automatisch die Sachen raus und und ich muss gar nichts mehr machen gut das nur am Rande dann Jason Skemer erledigt würde ich sagen. Würde ich auch sagen.

Erledigt. Wenn ihr dazu Fragen habt, dann meldet [email protected] auch für alle anderen Themen. Und weil ich sagen nicht mal gesagt hab, wenn ihr Lust habt, gibt uns doch mal wieder ne ne Bewertung, ne Positive natürlich und lasst uns Kommentare da oder so, wenn ihr mögt ansonsten danke Burkhard, danke euch fürs Zuhören. Gerne und Tschüss aus Hamburg. Einfach komplex wird präsentiert und produziert von Heiseware.

Wir freuen uns auf deinen Fragen und [email protected] vielen Dank fürs Hören dieser Folge bis Dienstag in 2 Wochen und Tschüss aus Hamburg.