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 euchbeiunsueberpodcast@heisenberg.com
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
deinfeedbackanpodcast@heiseware.com vielen Dank fürs Hören dieser
Folge bis Dienstag in 2 Wochen und Tschüss aus Hamburg.