WEBVTT

00:00.000 --> 00:03.000
Working Draft Revision 549.

00:30.000 --> 00:41.000
Workshops.de ist die Trainerinnen-Community, die IT-Schulungen mit Fokus auf Web-Entwicklung für deine Firma anbietet, mit einem Pool von über 500 Themenmodulen.

00:41.000 --> 00:45.000
Zum Beispiel zu den Themen Angular, React und View.

00:45.000 --> 00:55.000
Dabei gibt es erstklassige Basisschulungen und maßgeschneiderte In-Haus-Klasses, die dann zum Beispiel sechs Tage lang jeweils Halbtags-Remote stattfinden

00:55.000 --> 01:02.000
oder als Masterclass mit einem sehr hohen Selbstlernaranteil in Verbindung mit regelmäßigen Ask Me Anything Sessions.

01:02.000 --> 01:12.000
Die Trainerinnen sind regelmäßig in echten Projekten in der Wirtschaft unterwegs und lassen stets aktuelle Erfahrungen in ihre Materialien mit einfließen.

01:12.000 --> 01:21.000
Außerdem bilden sie sich sowohl gegenseitig fachlich als auch extern didaktisch regelmäßig weiter, um für alle Lerntypen Angebote zu schaffen.

01:21.000 --> 01:31.000
Vielleicht kennst Du Workshops.de auch schon von Projekten wie Angular.de oder den Community-Konferenzen NG.de und View.js.de Conference.

01:31.000 --> 01:36.000
Wenn Du jetzt mehr darüber erfahren möchtest, dann schau doch einfach mal bei Workshops.de vorbei.

01:36.000 --> 01:41.000
Dort kannst Du auch Teil der Trainerinnen-Community werden, der bereits 70 Menschen angehören.

01:41.000 --> 01:46.000
Wir danken Workshops.de für die Unterstützung dieser Folge vom Working Draft.

01:46.000 --> 01:55.000
Hallo und herzlich willkommen zu Working Draft Revision 549. Heute sind am Start die Vanessa.

01:55.000 --> 01:56.000
Hallo.

01:56.000 --> 02:04.000
Meine Wenigkeit, der Peter und neben diversen Katzen, die noch im Hintergrund herum wuseln, ist auch am Start der State of Javascript.

02:04.000 --> 02:11.000
Jahre des Herrn 2022, im Moment noch in der auszufüllenden Form und wir dachten uns, wir füllen das einfach mal aus

02:11.000 --> 02:17.000
und gucken mal, was wir da so an lustigen Frameworks von denen wir noch nie was gehört haben finden oder Features oder Ähnlichem.

02:17.000 --> 02:25.000
Ich würde sagen, wir steigen einfach mal ein in den Survey, wer mitspielen möchte, weiß jetzt gerade nicht, weil das hier released wird,

02:25.000 --> 02:29.000
aber State of Javascript, erstes Google Ergebnis drauf drücken und dann läuft die Kiste.

02:29.000 --> 02:35.000
Gut, dann würde ich sagen, fangen wir das mal an, ich würde sagen, wir beide spielen das parallel

02:35.000 --> 02:40.000
und beantworten einfach mal zusammen alle Fragen und gucken mal, worüber man was erzählen kann, oder?

02:40.000 --> 02:42.000
Cool.

02:42.000 --> 02:48.000
Dann, wenn ich mich nicht täusche, bin ich jetzt hier, zuerst gelandet bei Language Features von Javascript

02:48.000 --> 02:54.000
mit lauter neuen Features, wenn ich das richtig sehe, mit der Frage, ob man das denn mal benutzt hat oder nicht.

02:54.000 --> 02:58.000
Da bin ich ja mal sehr gespannt, was das eigentlich einem sagen soll, oder?

02:58.000 --> 03:01.000
Weil ich meine, wenn ich da jetzt sage, habe ich noch nie von gehört, weiß ich nicht, brauche ich nicht,

03:01.000 --> 03:06.000
kann das ja entweder heißen, das weiß keiner, es gibt ein PR-Problem oder das braucht keiner

03:06.000 --> 03:09.000
und es gibt halt mehr so ein Use Case-Problem.

03:09.000 --> 03:13.000
Genau, das Problem hatte ich die ganze Zeit bei dem Survey, wo wir hier durchgehen,

03:13.000 --> 03:18.000
dass ich mir gedacht habe, vor allem in meinem Use Case brauche ich es halt nicht.

03:18.000 --> 03:23.000
Also wir haben dann auch zum Beispiel die Antwortmöglichkeiten, habe ich von Gehören, würde ich gerne lernen,

03:23.000 --> 03:29.000
das will ich manchmal andrücken, weil würde ich jetzt so ein Projekt machen, dann würde ich das benutzen,

03:29.000 --> 03:34.000
aber ich mache nicht so ein Projekt, also eigentlich ist es mir egal. Schwierig zu antworten.

03:34.000 --> 03:38.000
Bei Proxies, das ist so der erste Kandidat hier, geht es mir ja immer so,

03:38.000 --> 03:42.000
das habe ich halt für manche so Experimente mal verwendet.

03:42.000 --> 03:46.000
Und immer wenn das Experiment dann sozusagen mehr geworden ist als wirklich nur ein Experiment,

03:46.000 --> 03:52.000
merke ich halt relativ schnell, so ein Proxies ist in fast allen Fällen,

03:52.000 --> 03:56.000
was das mehr Probleme und Verwirrung schafft, als es wirklich einem hilft.

03:56.000 --> 04:01.000
Bei den Proxies habe ich ja sofort angeklickt, habe ich benutzt,

04:01.000 --> 04:04.000
was mir aufgefallen ist, ich habe das ja gar nicht persönlich benutzt,

04:04.000 --> 04:09.000
aber ich schreibe sehr viel in View 3, was auf Proxies passiert, um die Reactivity zu steuern

04:09.000 --> 04:15.000
und das Observer-Pattern damit zu machen, indem man bei dem Proxy, wo man ja die Möglichkeit hat,

04:15.000 --> 04:21.000
sozusagen ein Objekt zu erstellen, das anstelle von dem original Objekt dann verwendet wird

04:21.000 --> 04:24.000
und man kann halt Mepper und Setter zum Beispiel neu definieren.

04:24.000 --> 04:29.000
Da haben wir uns halt die Reactivity rein, deswegen habe ich gleich gesagt, ja Proxies, war ich ja täglich.

04:29.000 --> 04:35.000
Ich glaube, das gilt nicht, weil ich selber schreibe gar keinen, sich nutzen, ist Framework dafür.

04:35.000 --> 04:41.000
Ja, interessant, und während du das gerade erzählt hast, merke ich tatsächlich mitten in dem Programm,

04:41.000 --> 04:44.000
an dem ich gerade die meiste Zeit rumschraube, mitten drinsitze ein riesiger Proxy

04:44.000 --> 04:47.000
und ich habe es tatsächlich komplett vergessen.

04:47.000 --> 04:54.000
Na ja, da habe ich eine Datenstruktur drin, das ist im Prinzip einfach so eine mehrfach gelingte Liste

04:54.000 --> 04:59.000
und ich verwende das vor allen Dingen aus so Convenience-Grunden,

04:59.000 --> 05:04.000
weil ich dann so diese Liste bzw. einzelne Member von dieser Liste halt an Funktionen übergeben kann

05:04.000 --> 05:08.000
und die kriegen dann halt eben einfach so eine Liste der ganzen Daten von ganz Anfang bis ganz Ende.

05:08.000 --> 05:11.000
Aber manchmal will ich aus bestimmten Gründen, denen die Illusion geben,

05:11.000 --> 05:16.000
dass die Liste früher aufhört oder später anfängt, als eigentlich der Fall ist

05:16.000 --> 05:20.000
und statt halt eben die Liste zu modifizieren, gebe ich der Funktion immer ein Proxy,

05:20.000 --> 05:24.000
wo halt eben dann so drin gegeben ist, aha, wenn du irgendwie jetzt hier da in das nächste Number reingehst,

05:24.000 --> 05:28.000
aber ist ab dem siebten halt eben Schluss und du fähigst einen undefined,

05:28.000 --> 05:31.000
damit ich halt die Datenstruktur sozusagen unangetastet lassen kann,

05:31.000 --> 05:36.000
aber halt den Proxy als View auf die Datenstruktur gleichsam habe.

05:36.000 --> 05:41.000
Was glaube ich auch insofern ganz gut ist, dass ich vergessen habe, dass ich das brauche,

05:41.000 --> 05:46.000
weil das hätte man auch anders machen können, aber so ist glaube ich irgendwie effizienter möglicherweise

05:46.000 --> 05:50.000
und es fällt halt nicht auf, was halt ganz nett ist, was ja eigentlich der Sinn von so einem Proxy ist.

05:50.000 --> 05:56.000
Ja, also ich weiß, ich würde gerne mal da in die Runde zu allen Hörern und Hörern fragen,

05:56.000 --> 06:03.000
ob wenn jemand da draußen Proxys benutzt, ob man das so hier und da mal für einen speziellen Case braucht

06:03.000 --> 06:07.000
oder ob es da draußen wirklich Leute gibt, die das ständig einsetzen.

06:07.000 --> 06:11.000
Ich habe ja auch mal gesehen, irgendwelche Menschen verwenden das so im Kontext von Web Components,

06:11.000 --> 06:16.000
dass man irgendwie so eine Art Datenstore damit macht.

06:16.000 --> 06:19.000
Halt ich halt auch mal für so eine gute Idee bis ich halt irgendwie mir denke,

06:19.000 --> 06:22.000
aber pass mal auf, du bist ja jeden in der Baumstruktur drin

06:22.000 --> 06:25.000
und der Datenstore könnte ja einfach auch ein Element sein.

06:25.000 --> 06:28.000
Und dann müsstest du halt nicht zwischen irgendwie Dom-Objekten und anderen Objekten unterscheiden

06:28.000 --> 06:32.000
und du müsstest irgendwie global wissen, was da irgendwie so ein Proxy-Objekt ist

06:32.000 --> 06:35.000
und ein Proxy-Objekt implementiert auf irgendeinem Parent-Element,

06:35.000 --> 06:38.000
was dann irgendwie der Datenprovider ist oder so.

06:38.000 --> 06:42.000
Und dann muss es halt nicht mal ein Proxy sein, weil dann nimmst du einfach normale Getter und Setter auf Verklassen

06:42.000 --> 06:43.000
oder irgendwie so was.

06:43.000 --> 06:46.000
Auf einer Klasse? Also keine Klasse.

06:46.000 --> 06:49.000
Wenn du Web Components schreibst, dann wahrscheinlich schon.

06:49.000 --> 06:51.000
Ja, okay.

06:51.000 --> 06:55.000
Okay, aber ich würde mal sagen für uns beide, wenn wir jetzt sozusagen unsere Proxy-Erfahrung zusammennehmen,

06:55.000 --> 07:01.000
also irgendwie so, bei dir ein halbes Benutzt durch View und bei mir ein ganzes Benutzt durch mein eigenes Ding,

07:01.000 --> 07:07.000
würde ich sagen, machen wir da mal einen für, haben wir benutzt, wir sind die Coolen, die das verwendet haben.

07:07.000 --> 07:10.000
Okay, promise all settled.

07:10.000 --> 07:13.000
Ich wundert es mich eigentlich, dass es sowas nicht früher gab.

07:13.000 --> 07:16.000
Gut, es gab auch einfach immer Workarounds dafür.

07:16.000 --> 07:18.000
Ich habe es noch nie benutzt.

07:18.000 --> 07:21.000
Das ist jetzt blöd, weil das heißt jetzt nicht, dass ich es nicht cool finde.

07:21.000 --> 07:25.000
Ich habe es einfach noch nie gebraucht, gerade in den letzten Monaten.

07:25.000 --> 07:27.000
Ich weiß auch noch gar nicht, seit's wanns genau gibt.

07:27.000 --> 07:31.000
Ich höre ja immer vorher, ah, irgendwann soll's mal sowas geben, ist ja total cool.

07:31.000 --> 07:35.000
Dann habe ich immer das Problem, dann vergesse ich wieder, dass das existieren wird in der Zukunft,

07:35.000 --> 07:38.000
weil ich kann es vielleicht noch nicht benutzen und irgendwann ist es plötzlich da.

07:38.000 --> 07:47.000
Also all settled nimmt als Parameter ein iteratable an und return dafür ein Einzelnis promise

07:47.000 --> 07:51.000
und das wird einfach Bescheid zeigen, sobald alle promises fertig sind,

07:51.000 --> 07:56.000
ob jetzt successful oder mit Fehler, aber auf jeden Fall sind sie dann alle fertig.

07:56.000 --> 08:01.000
Genau, ich überlege gerade, ob ich das als Antipätern bezeichnen möchte.

08:01.000 --> 08:08.000
Weil promise Fehler ist ja gleichsam die asynchrone exception.

08:08.000 --> 08:17.000
So, das heißt in meinem Fall finde ich halt so ein catchall für,

08:17.000 --> 08:21.000
interessiert mich nicht so richtig, ob das jetzt irgendwie Erfolg oder Fehler war.

08:21.000 --> 08:26.000
Ein bisschen fragwürdig, weil wenn ich den Fehler sozusagen handeln möchte,

08:26.000 --> 08:29.000
ohne dass es halt irgendwie exceptionmäßig ein Abriss des Programms geht,

08:29.000 --> 08:33.000
würde ich doch eher sagen, ich nehme das fehlschlagende promise und hänge dann catchhandler an.

08:33.000 --> 08:37.000
Also irgendwie finde ich das expliziter als zu sagen, schmeiß die da alle rein

08:37.000 --> 08:39.000
und hinterher interpretiere ich es um.

08:39.000 --> 08:44.000
Ausnahme natürlich, es gibt irgendwie eine API, wo häufig fehlende promises rauskommen.

08:44.000 --> 08:48.000
Also das jetzt meine Interpretation rejected as promise ist eine exception,

08:48.000 --> 08:50.000
de facto sieht es wahrscheinlich bei vielen anderen aus.

08:50.000 --> 08:53.000
Ich habe ein Beispiel dafür, wir haben auch bei uns auf der Plattform,

08:53.000 --> 08:58.000
dass wir das User bei uns andere URLs eingeben können,

08:58.000 --> 09:01.000
um was zu hinterlegen und dafür fetschen wir auch die Metadaten.

09:01.000 --> 09:04.000
Das ist natürlich alles mit Time Out, weil das kann unfassbar lange dauern

09:04.000 --> 09:07.000
und da kann auch wirklich mal nichts zurückkommen.

09:07.000 --> 09:11.000
Und da sagen wir zum Beispiel, wenn wir jetzt auch mehrere URLs hinlegen,

09:11.000 --> 09:17.000
wir versuchen es einfach für, ich glaube, 8 oder 10 Sekunden alles zu kriegen, was wir können.

09:17.000 --> 09:21.000
Und die werden dann halt Time Outed.

09:21.000 --> 09:24.000
Wenn nichts kommt und dann nehmen wir halt einfach alles, was kommt.

09:24.000 --> 09:28.000
Und wenn halt 3 URLs keine Metadaten liefern konnten, dann ist uns auch Wurscht

09:28.000 --> 09:32.000
und schreiben wir hin, Title, Description selber eintragen.

09:32.000 --> 09:36.000
Genau, und dass Metadaten konnten nicht geruhlt werden.

09:36.000 --> 09:39.000
Was also sozusagen einfach einer der normalen Fälle ist,

09:39.000 --> 09:41.000
das ist jetzt nicht der Happieste, der Happy Paths,

09:41.000 --> 09:43.000
aber einer, wo man sagt, macht jetzt auch keinen Unterschied,

09:43.000 --> 09:46.000
wird aber dann mit dem exceptionartigen Mechanismus modelliert,

09:46.000 --> 09:48.000
weil was willst du sonst nehmen?

09:48.000 --> 09:49.000
Ja.

09:49.000 --> 09:51.000
Und dafür will ich eigentlich auch kein Error Monitoring.

09:51.000 --> 09:54.000
Also ich kann vielleicht mitschreiben und mitlocken,

09:54.000 --> 09:56.000
wie oft es passiert, damit man überdenken kann,

09:56.000 --> 09:58.000
ob es überhaupt Sinn macht, dieses Video zu haben.

09:58.000 --> 10:01.000
Aber ich will jetzt auch nicht in Century irgendwie aufbingen.

10:01.000 --> 10:04.000
Metadaten nicht glatt, Metadaten nicht glatt. Ja, ja, schon klar, weiß ich.

10:04.000 --> 10:05.000
Ignore hier mal.

10:05.000 --> 10:08.000
Ja, nee, das ist kein Fehler, sondern halt irgendwie ein...

10:08.000 --> 10:10.000
Eine Info.

10:10.000 --> 10:12.000
Eine Info, genau, genau.

10:12.000 --> 10:16.000
Aber wie gesagt, wenn man jetzt das mal von der Synchrone übersetzen würde,

10:16.000 --> 10:19.000
wäre das ja quasi schon Control Flow durch Exception Handling,

10:19.000 --> 10:22.000
wo halt dann die Java Graubärte uns sagen würden, das macht man aber nicht.

10:22.000 --> 10:24.000
Ja.

10:24.000 --> 10:26.000
Also weiß ich, keine Ahnung, er hängt am Ende auch mit damit ab,

10:26.000 --> 10:28.000
mit was man es zu tun haben will.

10:28.000 --> 10:30.000
Und ich meine, wenn man das irgendwie auf einer API-Ebene entscheiden muss,

10:30.000 --> 10:34.000
gilt das jetzt als epischer Fehlschlag oder als Normalfall für Daten ist nicht da.

10:34.000 --> 10:36.000
Also ich habe nichts gegen All Zettel.

10:36.000 --> 10:39.000
Ich denke halt nur, immer wenn ich das wahrscheinlich gebrauchen würde,

10:39.000 --> 10:41.000
heutzutage würde ich es irgendwie anders handeln,

10:41.000 --> 10:44.000
aber ist jetzt wahrscheinlich auch echt kein großer Unterschied.

10:44.000 --> 10:46.000
Mhm.

10:46.000 --> 10:49.000
Also wir haben noch nicht benutzt Wissen, aber Bescheid.

10:49.000 --> 10:51.000
Ja.

10:51.000 --> 10:53.000
Aber eine Sache dazu habe ich noch zu sagen,

10:53.000 --> 10:56.000
weil ich habe ja gerade gemeint, als Parameter nimmt es ein Iterable Hand.

10:56.000 --> 10:59.000
Entschuldigung, es sind immer solche Wörter, die ich immer nur schreibe und dann steupe.

10:59.000 --> 11:01.000
Ich drüber beim Aussprechen.

11:01.000 --> 11:05.000
Du bist ja unser TypeScript-Experte,

11:05.000 --> 11:08.000
erklär wer, ein Iterable,

11:08.000 --> 11:10.000
sprich mal so aus.

11:10.000 --> 11:12.000
A-Tribble.

11:12.000 --> 11:14.000
Okay.

11:14.000 --> 11:16.000
Ein Array, Set, Map.

11:16.000 --> 11:18.000
Gibt es noch weitere Möglichkeiten?

11:18.000 --> 11:20.000
A-Tribble ist bloß ein Interface.

11:20.000 --> 11:23.000
Das kannst du im Prinzip auf jedem Objekt implementieren.

11:23.000 --> 11:28.000
Also du kannst doch dann dir eine ganz eigene Sorte von Listen-artigem Objekt machen.

11:28.000 --> 11:30.000
Wir tun jetzt mal so, als wäre es eine Klasse.

11:30.000 --> 11:33.000
Du hast ja gerade gesagt, Klassens sind jetzt irgendwie doof und riechen nach Lulu.

11:33.000 --> 11:35.000
Neckling nach Java.

11:35.000 --> 11:40.000
Irgendwann muss ich dich noch eine Sache zu View und Klassens fragen.

11:40.000 --> 11:43.000
Da habe ich letztens eine sehr schöne Frontalcarambolage bei einem Kunden gehabt.

11:43.000 --> 11:45.000
Aber nee.

11:45.000 --> 11:49.000
Also was du machst, du baust ein Objekt, definierst darauf ein Feld.

11:49.000 --> 11:53.000
Das Feld hat den Namen Symbol.iterator, also ein spezifisches Symbol

11:53.000 --> 11:55.000
von den globalen Wohlbekannten.

11:55.000 --> 12:00.000
Und darauf definierst du eine Funktion, die werden aufgerufen, ein Objekt returned.

12:00.000 --> 12:07.000
Das Objekt hat dann eine Methode Next und das Returnt wiederum Objekte mit Done und False.

12:07.000 --> 12:09.000
Und davon die Kurzform ist die Generator Function.

12:09.000 --> 12:13.000
Das ist einfach so das allgemeine Interface, was man da implementiert.

12:13.000 --> 12:19.000
Und das Promise All Zettel sollte halt mit all dem klar kommen, was das so macht.

12:19.000 --> 12:21.000
Ja.

12:21.000 --> 12:24.000
Generell glaube ich, dass Set und Map ein bisschen unterschätzt sind

12:24.000 --> 12:27.000
im Mein im JavaScript, TypeScript umfällt.

12:27.000 --> 12:29.000
Es ist immer sofort halt ein Array.

12:29.000 --> 12:31.000
Ich würde das gerne mal ein bisschen...

12:31.000 --> 12:33.000
Immer.

12:33.000 --> 12:36.000
Ich würde eigentlich gerne mal mehr mit Sets und Maps arbeiten,

12:36.000 --> 12:39.000
weil das ist halt irgendwie so unscharverskriptisch.

12:39.000 --> 12:41.000
Ja, nicht nur das.

12:41.000 --> 12:44.000
Ich glaube halt eben, der JavaScriptler ist auch generell der alternativen Datenstruktur

12:44.000 --> 12:46.000
eher skeptisch gegenüber eingestellt.

12:46.000 --> 12:49.000
Ich habe letztens für mich das sortierte Array entdeckt.

12:49.000 --> 12:51.000
So einfach total der Oberhammer.

12:51.000 --> 12:53.000
Also ich musste da zwar ein Algorithmus implementieren, den ich nicht verstanden habe,

12:53.000 --> 12:56.000
weil ich habe ja Geschichte und Film studiert und nichts Anständiges.

12:56.000 --> 12:59.000
Aber als ich den halt eben übertragen hatte nach TypeScript

12:59.000 --> 13:01.000
und halt eben dann noch Symbol.iterator draufgemacht habe,

13:01.000 --> 13:03.000
okay, ich habe jetzt keine Literal-Syntax dafür,

13:03.000 --> 13:05.000
aber ich habe ein Array, das einfach permanent sortiert ist,

13:05.000 --> 13:08.000
weil die Use-Case ist echt super ist und auch echt besser performt,

13:08.000 --> 13:11.000
als wenn man es halt irgendwie hin und wieder sortiert.

13:11.000 --> 13:13.000
Und das geht halt voll gut mit allem zusammen klar.

13:13.000 --> 13:16.000
Also kannst du ein Array from reinstecken, kriegst ein richtiges Array raus.

13:16.000 --> 13:18.000
Kannst du irgendwie in eine Voroffschleife verwenden?

13:18.000 --> 13:20.000
Das ist wirklich so quasi-native,

13:20.000 --> 13:23.000
ohne dass sich tatsächlich so klar sortet Array Extents Array.

13:23.000 --> 13:25.000
Ich habe es einfach von Fuß nochmal neu implementiert.

13:25.000 --> 13:27.000
Total großartig.

13:27.000 --> 13:29.000
Aber sowas sieht man irgendwo.

13:29.000 --> 13:32.000
Ja, schade.

13:32.000 --> 13:35.000
Außer halt eben natürlich irgendwie so Class-List oder so,

13:35.000 --> 13:37.000
was ja im Prinzip auch nicht ein Array ist,

13:37.000 --> 13:41.000
sondern halt so eine Dom-Token-List, Dom-String-List, eins von beiden.

13:41.000 --> 13:43.000
Das nimmt man dann.

13:43.000 --> 13:46.000
Aber irgendwie selber, die Dinger zu verwenden, ist nicht so das große Dritt.

13:46.000 --> 13:48.000
Ja, man nimmt schon an, wenn es da schon herkommt,

13:48.000 --> 13:50.000
aber man kommt nicht selber auf die Idee, das zu machen.

13:50.000 --> 13:52.000
Und ich finde das irgendwie komisch,

13:52.000 --> 13:54.000
wenn ich mich dann irgendwie mit anderen Developern unterhalte,

13:54.000 --> 13:56.000
wenn ich sage, ich habe einfach nur ein Array,

13:56.000 --> 13:58.000
und dann so ja ein Dictionary.

13:58.000 --> 14:00.000
Nee, halt ein Array, ein Liste halt.

14:00.000 --> 14:02.000
Ja, ist halt...

14:02.000 --> 14:04.000
Hat die eine fixe Länge?

14:04.000 --> 14:07.000
Wächst die? Was sind da so die Memory-Behaviours und so?

14:07.000 --> 14:09.000
Ist ja nicht so, als ob wir die Wahl hätten.

14:09.000 --> 14:12.000
Wie macht das denn der Garbage-Collector?

14:12.000 --> 14:14.000
Der Garbage-Collector, ja.

14:14.000 --> 14:16.000
Ja, macht das halt, ne?

14:16.000 --> 14:19.000
Also, ich beschuldige ja ganz knallhart Jason.

14:19.000 --> 14:22.000
Du kannst ja auch mit den ganzen Maps und Sets und Gedönsen

14:22.000 --> 14:24.000
nichts werden in Jason.

14:24.000 --> 14:26.000
Mhm.

14:26.000 --> 14:29.000
Und ich glaube, weil einfach alle Jason sprechen.

14:29.000 --> 14:31.000
Hat das halt einfach...

14:31.000 --> 14:33.000
So schon mal ist das einfach ein kompletter No-Starter.

14:35.000 --> 14:38.000
Also klar, du könntest halt irgendwie jetzt so

14:38.000 --> 14:40.000
eine Map verwenden oder ein Set oder so kram,

14:40.000 --> 14:42.000
aber das machst du ja wirklich

14:42.000 --> 14:44.000
in irgendwelchen JavaScript-Programmen,

14:44.000 --> 14:46.000
die sozusagen in sich selbst

14:46.000 --> 14:48.000
irgendwelche komplexen Sachen mit Datenstrukturen machen.

14:48.000 --> 14:51.000
Aber ich glaube, das findet halt bei vielen Menschen kaum statt.

14:51.000 --> 14:53.000
Weil die halt eben mehr so

14:53.000 --> 14:56.000
gibt Daten von API, bastet das hier ins React-Framework rein

14:56.000 --> 14:58.000
und dann ist fertig.

14:58.000 --> 15:00.000
Und dann spielt das halt auch keine Rolle,

15:00.000 --> 15:02.000
dass man da mehr Möglichkeiten hätte

15:02.000 --> 15:04.000
oder dass die irgendwie effizienter wären.

15:04.000 --> 15:07.000
Weil das halt einfach so ein ganz kleiner Problemslice

15:07.000 --> 15:09.000
von dem gesamten Kuchen ist.

15:09.000 --> 15:11.000
Ja, und bei jedem Video-Tutorial,

15:11.000 --> 15:13.000
wir haben ja mittlerweile diese Ära an Frameworks,

15:13.000 --> 15:15.000
die alle Developer-Relations haben

15:15.000 --> 15:17.000
und alle viel eigene Werbung haben

15:17.000 --> 15:19.000
und dann immer die besten Tutorials über,

15:19.000 --> 15:21.000
ja, wahrscheinlich, wie mache ich jetzt React mit,

15:21.000 --> 15:23.000
weil wir haben immer gerade der aktuelle Store

15:23.000 --> 15:25.000
für React heißt.

15:25.000 --> 15:27.000
Und das sind ja alles Errays.

15:27.000 --> 15:30.000
Und dann schaust du dabei den Experten-Expertinnen zu.

15:30.000 --> 15:33.000
Also, warum sollte jetzt jemand junioriges auf die Idee kommen,

15:33.000 --> 15:35.000
nach Set und Map überhaupt zu googeln,

15:35.000 --> 15:37.000
wenn man das noch nicht mehr gehört hat?

15:37.000 --> 15:39.000
Ja.

15:39.000 --> 15:41.000
Die haben alle ihre Use-Cases,

15:41.000 --> 15:43.000
aber ich finde, die sind auch alle so ein bisschen exotisch

15:43.000 --> 15:46.000
und so und da kann man wirklich dem 0815

15:46.000 --> 15:49.000
ehrlichen React-Arbeiterinnen und Arbeiter, weißt du?

15:49.000 --> 15:51.000
Ja.

15:51.000 --> 15:53.000
Die morgens aufstehen, den ganzen Tag in der React-Mine schuften

15:53.000 --> 15:55.000
und abends nach Hause fahren.

15:55.000 --> 15:57.000
Die vier Stunden in Meetings sind meinste.

15:57.000 --> 16:00.000
Äh, ja, stimmt, das habe ich vergessen.

16:00.000 --> 16:03.000
Also, die Person, die da acht Stunden am Coding ist

16:03.000 --> 16:05.000
und dann nach Hause fertig, kenne ich nicht.

16:05.000 --> 16:08.000
Nee, das ist wahrscheinlich eher nicht.

16:08.000 --> 16:10.000
Das sind dann mehr so die brotlosen Künstler.

16:13.000 --> 16:15.000
Herrlich.

16:15.000 --> 16:17.000
In Künstler ist auch der dynamische Import.

16:17.000 --> 16:19.000
Ein überlebenskünstler.

16:19.000 --> 16:23.000
Wo wir jetzt das Keyword await setzen können,

16:23.000 --> 16:25.000
bevor wir schreiben, Import,

16:25.000 --> 16:28.000
irgendein Shavascript-Module oder was auch immer.

16:28.000 --> 16:32.000
Ich gebe meinen Thumbs-Up für, habe ich benutzt,

16:32.000 --> 16:34.000
für wirklich diverse Sachen

16:34.000 --> 16:36.000
und fand es auch immer wieder praktisch,

16:36.000 --> 16:39.000
Sachen dynamisch nachzuladen.

16:39.000 --> 16:42.000
Ja, wir sehen mich ja mehr so dazu gezwungen,

16:42.000 --> 16:44.000
weil ich follow-on mich entschieden habe,

16:44.000 --> 16:47.000
ah, baut das Ding halt mit Next.js

16:47.000 --> 16:49.000
und dann bist du irgendwie so,

16:49.000 --> 16:51.000
du musst hast ja irgendwie so automatisch

16:51.000 --> 16:54.000
die Reakt-Komponente auf dem Server wie auf dem Client.

16:54.000 --> 16:57.000
Und dann kannst du ja erstmal nicht einfach so sagen,

16:57.000 --> 16:59.000
hier ist jetzt Web-Komponent angesagt,

16:59.000 --> 17:03.000
weil da müsstest du ja deine Class Extents HTML Element sagen

17:03.000 --> 17:06.000
und HTML Element auf Node ist einfach nur eine Exception.

17:06.000 --> 17:08.000
Also muss man dann irgendwo sagen,

17:08.000 --> 17:10.000
wenn der Mond richtig steht

17:10.000 --> 17:12.000
und ich über irgendwelche obskuren Mechanismen rausstelle,

17:12.000 --> 17:15.000
dass ich mich Reakt-Komponente jetzt gerade auf dem Client befinde,

17:15.000 --> 17:17.000
dann lade ich auch erst diese Library nach,

17:17.000 --> 17:20.000
die ansonsten einfach nur qua existenzende Exception auslöst

17:20.000 --> 17:22.000
und dann ist halt irgendwie plötzlich alles asynchron geworden.

17:22.000 --> 17:24.000
Ich will ja einfach nur eine HTML-Krams anzeigen,

17:24.000 --> 17:26.000
aber ich muss es jetzt halt irgendwie

17:26.000 --> 17:28.000
mit einem Ladespinner versehen,

17:28.000 --> 17:30.000
weil ich es halt dynamisch nachladen muss.

17:30.000 --> 17:32.000
Immerhin geht's, immerhin geht's.

17:32.000 --> 17:34.000
Immerhin geht's.

17:34.000 --> 17:36.000
Der eine Use Case, den ich habe,

17:36.000 --> 17:38.000
ist, dass ich genau wie du gerade meinst,

17:38.000 --> 17:40.000
eine Bibliothek nachladen muss, die relativ groß ist,

17:40.000 --> 17:42.000
aber die brauche ich halt auch nur in dem Fall,

17:42.000 --> 17:44.000
das ist ein Editor,

17:44.000 --> 17:46.000
und dann brauche ich aber nur in dem Fall,

17:46.000 --> 17:48.000
wenn die User auch tatsächlich sagen,

17:48.000 --> 17:50.000
dass sie das nicht editieren,

17:50.000 --> 17:52.000
sonst lade ich es nicht davor,

17:52.000 --> 17:54.000
sonst ist es halt nur eine View davon.

17:54.000 --> 17:56.000
Beim Anfang sind es, glaube ich, ein paar Icons,

17:56.000 --> 17:58.000
die ich nachladen, je nach Case,

17:58.000 --> 18:00.000
ob die User jetzt bestimmte Tools verknüpft haben,

18:00.000 --> 18:02.000
dann brauche ich in dem Fall,

18:02.000 --> 18:04.000
dass sie das verknüpft haben,

18:04.000 --> 18:06.000
dann auch die Icons.

18:06.000 --> 18:08.000
Das weiß ich natürlich nicht vorher,

18:08.000 --> 18:10.000
sondern das klingt ja dann von den Context-Usern ab.

18:10.000 --> 18:12.000
Und dann ist es halt so ein bisschen

18:12.000 --> 18:14.000
kleinseitige Single-Page-Application,

18:14.000 --> 18:16.000
dass ich da sage, ich habe da kleinseitiges Routing,

18:16.000 --> 18:18.000
Routing,

18:18.000 --> 18:20.000
und möchte halt tatsächlich den einen Teil nur laden,

18:20.000 --> 18:22.000
wenn die Page auch angeklickt wird.

18:22.000 --> 18:24.000
Und dann habe ich halt meinen

18:24.000 --> 18:26.000
Loading-Spinner, habe ich natürlich nicht.

18:26.000 --> 18:28.000
Wir haben natürlich so einen coolen,

18:28.000 --> 18:30.000
smoothen Loading-Biken.

18:30.000 --> 18:32.000
So Balken,

18:32.000 --> 18:34.000
cooler als Spinner?

18:34.000 --> 18:36.000
Ja, aktuell, glaube ich,

18:36.000 --> 18:38.000
ist das noch in Mode.

18:38.000 --> 18:40.000
Aber ich habe auch gehört,

18:40.000 --> 18:42.000
ich bin ja millennial, glaube ich,

18:42.000 --> 18:44.000
ich bin mir nicht ganz sicher,

18:44.000 --> 18:46.000
und habe ich über TikTok erfahren.

18:46.000 --> 18:48.000
Ich muss jetzt andere Routines kaufen.

18:48.000 --> 18:50.000
Also vielleicht sind Spinner auch jetzt wieder in.

18:50.000 --> 18:52.000
Und ich habe es noch nicht gemacht.

18:52.000 --> 18:54.000
Ich würde mir jedenfalls sagen,

18:54.000 --> 18:56.000
für so lange du noch Informationen von TikTok beziehst,

18:56.000 --> 18:58.000
ist das Grab noch nicht so nah?

18:58.000 --> 19:00.000
Das war meine Corona-Phase,

19:00.000 --> 19:02.000
wo ich gedacht habe,

19:02.000 --> 19:04.000
Fernsehen ist zu anstrengend.

19:04.000 --> 19:06.000
Ich versuche jetzt mal dieses TikTok,

19:06.000 --> 19:08.000
weil das war nicht ganz so anstrengend,

19:08.000 --> 19:10.000
das war so kurzlebig.

19:10.000 --> 19:12.000
Ich habe jedem geschworen, ich lösche es dann auch wieder.

19:12.000 --> 19:14.000
Oh je.

19:14.000 --> 19:16.000
Okay, also dann geben wir

19:16.000 --> 19:18.000
dem Dynamic Import unseren Daumen hoch.

19:18.000 --> 19:20.000
Und dann kommen wir zum

19:20.000 --> 19:22.000
Nallish Corlessing. Jawoll.

19:22.000 --> 19:24.000
Steht es

19:24.000 --> 19:26.000
und ständig bei mir?

19:26.000 --> 19:28.000
Tatsächlich.

19:28.000 --> 19:30.000
Ich weiß, was es ist.

19:30.000 --> 19:32.000
Ich habe es noch nie benutzt.

19:32.000 --> 19:34.000
Und dann frage ich mich die ganze Zeit,

19:34.000 --> 19:36.000
bin ich zu doof, mich zu dran erinnern

19:36.000 --> 19:38.000
und ich bräuchte es eigentlich,

19:38.000 --> 19:40.000
oder hatte ich tatsächlich den Use Case noch nicht?

19:40.000 --> 19:42.000
Also, wir reden ja davon

19:42.000 --> 19:44.000
von diesen doppelten Fragezeichen,

19:44.000 --> 19:46.000
zu sagen Null

19:46.000 --> 19:48.000
Fragezeichen, Fragezeichen

19:48.000 --> 19:50.000
oder eben was anderes.

19:50.000 --> 19:52.000
Und was ich natürlich schon häufig mache,

19:52.000 --> 19:54.000
ist, dass ich schreibe

19:54.000 --> 19:56.000
irgendwas

19:56.000 --> 19:58.000
oder oder irgendwas anderes.

19:58.000 --> 20:00.000
Und der Unterschied zwischen den beiden

20:00.000 --> 20:02.000
ist, dass dieses oder oder Zeichen,

20:02.000 --> 20:04.000
die Pi-Pipe, dafür steht,

20:04.000 --> 20:06.000
dass es irgendein Falsive Value sein kann,

20:06.000 --> 20:08.000
also auch eine Negatriefe

20:08.000 --> 20:10.000
oder ein leerer

20:10.000 --> 20:12.000
String.

20:12.000 --> 20:14.000
Eine negative Nummer ist doch Truthie.

20:14.000 --> 20:16.000
Eine Null ist

20:16.000 --> 20:18.000
Volzi.

20:18.000 --> 20:20.000
Korrekt, danke.

20:20.000 --> 20:22.000
Und hier bei dem

20:22.000 --> 20:24.000
Fragezeichen geht es nur um

20:24.000 --> 20:26.000
Null oder Andefind.

20:26.000 --> 20:28.000
Genau. Und du hast

20:28.000 --> 20:30.000
jetzt gerade ja auch die beste

20:30.000 --> 20:32.000
Erklärung geliefert, warum man lieber

20:32.000 --> 20:34.000
zwei Fragezeichen statt zwei Odas

20:34.000 --> 20:36.000
verwenden würde.

20:36.000 --> 20:38.000
Weil dann ist halt eben diese ganze Truthie

20:38.000 --> 20:40.000
Vollzieggeschichte, die halt aber echt nicht einfach

20:40.000 --> 20:42.000
selbst, wenn man sie irgendwie

20:42.000 --> 20:44.000
im Kopf hat, hat man sie halt immer noch nicht...

20:44.000 --> 20:46.000
Ist mir jetzt ganz fertig.

20:46.000 --> 20:48.000
Ja, minus Null ist nicht Truthie, aber minus

20:48.000 --> 20:50.000
eins.

20:50.000 --> 20:52.000
Also es sei denn, ich habe jetzt irgendwie

20:52.000 --> 20:54.000
Brainfog.

20:54.000 --> 20:56.000
Schon?

20:58.000 --> 21:00.000
Also, wenn man sich halt mal die Bits und Bytes anguckt,

21:00.000 --> 21:02.000
dann schon, ne? Ja, ja, ja.

21:02.000 --> 21:04.000
Aber sonst, das kannst du halt doch keinem

21:04.000 --> 21:06.000
machen.

21:06.000 --> 21:08.000
So, das teste ich jetzt auch nach.

21:08.000 --> 21:10.000
Ja, Truthie.

21:14.000 --> 21:16.000
Ja, gut.

21:16.000 --> 21:18.000
Gut, dass es das gibt.

21:18.000 --> 21:20.000
Nicht wahr?

21:20.000 --> 21:22.000
Also ich verwende das halt einfach ganz gern um zu sagen,

21:22.000 --> 21:24.000
halt die Klappe TypeScript, das passiert eh nicht.

21:24.000 --> 21:26.000
Also so.

21:26.000 --> 21:28.000
Der TypeScript vollzieht ja nach, wenn sozusagen

21:28.000 --> 21:30.000
man einen Programmfahrt genommen hat, der in der

21:30.000 --> 21:32.000
Exception endet.

21:32.000 --> 21:34.000
Das heißt einfach nur Fail, die schmeißt eine Exception.

21:34.000 --> 21:36.000
Und die hat nur den Grund, dass sich an Stellen,

21:36.000 --> 21:38.000
wo eine Expression stehen kann, eine Exception

21:38.000 --> 21:40.000
auslösen kann, also ein Programmablauf

21:40.000 --> 21:42.000
zu sagen kann. Also wenn ich halt irgendwie weiß,

21:42.000 --> 21:44.000
so, well, die variable Foo

21:44.000 --> 21:46.000
enthält laut Typsystem entweder

21:46.000 --> 21:48.000
ein String oder undyfeind.

21:48.000 --> 21:50.000
Ich weiß aber, aufgrund des Programmablaufs,

21:50.000 --> 21:52.000
dass es eigentlich nur undyfeind ist,

21:52.000 --> 21:54.000
wenn wirklich irgendwas krass schief gelaufen ist,

21:54.000 --> 21:56.000
dann habe ich halt irgendwie

21:56.000 --> 21:58.000
so was wie Foo, Fragezeichen, Fragezeichen,

21:58.000 --> 22:00.000
Fail, das sollte niemals passieren.

22:00.000 --> 22:02.000
Mhm, ja.

22:02.000 --> 22:04.000
So sieht es meistens aus.

22:04.000 --> 22:06.000
Ach so, ja, ja, ja, ja, verstehe, das ist

22:06.000 --> 22:08.000
ein bisschen eleganter als die Lösungen, die ich hab.

22:08.000 --> 22:10.000
Es gefällt mir, was du sagst.

22:10.000 --> 22:12.000
Wie sehen die aus?

22:12.000 --> 22:14.000
Ja, das ist dann so ein if

22:14.000 --> 22:16.000
Ausruckverzeichen, Objekt

22:16.000 --> 22:18.000
Schwerfen mal ein Error.

22:18.000 --> 22:20.000
Genau, genau, das ist es

22:20.000 --> 22:22.000
nur halt eben als Einzeiler.

22:22.000 --> 22:24.000
Und das Schöne ist halt, wenn du sowieso nicht

22:24.000 --> 22:26.000
davon ausgehst, dass das passiert, wenn

22:26.000 --> 22:28.000
alles einigermaßen normal läuft,

22:28.000 --> 22:30.000
dann steht das halt weniger im Weg rum als

22:30.000 --> 22:32.000
so ein if-Branch.

22:32.000 --> 22:34.000
Richtig, deswegen sage ich gerade, es ist

22:34.000 --> 22:36.000
ein bisschen elegante.

22:36.000 --> 22:38.000
Zu Minus 1 ist mir gerade noch eine andere Geschichte

22:38.000 --> 22:40.000
eingefallen, bei Inputfeldern vom Type Number

22:40.000 --> 22:42.000
kann ich ja Min und Max Werte eingeben

22:42.000 --> 22:44.000
und worüber

22:44.000 --> 22:46.000
ich selber auch immer wieder stolper,

22:46.000 --> 22:48.000
das bedeutet nicht zwangsweise,

22:48.000 --> 22:50.000
dass man nicht auch tatsächlich negative Zahlen

22:50.000 --> 22:52.000
eingeben kann.

22:52.000 --> 22:54.000
Das stimmt.

22:54.000 --> 22:56.000
Ich glaube, man kann per Pfeiltasten

22:56.000 --> 22:58.000
nicht unter 5 drücken,

22:58.000 --> 23:00.000
aber man kann es auf jeden Fall noch schaffen,

23:00.000 --> 23:02.000
den Minus zu schreiben.

23:02.000 --> 23:04.000
Genau.

23:04.000 --> 23:06.000
Und dann ist das, ich glaube, da haben wir

23:06.000 --> 23:08.000
jetzt so ein bisschen ein Problem

23:08.000 --> 23:10.000
von unseren Superduper Frameworks

23:10.000 --> 23:12.000
und wir haben alles im Klient

23:12.000 --> 23:14.000
und zur Frontend getrennt,

23:14.000 --> 23:16.000
ist, dass ich in der Wildnis

23:16.000 --> 23:18.000
immer weniger richtige Formular

23:18.000 --> 23:24.000
habe, die ich in der Wildnis

23:24.000 --> 23:26.000
immer weniger richtige Formulare

23:26.000 --> 23:28.000
mit so Buttons vom Typen Submit sehe,

23:28.000 --> 23:30.000
sondern eher so Buttons

23:30.000 --> 23:32.000
vom Typ Button

23:32.000 --> 23:34.000
und die machen dann halt

23:34.000 --> 23:36.000
einen API-Request, einen Fetch-Request,

23:36.000 --> 23:38.000
aber die schicken dann halt

23:38.000 --> 23:40.000
einzelne Inputfelder ab, aber das Ganze

23:40.000 --> 23:42.000
ist keine Form mehr.

23:42.000 --> 23:44.000
Da wird dann nichts mehr validiert.

23:44.000 --> 23:46.000
Das Problem ist ja, wenn ich eine Form,

23:46.000 --> 23:48.000
also das Diskute ist ja, wenn ich eine Form habe

23:48.000 --> 23:50.000
mit einem Button, der Submit ist,

23:50.000 --> 23:52.000
dann wird ja immer noch die HTML-Validierung

23:52.000 --> 23:54.000
eben gesagt, hey, dein Wert ist kleiner

23:54.000 --> 23:56.000
als null, aber wir brauchen

23:56.000 --> 23:58.000
hier halt einen positiven Wert, oder wir brauchen

23:58.000 --> 24:00.000
ein Datum in der Zukunft. Dann hat man

24:00.000 --> 24:02.000
diese In-House-Validierung gleich mit

24:02.000 --> 24:04.000
geliefert im Browser.

24:04.000 --> 24:06.000
Aber ist hier schon öfter, dass das einfach nur Buttons sind,

24:06.000 --> 24:08.000
die dann Request abfeuern, aber

24:08.000 --> 24:10.000
keine Forms mitmachen?

24:10.000 --> 24:12.000
Das gibt es also zu

24:12.000 --> 24:14.000
deinem, in der Erklärung zum Number

24:14.000 --> 24:16.000
würde ich noch hinzufügen, du hast ja gesagt mit den Falttasten

24:16.000 --> 24:18.000
und den kleinen Buttons rauf und runter

24:18.000 --> 24:20.000
kann man nicht dieses Limit reißen.

24:20.000 --> 24:22.000
Das sagt ja der Standard tatsächlich nicht.

24:22.000 --> 24:24.000
Das ist tatsächlich den Browser überlassen,

24:24.000 --> 24:26.000
dass sie das so umsetzen. Und das machen die,

24:26.000 --> 24:28.000
glaube ich, alle so. Aber der Punkt

24:28.000 --> 24:30.000
ist halt gedacht, also ein

24:30.000 --> 24:32.000
Feld, das am Ende ein

24:32.000 --> 24:34.000
Wert modelliert, der ein numerischer

24:34.000 --> 24:36.000
gültiger Wert ist, definiert

24:36.000 --> 24:38.000
durch MinMax und den ganzen anderen Kram.

24:38.000 --> 24:40.000
Das ist das eine.

24:40.000 --> 24:42.000
Und das andere ist, nee, die sind keine Forms mehr,

24:42.000 --> 24:44.000
weil wenn du halt eben hingehst und sagst,

24:44.000 --> 24:46.000
hier hast du mal fünf Formular-Validierung,

24:46.000 --> 24:48.000
dann kommt halt zuerst, ja, das sieht ja doof aus.

24:48.000 --> 24:50.000
Das ist halt, machst es halt schön.

24:50.000 --> 24:52.000
Das sieht ja doof aus.

24:52.000 --> 24:54.000
Das passt schon.

24:54.000 --> 24:56.000
Das ist so auch was, was

24:56.000 --> 24:58.000
ich sage, das habe ich aber in meinem

24:58.000 --> 25:00.000
Argumentationsarsenal hinten angestellt,

25:00.000 --> 25:02.000
weil das Konzept einer 80-20-Lösung

25:02.000 --> 25:04.000
in einer Welt, in der du dir auch

25:04.000 --> 25:06.000
einfach 17 Gigabyte NPM

25:06.000 --> 25:08.000
UI-Library installieren könntest, so gut nicht

25:08.000 --> 25:10.000
zählt. Aber eigentlich ist es ja so,

25:10.000 --> 25:12.000
du könntest das nehmen, du hättest 80% schon mal

25:12.000 --> 25:14.000
da, zack Prototypen ohne irgendwas zu tun

25:14.000 --> 25:16.000
gemacht und dann machst es halt noch schön

25:16.000 --> 25:18.000
aus deinen eigenen Formular-Validierungsregeln wieder

25:18.000 --> 25:20.000
da dran. Aber nein, bei Formular-Validierung

25:20.000 --> 25:22.000
ist es genauso wie mit irgendwie modernen Frontends.

25:22.000 --> 25:24.000
Statt dass man einfach irgendwie so einen Submit-Button

25:24.000 --> 25:26.000
zum Submitten nimmt, baut man alles aus Diffs neu auf

25:26.000 --> 25:28.000
oder im Falle von Formular-Validierung

25:28.000 --> 25:30.000
alles mit regulären Ausdrücken von Null wieder aufbauen.

25:30.000 --> 25:32.000
Ich verstehe das auch nicht.

25:32.000 --> 25:34.000
Wahrscheinlich bin ich einfach jetzt hier der alte Grandlar,

25:34.000 --> 25:36.000
der sagt, früher haben wir das doch auch.

25:36.000 --> 25:38.000
Nee, ich verstehe es nicht.

25:38.000 --> 25:40.000
Dass wir alle immer wieder von vorne

25:40.000 --> 25:42.000
von vorne immer wieder

25:42.000 --> 25:44.000
Validierung geschrieben müssen, das ist total getontant.

25:44.000 --> 25:46.000
Ich habe die letzten so paar interne Tools gebaut.

25:46.000 --> 25:48.000
Einfach nur für mich selber, einfach so

25:48.000 --> 25:50.000
Formular, Local Storage,

25:50.000 --> 25:52.000
komplett Vanilla und halt eben

25:52.000 --> 25:54.000
so eine ganze Menge inner HTML und

25:54.000 --> 25:56.000
zwei Web-Components.

25:56.000 --> 25:58.000
Das ist total gammelig, damit kannst du dich halt

25:58.000 --> 26:00.000
echt nicht blicken lassen. Aber ich war halt eben

26:00.000 --> 26:02.000
nach einem Nachmittag fertig und hatte mir drei interne Tools gebaut,

26:02.000 --> 26:04.000
die halt voll gut funktionieren.

26:04.000 --> 26:06.000
In der Zeit installiert sich

26:06.000 --> 26:08.000
Create-React-App nicht mal.

26:10.000 --> 26:12.000
Dann brauchen wir aber schnellere Suite, aber das kommt

26:12.000 --> 26:14.000
später, glaube ich, noch.

26:14.000 --> 26:16.000
Weil als nächstes kommen

26:16.000 --> 26:18.000
Private Feels und der Klasse.

26:18.000 --> 26:20.000
Da übergebe ich doch gleich an dich.

26:20.000 --> 26:22.000
Ja, super. Ständig benutzt

26:22.000 --> 26:24.000
immer, wenn ich eine Klasse schreibe, also Web-Komponent

26:24.000 --> 26:26.000
oder Gebömsel. Darf ich das

26:26.000 --> 26:28.000
Private zu verstehen, wie es in

26:28.000 --> 26:30.000
objektorientierten Sprachen auch einfach ist?

26:30.000 --> 26:32.000
Ist es halt nicht public, ist es private?

26:32.000 --> 26:34.000
So ist es. Das ist private.

26:34.000 --> 26:36.000
Und ich muss es nicht mehr mit einem underscore

26:36.000 --> 26:38.000
prefixen, um zu sagen, bitte, bitte nicht benutzen.

26:38.000 --> 26:40.000
Na, du musst es mit der Route prefixen.

26:40.000 --> 26:42.000
Aber ist es dann

26:42.000 --> 26:44.000
von außen sichtbar und ich weiß,

26:44.000 --> 26:46.000
ich darf es nicht benutzen, weil es eine Route hat

26:46.000 --> 26:48.000
oder ist es von außen tatsächlich nicht mehr sichtbar?

26:48.000 --> 26:50.000
Es ist von außen nicht

26:50.000 --> 26:52.000
accessible.

26:52.000 --> 26:54.000
Also es ist insofern sichtbar,

26:54.000 --> 26:56.000
als dass du, wenn du versuchst,

26:56.000 --> 26:58.000
einen Zugriff zu machen, eine sehr spezifische

26:58.000 --> 27:00.000
Fehlermeldung bekommst.

27:00.000 --> 27:02.000
Der Trick ist der folgende.

27:02.000 --> 27:04.000
Route am Start von einem Identifier war nicht gültig.

27:04.000 --> 27:06.000
Hat man jetzt zugelassen

27:06.000 --> 27:08.000
für den Spezialfall,

27:08.000 --> 27:10.000
in einer Klasse sich befindet,

27:10.000 --> 27:12.000
da darf man so ein Identifier schreiben.

27:12.000 --> 27:14.000
Weil man dann auch die Scope-Check-Regeln,

27:14.000 --> 27:16.000
wo man halt eben guckt, ist dieses Ding hier überhaupt

27:16.000 --> 27:18.000
accessible, gibt es einen

27:18.000 --> 27:20.000
Feld mit diesem Namen,

27:20.000 --> 27:22.000
von neu auf erfinden kann.

27:22.000 --> 27:24.000
Und hat dann sozusagen den gleichen Mechanismus,

27:24.000 --> 27:26.000
der dir ja auch sagt, wenn du irgendwie eine Variable

27:26.000 --> 27:28.000
zweimal definierst, let x, gleich 1, let x, gleich 2,

27:28.000 --> 27:30.000
dann kriegst du ja eine Exception, bevor das Programm

27:30.000 --> 27:32.000
läuft im Rahmen des Sündtags-Checks.

27:32.000 --> 27:34.000
Und der Mechanismus ist quasi für die privaten Felder

27:34.000 --> 27:36.000
in den Klassen gehighjacked,

27:36.000 --> 27:38.000
wenn wir mal einen OOP sprachen,

27:38.000 --> 27:40.000
da sind ja diese Features

27:40.000 --> 27:42.000
Public Private Protected, Features vom Typsystem,

27:42.000 --> 27:44.000
damit du einen Error kriegst, bevor das Programm läuft.

27:44.000 --> 27:46.000
Und du willst ja auch einen Error kriegen

27:46.000 --> 27:48.000
in JavaScript, bevor das Programm läuft,

27:48.000 --> 27:50.000
hast aber keinen Compile-Ergum, musst du den Sündtagschecker

27:50.000 --> 27:52.000
dazu highlighten, und deswegen ist die Route

27:52.000 --> 27:54.000
Namensbestandteil des Identifiers.

27:54.000 --> 27:56.000
Das ist voll gut, da kann man wunderbar

27:56.000 --> 27:58.000
so auch Java-Leute mit trollen,

27:58.000 --> 28:00.000
auf Konferenzen, wo man irgendwie so sagt,

28:00.000 --> 28:02.000
hier Web-Technologieüberblick für Backendler,

28:02.000 --> 28:04.000
kann man irgendwie so sagen, kannst du private Felder machen?

28:04.000 --> 28:06.000
Du kannst es auch mit TypeScript kombinieren.

28:06.000 --> 28:08.000
Yay, aber dann hast du sowohl

28:08.000 --> 28:10.000
das Rauteprivate als auch das Private Keyword

28:10.000 --> 28:12.000
von TypeScript, und die machen beide

28:12.000 --> 28:14.000
unterschiedliche Dinge, und dann ist es

28:14.000 --> 28:16.000
wieder so, braaaah, das hat Entwicklung.

28:16.000 --> 28:18.000
Das macht sehr viel Spaß.

28:18.000 --> 28:20.000
Da hätten wir halt alle mal was Kreins gelernt.

28:20.000 --> 28:22.000
So, aber benutzt hast du die noch nicht,

28:22.000 --> 28:24.000
weil Klassen doof sind?

28:24.000 --> 28:26.000
Ich sage nicht, dass Klassen doof sind,

28:26.000 --> 28:28.000
es ist nur absolut nicht in meinem Use-Case.

28:28.000 --> 28:30.000
Public static void main.

28:30.000 --> 28:32.000
Ja.

28:32.000 --> 28:34.000
Public static void main.

28:34.000 --> 28:36.000
Okay, aber dann würde ich sagen,

28:36.000 --> 28:38.000
runden wir mal auf zu I've used it, oder?

28:38.000 --> 28:40.000
Ja.

28:40.000 --> 28:42.000
Ich habe auch ein bisschen mal benutzt.

28:42.000 --> 28:44.000
Okay, dann zählt das.

28:44.000 --> 28:46.000
Ich hätte sowieso noch eine Frage,

28:46.000 --> 28:48.000
wo ich hier gerade mal die View-Expertin

28:48.000 --> 28:50.000
am Start habe.

28:50.000 --> 28:52.000
Ich war so bei Firma, guckst du an deren

28:52.000 --> 28:54.000
Source Code rein, und die so,

28:54.000 --> 28:56.000
ich habe hier unerklärliche

28:56.000 --> 28:58.000
Typefehler.

28:58.000 --> 29:00.000
In View verwendet man

29:00.000 --> 29:02.000
eigentlich unter gar keinen Umständen

29:02.000 --> 29:04.000
irgendwo mal eine Klasse, oder?

29:04.000 --> 29:06.000
Ich würde jetzt

29:06.000 --> 29:08.000
darauf tippen, dass das ein View 2

29:08.000 --> 29:10.000
Projekt war mit der

29:10.000 --> 29:12.000
Class Style API.

29:12.000 --> 29:14.000
Das war 3.

29:14.000 --> 29:16.000
Das war 3, nee.

29:16.000 --> 29:18.000
Die haben nämlich so ihre ganzen

29:18.000 --> 29:20.000
Geschichten

29:20.000 --> 29:22.000
für Backend-Anbindung, API-Calls und

29:22.000 --> 29:24.000
Zeug halt in Klassen ausmodelliert,

29:24.000 --> 29:26.000
weil die kannten das halt, das waren

29:26.000 --> 29:28.000
Backendler.

29:28.000 --> 29:30.000
Die haben halt so Sachen gemacht, wie

29:30.000 --> 29:32.000
wir nehmen diese Klassen-Instanzen,

29:32.000 --> 29:34.000
die mit TypeScript geschrieben sind,

29:34.000 --> 29:36.000
die sie halt auch so public und private

29:36.000 --> 29:38.000
und protected und so Zeug sind,

29:38.000 --> 29:40.000
und stopfen die halt in solche View-

29:40.000 --> 29:42.000
Konstruktionen, wie so Refs rein.

29:42.000 --> 29:44.000
Ja.

29:44.000 --> 29:46.000
Und dann kamen die halt eben da raus

29:46.000 --> 29:48.000
mit so einer ungefähr gleichen

29:48.000 --> 29:50.000
API, so das lief zur Laufzeit

29:50.000 --> 29:52.000
alles, aber TypeScript hat dann halt

29:52.000 --> 29:54.000
eben behauptet, diese Dinger seien

29:54.000 --> 29:56.000
tatsächlich keine exakten Instanzen

29:56.000 --> 29:58.000
für die Teile, die so Reaktivität

29:58.000 --> 30:00.000
implementieren.

30:00.000 --> 30:02.000
Ja, genau.

30:02.000 --> 30:04.000
So sah das nämlich für mich dann auch irgendwann aus,

30:04.000 --> 30:06.000
dass da man irgendwie A reinsteckt,

30:06.000 --> 30:08.000
man kriegt aber B raus und B hat halt

30:08.000 --> 30:10.000
irgendwie... Ja, das sind die Proxis, die rauskommen.

30:10.000 --> 30:12.000
Genau.

30:12.000 --> 30:14.000
Und weil diese Proxis natürlich dann die

30:14.000 --> 30:16.000
ganzen Privatheiten von diesen Klassen

30:16.000 --> 30:18.000
nicht beinhalten, sind die natürlich

30:18.000 --> 30:20.000
nicht mehr der exakt gleiche Typ.

30:20.000 --> 30:22.000
Nee, überhaupt nicht.

30:22.000 --> 30:24.000
Das macht halt nicht so Sinn.

30:24.000 --> 30:26.000
Das muss man schon so machen.

30:26.000 --> 30:28.000
Aber es ist halt dann komisch.

30:28.000 --> 30:30.000
Ja, man muss halt überall dann SA

30:30.000 --> 30:32.000
nicht ranklatschen, damit man halt eben

30:32.000 --> 30:34.000
TypeScript sagt so, ich weiß, dass es

30:34.000 --> 30:36.000
technisch gesehen nicht exakt ist, aber...

30:36.000 --> 30:38.000
Ja, aber dann...

30:38.000 --> 30:40.000
Also es ist halt wirklich so, es sollte

30:40.000 --> 30:42.000
schon irgendwie einfach ein Objekt, es

30:42.000 --> 30:44.000
darf ein Objekt sein, es darf ein

30:44.000 --> 30:46.000
Area sein und jeder primitiver Typ.

30:46.000 --> 30:48.000
Aber alles, was zu über hinaus geht, macht

30:48.000 --> 30:50.000
dann halt einfach nicht mehr so viel Sinn,

30:50.000 --> 30:52.000
dass man dann ein Proxytraum rumhaut.

30:52.000 --> 30:54.000
Das ist ein normaler, daher gelaufene

30:54.000 --> 30:56.000
View-Entwicklerin oder View-Entwickler.

30:56.000 --> 30:58.000
Also weiß man das.

30:58.000 --> 31:00.000
Weil wir mussten da echt einen ganzen Name

31:00.000 --> 31:02.000
darauf rumkommen, bis wir überhaupt auf die Idee

31:02.000 --> 31:04.000
gekommen sind, dass das sein könnte.

31:04.000 --> 31:06.000
Die hatten keine Ahnung von TypeScript, ich hatte

31:06.000 --> 31:08.000
keine Ahnung von View.

31:08.000 --> 31:10.000
Ich denke, das Problem ist, dass die

31:10.000 --> 31:12.000
Standard-View-Entwickler-Personen

31:12.000 --> 31:14.000
nicht von dieser TypeScript-Back-Entrichtung

31:14.000 --> 31:16.000
kommen. Also wir würden nicht auf die Idee

31:16.000 --> 31:18.000
kommen, eine Klasse zu schreiben.

31:18.000 --> 31:20.000
Wir schreiben halt einfach nur Areas und

31:20.000 --> 31:22.000
sind nicht in meiner Wappel.

31:22.000 --> 31:24.000
Und dann besteht auch

31:24.000 --> 31:26.000
keine sozusagen Veranlassung,

31:26.000 --> 31:28.000
das groß zu dokumentieren oder zu

31:28.000 --> 31:30.000
besprechen, dass man das einfach so wüsste.

31:30.000 --> 31:32.000
Ja, weil es ist ja irgendwie klar,

31:32.000 --> 31:34.000
dass es dann so funktioniert.

31:34.000 --> 31:36.000
Also der einzige Streit, den sonst immer

31:36.000 --> 31:38.000
nur gibt, nimmt man jetzt Ref oder Reactive.

31:38.000 --> 31:40.000
Es ist ungefähr das Gleiche, bei

31:40.000 --> 31:42.000
dem einschreibste Punkt Value dahinter,

31:42.000 --> 31:44.000
beim anderem nicht.

31:44.000 --> 31:46.000
Das ist mal kurob zusammengefasst.

31:46.000 --> 31:48.000
Aber es gab

31:48.000 --> 31:50.000
Ref und Reactive.

31:50.000 --> 31:52.000
Ansonsten gibt es keine weiteren Fragen.

31:52.000 --> 31:54.000
Es gibt andere TypeScript-Fragen.

31:54.000 --> 31:56.000
Das ist aber eher so was

31:56.000 --> 31:58.000
konzeptspezifischeres.

31:58.000 --> 32:00.000
Und ansonsten

32:00.000 --> 32:02.000
bei View und TypeScript zusammen

32:02.000 --> 32:04.000
ist es so, ich weiß immer

32:04.000 --> 32:06.000
gar nicht, ob ich jetzt sagen soll, ich benutze

32:06.000 --> 32:08.000
TypeScript, weil ich fühle mich immer nur,

32:08.000 --> 32:10.000
als würde ich TypeScript-Light verwenden.

32:10.000 --> 32:12.000
Wenn ich jetzt in

32:12.000 --> 32:14.000
VS Code in der IDE schreibe,

32:14.000 --> 32:16.000
const items equals

32:16.000 --> 32:18.000
und dann halt ein Array da drinnen,

32:18.000 --> 32:20.000
dann weiß

32:20.000 --> 32:22.000
VS Code und die

32:22.000 --> 32:24.000
Extensions, die wissen ja schon automatisch,

32:24.000 --> 32:26.000
dass das jetzt ein Typ ist

32:26.000 --> 32:28.000
von Array, von Typen items

32:28.000 --> 32:30.000
automatisch.

32:30.000 --> 32:32.000
Die meiste Magie hat man dann damit schon

32:32.000 --> 32:34.000
fast erledigt.

32:34.000 --> 32:36.000
Oder ich habe halt irgendwie meinen Store,

32:36.000 --> 32:38.000
mein State Management und sage an,

32:38.000 --> 32:40.000
hier erwarte ich entweder einen User-Objekt

32:40.000 --> 32:42.000
oder halt andefined

32:42.000 --> 32:44.000
oder null, ich weiß immer nicht, was besser

32:44.000 --> 32:46.000
ist dann die meiste TypeScript-Magie

32:46.000 --> 32:48.000
schon dahinter.

32:48.000 --> 32:50.000
Na ja, aber das finde ich eigentlich

32:50.000 --> 32:52.000
ist genau der,

32:52.000 --> 32:54.000
da wo man eigentlich sein möchte.

32:54.000 --> 32:56.000
Ja, ich bin da supergerne.

32:56.000 --> 32:58.000
Ich predige auch immer, dass man dahin will.

32:58.000 --> 33:00.000
Also wenn man halt eben genau das macht, was du grad beschrieben hast,

33:00.000 --> 33:02.000
man bewegt sich halt innerhalb dieses Frameworks,

33:02.000 --> 33:04.000
da ist ja wirklich die Idee,

33:04.000 --> 33:06.000
man schreibt ja im Prinzip den Code

33:06.000 --> 33:08.000
und füllt im Prinzip, es ist ja so ein bisschen

33:08.000 --> 33:10.000
malen nach Zahlen, ne? Nimm diesen Standard Store

33:10.000 --> 33:12.000
und nimm dieses Standard Schreibweise,

33:12.000 --> 33:14.000
das Standard Komponente zu bauen

33:14.000 --> 33:16.000
und dann beschreibe im Prinzip wie aus den Daten am Ende

33:16.000 --> 33:18.000
der schöne View wird.

33:18.000 --> 33:20.000
Das heißt du bist ja ständig

33:20.000 --> 33:22.000
im Kontakt mit irgendwelchen Dingern, die sozusagen

33:22.000 --> 33:24.000
dafür sorgen, dass

33:24.000 --> 33:26.000
die Typen

33:26.000 --> 33:28.000
required und halt eben auch vergeben werden

33:28.000 --> 33:30.000
und dann musst du das nicht machen und diese ganze

33:30.000 --> 33:32.000
advanced TypeScript hier, was der Stefan und ich immer

33:32.000 --> 33:34.000
so rum fabulieren,

33:34.000 --> 33:36.000
das brauchst du halt um das zu ermöglichen, aber wenn es dir schon ermöglicht wird,

33:36.000 --> 33:38.000
weil View halt eben ordentlich aufgezogen ist,

33:38.000 --> 33:40.000
dann profitierst du einfach nur

33:40.000 --> 33:42.000
und dann ist das nicht TypeScript Lite, sondern dann stehst du halt

33:42.000 --> 33:44.000
eben einfach auf den Schultern von Riesen und das ist voll gut

33:44.000 --> 33:46.000
und wenn man da nicht steht und ständig an Variablen

33:46.000 --> 33:48.000
Typen dranschreiben muss, dann macht entweder

33:48.000 --> 33:50.000
man was falsch oder das

33:50.000 --> 33:52.000
Framework, mit dem man zu tun hat, macht was falsch.

33:52.000 --> 33:54.000
Das ist nicht TypeScript Lite, das ist TypeScript

33:54.000 --> 33:56.000
TypeScript Right.

33:56.000 --> 33:58.000
Sehr gut.

33:58.000 --> 34:00.000
Sehr gut.

34:00.000 --> 34:02.000
Komm wir als nächstes,

34:02.000 --> 34:04.000
ich glaube wieder zu anders Kurs,

34:04.000 --> 34:06.000
wenn ich mich nicht täusche bei den

34:06.000 --> 34:08.000
Numeric Separators.

34:08.000 --> 34:10.000
Wenn ich das richtig verstehe, ist das

34:10.000 --> 34:12.000
einfach nur für Menschenlesbarkeit,

34:12.000 --> 34:14.000
dass wenn ich jetzt eine lange Zahl habe, so

34:14.000 --> 34:16.000
eine Milliarde oder sowas, da wo ich schon gar nicht

34:16.000 --> 34:18.000
mehr weiß, wie viele Nullen das hat,

34:18.000 --> 34:20.000
dass ich mir dann anders score, so nach allen

34:20.000 --> 34:22.000
drei Ziffern schreiben kann,

34:22.000 --> 34:24.000
die der Computer ignoriert,

34:24.000 --> 34:26.000
aber ich kann es besser lesen, ist das korrekt?

34:26.000 --> 34:28.000
Genau, so ist das.

34:28.000 --> 34:30.000
Der einzige Unterschied ist halt nur,

34:30.000 --> 34:32.000
du musst noch deinen inneren Troll channeln.

34:32.000 --> 34:34.000
Du kannst diese anders score

34:34.000 --> 34:36.000
nach allen drei Zeichen machen, aber eigentlich

34:36.000 --> 34:38.000
ist das einfach nur ein Know-of

34:38.000 --> 34:40.000
in der Sonntags.

34:40.000 --> 34:42.000
Du kannst auch irgendwie nach jedem Zeichen

34:42.000 --> 34:44.000
einen anders score machen.

34:44.000 --> 34:46.000
Kann ich auch zwei schreiben, anders score, anders score?

34:46.000 --> 34:48.000
Das weiß ich jetzt natürlich nicht.

34:48.000 --> 34:50.000
Ausprobieren?

34:50.000 --> 34:52.000
Keine Ahnung, eins, anders score, anders score,

34:52.000 --> 34:54.000
eins, anders score, anders score, eins.

34:54.000 --> 34:56.000
Nee, das geht nicht.

34:56.000 --> 34:58.000
The only one anders score is allowed as a Numeric

34:58.000 --> 35:00.000
Separator. Also genau für den Fall

35:00.000 --> 35:02.000
ist im Browser ein String hinterlegt mit der

35:02.000 --> 35:04.000
korrekten Fehlermeldung.

35:04.000 --> 35:06.000
Ja, dieser Aufristin,

35:06.000 --> 35:08.000
die beim Browser programmieren,

35:08.000 --> 3