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 --> 35:10.000
betreiben müssen einfach nur, weil hier zwei Leute

35:10.000 --> 35:12.000
...

35:12.000 --> 35:14.000
Oh, schon wieder eine Extension in Sentry.

35:14.000 --> 35:16.000
Da darfst du schon wieder ausprobieren.

35:16.000 --> 35:18.000
Okay.

35:18.000 --> 35:20.000
Das ist also auch eigentlich

35:20.000 --> 35:22.000
eine schöne Trollmethode.

35:22.000 --> 35:24.000
Wenn man irgendwo

35:24.000 --> 35:26.000
detected, dass die Seite Sentry hat,

35:26.000 --> 35:28.000
braucht man eine Browser Extension, die einfach

35:28.000 --> 35:30.000
so random garbage auslöst.

35:30.000 --> 35:32.000
Ja, das wäre ganz toll.

35:32.000 --> 35:34.000
Das funktioniert

35:34.000 --> 35:36.000
schon immer jedes Mal, wenn Safari Update

35:36.000 --> 35:38.000
rauskommt, dass

35:38.000 --> 35:40.000
Stunden später beim Sentry

35:40.000 --> 35:42.000
mal rot ist. Alle fragen mich, was

35:42.000 --> 35:44.000
los passiert, geht unsere Webseite

35:44.000 --> 35:46.000
noch? Ja, ja, es ist eine neue Safari.

35:46.000 --> 35:48.000
Die wissen das in Early Birds, die wissen

35:48.000 --> 35:50.000
schon Bescheid gar keine Webseite.

35:50.000 --> 35:52.000
Nee, ich weiß gar nicht, dass Safari war,

35:52.000 --> 35:54.000
glaube ich, sogar ganz gut.

35:54.000 --> 35:56.000
Man könnte da wirklich auch schöne

35:56.000 --> 35:58.000
Exceptions auslösen, einfach so

35:58.000 --> 36:00.000
besser zum Spaß. Also so was wie mit den

36:00.000 --> 36:02.000
Stringfroton-Types.

36:02.000 --> 36:04.000
Ja, super.

36:04.000 --> 36:06.000
Da hast du normale Menschen, die halt

36:06.000 --> 36:08.000
das gar nicht wissen, dass es existiert.

36:08.000 --> 36:10.000
Die müssen erst mal gucken,

36:10.000 --> 36:12.000
was?

36:12.000 --> 36:14.000
Oder weißt du,

36:14.000 --> 36:16.000
einfach so eine Exception

36:16.000 --> 36:18.000
schmeißen in eines Händes überwachter Webseite.

36:18.000 --> 36:20.000
Verdammt, der Bitcoin-Mainer ist abgestürzt

36:20.000 --> 36:22.000
und muss neu gestartet werden.

36:22.000 --> 36:24.000
Oh je.

36:24.000 --> 36:26.000
Gehen wir lieber ganz schnell weiter

36:26.000 --> 36:28.000
zu Stringfroton-Type

36:28.000 --> 36:30.000
Ja, gut, ich replace

36:30.000 --> 36:32.000
tatsächlich. Replace du

36:32.000 --> 36:34.000
Sachen in Strings

36:34.000 --> 36:36.000
in der Realität?

36:38.000 --> 36:40.000
Sagen wir mal so,

36:40.000 --> 36:42.000
das kommt

36:42.000 --> 36:44.000
durchaus schon vor, weil ich ja auch

36:44.000 --> 36:46.000
viel 80-20 Gramm schreibe.

36:46.000 --> 36:48.000
Weißt du?

36:48.000 --> 36:50.000
Und wenn es halt irgendwie nicht

36:50.000 --> 36:52.000
wasserfest sein muss, dann ist das

36:52.000 --> 36:54.000
irgendwie so eine ad hoc Template,

36:54.000 --> 36:56.000
so einen Tag, den ich mir gerade akut selber

36:56.000 --> 36:58.000
interpoliert.

36:58.000 --> 37:00.000
Kommt schon mal vor.

37:00.000 --> 37:02.000
Aber sagen wir mal so,

37:02.000 --> 37:04.000
es ist halt einfach nur besser als die Alternative,

37:04.000 --> 37:06.000
das ist halt das Wichtigste.

37:06.000 --> 37:08.000
Ja, also ich glaube, das Problem ist,

37:08.000 --> 37:10.000
dass die Alternative

37:10.000 --> 37:12.000
schon sehr irreführend ist.

37:12.000 --> 37:14.000
Also wenn ich jetzt einen String habe

37:14.000 --> 37:16.000
und ich sage, ich möchte da jetzt

37:16.000 --> 37:18.000
ein Wort davon replacen,

37:18.000 --> 37:20.000
dieses Wort kommt aber mehrfach

37:20.000 --> 37:22.000
in dem String vor, dann wird nur das erste

37:22.000 --> 37:24.000
genau das erste davon ersetzt,

37:24.000 --> 37:26.000
das ist nicht vorgestellt.

37:26.000 --> 37:28.000
Wenn ich da sage, replace mir,

37:28.000 --> 37:30.000
das Beispiel ist

37:30.000 --> 37:32.000
Dog mit Monkey,

37:32.000 --> 37:34.000
dann hätte ich auch erwartet,

37:34.000 --> 37:36.000
dass alle Dogs nach Monkey sind.

37:36.000 --> 37:38.000
Aber dafür braucht man dann

37:38.000 --> 37:40.000
replace all.

37:40.000 --> 37:42.000
Ja.

37:42.000 --> 37:44.000
Ja und vor allen Dingen, also

37:44.000 --> 37:46.000
nicht nur das,

37:46.000 --> 37:48.000
aber es ist halt so, wenn man halt so

37:48.000 --> 37:50.000
replaced, ich weiß jetzt gar nicht,

37:50.000 --> 37:52.000
also das normale replaced, ich hatte mal

37:52.000 --> 37:54.000
so einen Replacement durchgeführt

37:54.000 --> 37:56.000
habe,

37:56.000 --> 37:58.000
in einem

37:58.000 --> 38:00.000
JavaScript Bundle, das erzeugt wurde.

38:00.000 --> 38:02.000
Da sollte man halt tendenziell nicht machen,

38:02.000 --> 38:04.000
aber so 80, 20 regelmäßig.

38:04.000 --> 38:06.000
Da gibt es halt am Ende den Default Export

38:06.000 --> 38:08.000
und aus irgendwelchen Gründen will ich

38:08.000 --> 38:10.000
in einem Postbildscript einfach sagen,

38:10.000 --> 38:12.000
der variable Name soll jetzt ersetzt werden

38:12.000 --> 38:14.000
durch dieses und jenes.

38:14.000 --> 38:16.000
Kann man ja machen, einfach nur,

38:16.000 --> 38:18.000
weil ich das halt eben zu dem Zeitpunkt Webpack

38:18.000 --> 38:20.000
nicht irgendwie beibringen konnte,

38:20.000 --> 38:22.000
weil ich das alles kaputtgeht beim nächsten Update,

38:22.000 --> 38:24.000
mache ich halt eben einfach mal ein replace

38:24.000 --> 38:26.000
oder so. Aber weißt du, bei replace

38:26.000 --> 38:28.000
kannst du ja nicht nur sagen string gegen string

38:28.000 --> 38:30.000
oder string gegen rackax, sondern du kannst

38:30.000 --> 38:32.000
halt eben auch so Spezien machen wie

38:32.000 --> 38:34.000
so spezielle Zeichenersetzungsketten, die mit

38:34.000 --> 38:36.000
ein Dollar anfangen.

38:36.000 --> 38:38.000
Und wenn du das halt irgendwie in deinem

38:38.000 --> 38:40.000
JavaScript Bundle irgendwie drin hast, weil

38:40.000 --> 38:42.000
irgendeine NPM-Dipendent, die sich geupdated hat,

38:42.000 --> 38:44.000
dann passieren unerwartete Dinge mit deinem Code.

38:44.000 --> 38:46.000
Deswegen wollte ich auch gerade

38:46.000 --> 38:48.000
einwerfen, deswegen habe ich gerade so

38:48.000 --> 38:50.000
den für das gebildete, was

38:50.000 --> 38:52.000
im Endeffekt rauskommt.

38:52.000 --> 38:54.000
Da habe ich jetzt doch auch viele Meinungen gehört,

38:54.000 --> 38:56.000
es wäre doch schon am besten, wenn man einfach

38:56.000 --> 38:58.000
lokal und im Endeffekt auf Production

38:58.000 --> 39:00.000
den gleichen Code hat, vielleicht minifiziert

39:00.000 --> 39:02.000
und abgeliefert und da, da, da. Aber

39:02.000 --> 39:04.000
bei so Themen wie sollte man

39:04.000 --> 39:06.000
Datatest-Attribute zum Beispiel entfernen

39:06.000 --> 39:08.000
oder nicht, weil es ist ja mehr

39:08.000 --> 39:10.000
Kilobyte, was man ausliefert im Endeffekt

39:10.000 --> 39:12.000
oder mehr Bits, für ein bisschen

39:12.000 --> 39:14.000
Datatest, aber dann wieder die andere

39:14.000 --> 39:16.000
Seite, ja, aber dann würde man ja

39:16.000 --> 39:18.000
quasi Code ausliefern, den man nie lokal

39:18.000 --> 39:20.000
getestet hat, wenn man das modifiziert

39:20.000 --> 39:22.000
und replaced.

39:22.000 --> 39:24.000
Das stimmt.

39:24.000 --> 39:26.000
Ja, ich würde es mit ausliefern, weil

39:26.000 --> 39:28.000
ganz ehrlich die Kilobytes zählen,

39:28.000 --> 39:30.000
glaube ich, nicht so richtig, wenn man ohnehin

39:30.000 --> 39:32.000
irgendwie so moderne Webentwicklung

39:32.000 --> 39:34.000
nach allen Regeln der Kunst betreibt

39:34.000 --> 39:36.000
und einfach nur, ich würde halt gar nicht

39:36.000 --> 39:38.000
drüber nachdenken wollen, da sind halt

39:38.000 --> 39:40.000
Datatestinger drin, finde ich damit ab,

39:40.000 --> 39:42.000
der du eh nicht in den Quellcode guckst.

39:42.000 --> 39:44.000
Ich würde auch argumentieren für,

39:44.000 --> 39:46.000
es gibt, sehr wahrscheinlich gibt es

39:46.000 --> 39:48.000
bessere Stellen, wo man optimieren kann,

39:48.000 --> 39:50.000
als Datatest equals Item 1

39:50.000 --> 39:52.000
und das andere ist dieses, aber das ist

39:52.000 --> 39:54.000
hier dann sichtbar und dann kann ich mir

39:54.000 --> 39:56.000
den Quellcode anzeigen.

39:56.000 --> 39:58.000
Ja, gut, ich mein, ist halt so.

39:58.000 --> 40:00.000
Dann sehe ich auch, dass da 100

40:00.000 --> 40:02.000
Tauben Klassen stehen oder dass da

40:02.000 --> 40:04.000
jemand View-Apps mit wie benutzt

40:04.000 --> 40:06.000
oder dass jemand 12 benutzt ist.

40:06.000 --> 40:08.000
Und wenn ich das Datatest sehe,

40:08.000 --> 40:10.000
denke ich mir, yay, das ist getestet.

40:10.000 --> 40:12.000
Also von all den Sachen, die man

40:12.000 --> 40:14.000
mir dann anheften kann, wenn man sich den

40:14.000 --> 40:16.000
Quelltecks anguckt, wären irgendwelche

40:16.000 --> 40:18.000
Attribute echt das letzte, das ein Problem darstellt.

40:20.000 --> 40:22.000
Oh Mann.

40:22.000 --> 40:24.000
Den nächsten String Prototype Match All

40:24.000 --> 40:26.000
kenne ich nicht.

40:26.000 --> 40:28.000
Also, beziehungsweise

40:28.000 --> 40:30.000
habe ich dann ge-googelt

40:30.000 --> 40:32.000
und nicht ganz verstanden.

40:32.000 --> 40:34.000
Also hier gibt es, glaube ich, in Richtung

40:34.000 --> 40:36.000
Reg X, dass ich jetzt sagen möchte,

40:36.000 --> 40:38.000
ich möchte schauen, ob in dem String

40:38.000 --> 40:40.000
was Spezielles vorhanden ist. Ich möchte

40:40.000 --> 40:42.000
lesen. Ich möchte einfach nur als Ergebnis

40:42.000 --> 40:44.000
einen Array haben

40:44.000 --> 40:46.000
wie von den Vorkommen

40:46.000 --> 40:48.000
in dem String. Und das

40:48.000 --> 40:50.000
Match All.

40:50.000 --> 40:52.000
Aber ich glaube, mein Problem ist nicht, dass ich die

40:52.000 --> 40:54.000
Methode nicht verstehe, sondern dass ich

40:54.000 --> 40:56.000
Reg X nicht lesen kann.

40:56.000 --> 40:58.000
Ach, wieso kannst du kein

40:58.000 --> 41:00.000
Reg X lesen? Ja, da war ich das

41:00.000 --> 41:02.000
Beispiel, dass ich das erste, was auf Google

41:02.000 --> 41:04.000
kommt, das erste ist irgendwas mit Test

41:04.000 --> 41:06.000
und eine Nummer danach. Also D für digit,

41:06.000 --> 41:08.000
habe ich verstanden. Aber da ist es

41:08.000 --> 41:10.000
ein Klammern. Ich glaube, das heißt

41:10.000 --> 41:12.000
optional.

41:12.000 --> 41:14.000
Kannst du klammern?

41:14.000 --> 41:16.000
Also das erste Beispiel.

41:16.000 --> 41:18.000
Ich Google das mal kurz raus.

41:18.000 --> 41:20.000
Das ist ein h-T,

41:20.000 --> 41:22.000
das da geschrieben ist. Und dann

41:22.000 --> 41:24.000
kommt ein e in Klammern

41:24.000 --> 41:26.000
und dann kommt wieder in Klammern

41:26.000 --> 41:28.000
ein st.

41:28.000 --> 41:30.000
Und dann wieder in Klammern

41:30.000 --> 41:32.000
ein backslash

41:32.000 --> 41:34.000
D für digit.

41:34.000 --> 41:36.000
Und da ist ein Fragezeichen dahinter.

41:36.000 --> 41:38.000
Das ist optional.

41:38.000 --> 41:40.000
Und wenn ich jetzt Match verwende,

41:40.000 --> 41:42.000
dann kommt da Test 1

41:42.000 --> 41:44.000
und Test 2 raus, wenn das mein String

41:44.000 --> 41:46.000
ist. Wenn ich jetzt aber Match All

41:46.000 --> 41:48.000
verwende mit diesen Klammern

41:48.000 --> 41:50.000
für e und st, dann kommt raus

41:50.000 --> 41:52.000
Test 1, e, st

41:52.000 --> 41:54.000
1 und 1.

41:54.000 --> 41:56.000
Genau.

41:56.000 --> 41:58.000
Weil er dir die Gruppen rauspickt, diese

41:58.000 --> 42:00.000
geklammerten Dinger. Ah, das sind Gruppen.

42:00.000 --> 42:02.000
Das ist nicht optional, das sind Gruppen.

42:02.000 --> 42:04.000
Genau, optional ist halt das Fragezeichen

42:04.000 --> 42:06.000
mit den Runden. Klammern sind halt die Gruppen.

42:06.000 --> 42:08.000
Und das Match All macht halt

42:08.000 --> 42:10.000
gib mir halt die ganzen Gruppen, die da drin gematched sind.

42:10.000 --> 42:12.000
Das normale Match ist ja nur

42:12.000 --> 42:14.000
Pastas ja oder nein.

42:14.000 --> 42:16.000
Und du wirst ja normalerweise exec verwenden, um

42:16.000 --> 42:18.000
sozusagen das zu machen.

42:18.000 --> 42:20.000
Parse mir aus diesen String diese und jenen

42:20.000 --> 42:22.000
Parts raus. Und das Match All

42:22.000 --> 42:24.000
macht das halt eben in der etwas zivilisierteren

42:24.000 --> 42:26.000
Variante, dass du halt diesen iterator

42:26.000 --> 42:28.000
bekommst, kannst du eine Voraufschleife reinschmeißen.

42:28.000 --> 42:30.000
So verstehe ich das.

42:30.000 --> 42:32.000
Okay.

42:32.000 --> 42:34.000
Ich kann dir jetzt nicht genau sagen, wo, aber ich

42:34.000 --> 42:36.000
würde mal annehmen das.

42:36.000 --> 42:38.000
Ja, ich nicht.

42:40.000 --> 42:42.000
Bin glücklich ohne ausgekommen.

42:42.000 --> 42:44.000
Habe jetzt auch nicht das Gefühl, oh, da muss

42:44.000 --> 42:46.000
jetzt was refactorn. Nee, gar nicht.

42:46.000 --> 42:48.000
Nee, also reguläre Ausdrücke ist auch so was

42:48.000 --> 42:50.000
wie so ein Proxy. Das ist halt echt so eine

42:50.000 --> 42:52.000
sehr gute, schnelle Lösung, die dann halt

42:52.000 --> 42:54.000
auch mal zum Problem auswachsen kann.

42:54.000 --> 42:56.000
Ja, ich glaube, mein Highlight an

42:56.000 --> 42:58.000
regularen Expressions war,

42:58.000 --> 43:00.000
nee, ich glaube, wenn ich bei dir es code

43:00.000 --> 43:02.000
machen möchte, wenn ich jetzt einen Refactoring

43:02.000 --> 43:04.000
machen möchte, zum Beispiel habe ich grad

43:04.000 --> 43:06.000
mir spezielle Design-Token,

43:06.000 --> 43:08.000
Custom Properties, CSS

43:08.000 --> 43:10.000
Variablen erstellt. Und ich wollte

43:10.000 --> 43:12.000
so eine bestimmte Verknüpfung, die ich immer

43:12.000 --> 43:14.000
habe bei Tabling-Klassen. Das ist immer so ein

43:14.000 --> 43:16.000
Background

43:16.000 --> 43:18.000
gray background white,

43:18.000 --> 43:20.000
aber im Dark Mode background gray

43:20.000 --> 43:22.000
900 und schon dessen habe ich mir so einen

43:22.000 --> 43:24.000
Namen dafür erstellt und wollte ihn überall

43:24.000 --> 43:26.000
replacen. Ist natürlich das Problem, dass ich

43:26.000 --> 43:28.000
nicht immer durch die automatische Sortierung

43:28.000 --> 43:30.000
bin. Es ist nicht immer so background-farbe

43:30.000 --> 43:32.000
und dark background-farbe, sondern ich glaube

43:32.000 --> 43:34.000
so alle Attribute, alle CSS-Klassen

43:34.000 --> 43:36.000
und dann kommen alle Dark-Klassen

43:36.000 --> 43:38.000
und so weiter und dann kommen alle

43:38.000 --> 43:40.000
Focus-Klassen. Und da muss ich, das ist das

43:40.000 --> 43:42.000
einzige, was ich dann mache, dass ich sage,

43:42.000 --> 43:44.000
ich suche einen String, das fängt an

43:44.000 --> 43:46.000
mit dieser Klasse, dann kommt

43:46.000 --> 43:48.000
irgendetwas dazwischen und dann kommt

43:48.000 --> 43:50.000
die Dark-Klasse dazu und ich möchte

43:50.000 --> 43:52.000
das ersetzen, aber den Rest natürlich

43:52.000 --> 43:54.000
nicht rauswerfen.

43:54.000 --> 43:56.000
Mehr mache ich nicht.

43:56.000 --> 43:58.000
Da hätte ich da eine Stunde dran gesetzt,

43:58.000 --> 44:00.000
aber ich bin ganz stolz darauf,

44:00.000 --> 44:02.000
dass ich stattdessen 40 Minuten

44:02.000 --> 44:04.000
versucht habe, die richtige

44:04.000 --> 44:06.000
Rackings zu finden.

44:06.000 --> 44:08.000
Naja, sagen wir mal so, ich glaube

44:08.000 --> 44:10.000
Rack-Ax ist so ein,

44:10.000 --> 44:12.000
also wenn man das ausrechnen

44:12.000 --> 44:14.000
gut kann, ist das halt, kann das halt

44:14.000 --> 44:16.000
echt so in manchen Situationen

44:16.000 --> 44:18.000
der große Power-Move sein.

44:18.000 --> 44:20.000
Total. Ich will jetzt nicht behaupten,

44:20.000 --> 44:22.000
dass ich das kann, aber wenn man halt

44:22.000 --> 44:24.000
eben wirklich mal so ein Komplex ist,

44:24.000 --> 44:26.000
was aus diesem String daraus friemelnd

44:26.000 --> 44:28.000
ding macht und wirklich dann auch mal

44:28.000 --> 44:30.000
sich einfach nur einmal drauf schafft,

44:30.000 --> 44:32.000
wie das irgendwie so ist mit irgendwie so

44:32.000 --> 44:34.000
Look-A-Hats und Zeug, also der ganze

44:34.000 --> 44:36.000
etwa-anste Kram.

44:36.000 --> 44:38.000
Und dann vielleicht auch mal den Schritt weiter geht,

44:38.000 --> 44:40.000
kann man es halt auch konvinient machen,

44:40.000 --> 44:42.000
weil gerade so diese Gruppen-Matching

44:42.000 --> 44:44.000
mit den runden Klammern, da geht ja normalerweise

44:44.000 --> 44:46.000
so, dass du dann halt irgendwelche Indizes rausbekommst,

44:46.000 --> 44:48.000
so die erste, zweite und dritte Gruppe,

44:48.000 --> 44:50.000
aber den Dinger kann man ja auch Namen geben.

44:50.000 --> 44:52.000
Und dann kriegst du da halt eben aus deinem

44:52.000 --> 44:54.000
String daraus und wenn man halt irgendwie so

44:54.000 --> 44:56.000
diese Dinger dann mal entlockt, dann macht man

44:56.000 --> 44:58.000
irgendwie so einen regulären Ausdruck,

44:58.000 --> 45:00.000
der ist so lang ist der,

45:00.000 --> 45:02.000
aber der funktioniert halt eben auch einfach.

45:02.000 --> 45:04.000
Es kann halt echt so,

45:04.000 --> 45:06.000
im Editor, klar, sicherlich, aber auch so manches

45:06.000 --> 45:08.000
Programm, wo halt eben da,

45:08.000 --> 45:10.000
schreib halt in einem String in so eine

45:10.000 --> 45:12.000
Micro-DSL-Werternutzer rein was du haben willst

45:12.000 --> 45:14.000
und dann fummelt es das schon raus.

45:14.000 --> 45:16.000
Das kann echt so ein Power-Move werden.

45:16.000 --> 45:18.000
Also, gibt ja dieses schöne Buch,

45:18.000 --> 45:20.000
so Regular Expressions von O'Reilly,

45:20.000 --> 45:22.000
das habe ich mal gelesen, also die ersten 20 Seiten.

45:22.000 --> 45:24.000
Und dann habe ich so gesagt,

45:24.000 --> 45:26.000
ah, okay, das ist keine schwarze Magie, das kann man verstehen.

45:26.000 --> 45:28.000
Dann habe ich es nicht wieder angefasst,

45:28.000 --> 45:30.000
aber das hat halt eben gereicht, um mir dann so

45:30.000 --> 45:32.000
im Laufe der nächsten Zeit das irgendwann drauf zu schaffen.

45:32.000 --> 45:34.000
Und wenn da draußen irgendwer ist, der oder die,

45:34.000 --> 45:36.000
immer noch sagt, reguläre Ausdrücke, schwarze Magie.

45:36.000 --> 45:38.000
Nee, ist es nicht. 20 Seiten von diesem Buch lesen.

45:38.000 --> 45:40.000
Das reicht.

45:40.000 --> 45:42.000
Sehr gut.

45:42.000 --> 45:44.000
Das nächste, ich weiß es nicht, ob es ein

45:44.000 --> 45:46.000
absoluter Power-Move ist, aber ich finde es cool,

45:46.000 --> 45:48.000
weil ich das von anderen Programmiersprachen

45:48.000 --> 45:50.000
so gewohnt war, ist Logical Assignment.

45:50.000 --> 45:52.000
Das heißt, ich kann jetzt

45:52.000 --> 45:54.000
mit Pipe-Pipe ist gleich

45:54.000 --> 45:56.000
Werte zu weisen,

45:56.000 --> 45:58.000
sollten sie davor noch

45:58.000 --> 46:00.000
undefined Fallzieh gewesen sein.

46:00.000 --> 46:02.000
Zum Beispiel kann ich jetzt sagen,

46:02.000 --> 46:04.000
wenn ich einen Objekt habe hier in dem Beispiel,

46:04.000 --> 46:06.000
das ist ein Objekt heißt A,

46:06.000 --> 46:08.000
ziemlich guter Name für so ein Objekt.

46:08.000 --> 46:10.000
Kunst A.

46:10.000 --> 46:12.000
Equals Duration 50,

46:12.000 --> 46:14.000
Title Empty String.

46:14.000 --> 46:16.000
Und jetzt kann ich schreiben

46:16.000 --> 46:18.000
A.Duration,

46:18.000 --> 46:20.000
Pipe-Pipe ist gleich, also oder oder ist gleich

46:20.000 --> 46:22.000
10, dann kommt 50

46:22.000 --> 46:24.000
raus, weil die Duration war ja schon vorher

46:24.000 --> 46:26.000
gesetzt, also bleibst einfach bei 50.

46:26.000 --> 46:28.000
Und wenn ich das Ganze mit dem A.

46:28.000 --> 46:30.000
Title mache und sage,

46:30.000 --> 46:32.000
jetzt kommt da ein String rein,

46:32.000 --> 46:34.000
dann kommt am Ende dieser String rein,

46:34.000 --> 46:36.000
weil es davor ja ein Falsie Value war.

46:36.000 --> 46:38.000
Und das habe ich,

46:38.000 --> 46:40.000
das kannte ich vor,

46:40.000 --> 46:42.000
vor einigen, vielen

46:42.000 --> 46:44.000
Jahren so ungefähr,

46:44.000 --> 46:46.000
8, nicht mehr sicher.

46:46.000 --> 46:48.000
Bei Ruby,

46:48.000 --> 46:50.000
dass ich das immer geschrieben hatte.

46:50.000 --> 46:52.000
Ja, der gemeine

46:52.000 --> 46:54.000
JavaScriptler hätte geschrieben

46:54.000 --> 46:56.000
A.Duration

46:56.000 --> 46:58.000
gleich A.Duration oder

46:58.000 --> 47:00.000
Ja, deswegen sagen absolut

47:00.000 --> 47:02.000
oder geiler PowerMove ist nicht,

47:02.000 --> 47:04.000
aber man spart halt ein paar Zeichen

47:04.000 --> 47:06.000
und auf der anderen Seite kann man argumentieren,

47:06.000 --> 47:08.000
aber was ist jetzt mit der Leserbarkeit,

47:08.000 --> 47:10.000
weil was ist jetzt der Wert davon,

47:10.000 --> 47:12.000
dass ich mir jetzt ungefähr 10 Zeichen gespart habe,

47:12.000 --> 47:14.000
aber vielleicht kennen viele Leute

47:14.000 --> 47:16.000
diese Schreibweise sind tags noch nicht

47:16.000 --> 47:18.000
oder mögen sie nicht.

47:18.000 --> 47:20.000
Und dann geht es wieder los mit Code Reviews,

47:20.000 --> 47:22.000
dass da einer sagt, das könnte man doch hier so schreiben

47:22.000 --> 47:24.000
und die andere Person sagt,

47:24.000 --> 47:26.000
nee, ich will es aber lieber so schreiben,

47:26.000 --> 47:28.000
weil ich finde meinen Style cooler

47:28.000 --> 47:30.000
und dann ist man mit Code Review blockiert wegen nichts.

47:30.000 --> 47:32.000
Also ich finde es cool.

47:32.000 --> 47:34.000
Ich würde aber auch immer dazu tendieren,

47:34.000 --> 47:36.000
den Streit aus dem Weg zu gehen

47:36.000 --> 47:38.000
und zu sagen, vielleicht hält man es auch einfach beim Alten

47:38.000 --> 47:40.000
und sagt halt eben, was du gerade meintest,

47:40.000 --> 47:42.000
wie cool ist es, Titel oder oder

47:42.000 --> 47:44.000
neuer String.

47:44.000 --> 47:46.000
Ja, das ist definitiv nicht irgendwie was,

47:46.000 --> 47:48.000
was einen großen Kampf wert ist.

47:48.000 --> 47:50.000
Nee.

47:50.000 --> 47:52.000
Ich finde halt,

47:52.000 --> 47:54.000
also ich nutze die halt eher sparser

47:54.000 --> 47:56.000
und das ist jetzt das absolute Nichtargument,

47:56.000 --> 47:58.000
damit kann ich halt auch im Code Review

47:58.000 --> 48:00.000
den großen Blockator geben.

48:00.000 --> 48:02.000
Also so rein, so vom Aussehen her

48:02.000 --> 48:04.000
finde ich, es macht den Coach schon so ein bisschen neusey,

48:04.000 --> 48:06.000
so ein Operator, der aus 3 Teilen besteht.

48:06.000 --> 48:08.000
Ja, ich bin es halt gewohnt.

48:08.000 --> 48:10.000
So das meine ich, ich bin damit so auch,

48:10.000 --> 48:12.000
bin damit mal aufgewachsen.

48:12.000 --> 48:14.000
Von daher schaut es für mich gar nicht komisch aus.

48:16.000 --> 48:18.000
Ich kann zum Beispiel keinen Pfeifen schreiben,

48:18.000 --> 48:20.000
weil ich schon bei der IF-Abfrage

48:20.000 --> 48:22.000
scheitere mit irgendwelchen Doppelpunkten

48:22.000 --> 48:24.000
oder sowas.

48:24.000 --> 48:26.000
Bin aber trotzdem, ich würde immer unterschreiben,

48:26.000 --> 48:28.000
dann schrat man lieber das Leserliche.

48:28.000 --> 48:30.000
Die Sache, mit der ich

48:30.000 --> 48:32.000
auf ein bisschen,

48:32.000 --> 48:34.000
die eine Sache, die ich wirklich persönlich nicht so toll finde,

48:34.000 --> 48:36.000
ist dieses, was es in JavaScript gibt,

48:36.000 --> 48:38.000
mit,

48:38.000 --> 48:40.000
dass ich mir die IF-Abfrage

48:40.000 --> 48:42.000
und die InDention danach

48:42.000 --> 48:44.000
spare,

48:44.000 --> 48:46.000
wenn ich sage, irgendein Boolean Value,

48:46.000 --> 48:48.000
zum Beispiel

48:48.000 --> 48:50.000
ist enabled und

48:50.000 --> 48:52.000
und Funktionsaufruf.

48:52.000 --> 48:54.000
Und das,

48:54.000 --> 48:56.000
das ist halt schon

48:56.000 --> 48:58.000
so trufi-mäßig

48:58.000 --> 49:00.000
und das funktioniert in vielen anderen Programmen,

49:00.000 --> 49:02.000
wir sprachen nicht

49:02.000 --> 49:04.000
immer sagen, können wir nicht einfach

49:04.000 --> 49:06.000
if, is enabled, klammer auf,

49:06.000 --> 49:08.000
andere klammer zu,

49:08.000 --> 49:10.000
andere klammer auf, Funktionsaufruf

49:10.000 --> 49:12.000
und dann halt wieder raus in Dention.

49:12.000 --> 49:14.000
Da bin ich immer auf der Sache.

49:14.000 --> 49:16.000
Ich finde es einfach leserlicher.

49:16.000 --> 49:18.000
Ja, da wäre ich auch

49:18.000 --> 49:20.000
auf dem Zug.

49:20.000 --> 49:22.000
Es dauert einfach länger, bis ich capiere,

49:22.000 --> 49:24.000
dass da quasi ein if drumrum ist.

49:24.000 --> 49:26.000
Wenn du es kapierst,

49:26.000 --> 49:28.000
im schlimmsten Fall landest du in so einer Go-to-Fail-Situation

49:28.000 --> 49:30.000
und glaubst du, das passt schon und das passt halt nicht.

49:30.000 --> 49:32.000
Ja.

49:32.000 --> 49:34.000
Das ist auch ein if überliste halt nicht.

49:34.000 --> 49:36.000
Ansonsten ist meine goldene Regel,

49:36.000 --> 49:38.000
wenn das da jetzt schon irgendwie steht

49:38.000 --> 49:40.000
und ich muss da was dran tun,

49:40.000 --> 49:42.000
dann würde ich das an sich einfach auch nicht anfassen

49:42.000 --> 49:44.000
und nicht refactern.

49:44.000 --> 49:46.000
Weil ich dann, dann kommt wieder

49:46.000 --> 49:48.000
im Code-Review wieder.

49:48.000 --> 49:50.000
Weil da hast du eigentlich was anderes geändert, das könnte live gehen

49:50.000 --> 49:52.000
und das ist eigentlich ein super tolles Feature

49:52.000 --> 49:54.000
und dann geht wieder der Streit in den Puller,

49:54.000 --> 49:56.000
das ist los und die Leute sind aufgehalten,

49:56.000 --> 49:58.000
weil ich mag den Style lieber

49:58.000 --> 50:00.000
und ja, wir haben doch schon so viele Linter-Reviews

50:00.000 --> 50:02.000
und dafür gibt es halt noch keine.

50:02.000 --> 50:04.000
Ja, das ist halt schwer.

50:04.000 --> 50:06.000
Man kann halt leider nicht wirklich jede

50:06.000 --> 50:08.000
Unstimmigkeit auf diesem Planeten mit Linter-Regeln.

50:08.000 --> 50:10.000
Ja.

50:10.000 --> 50:12.000
Und dann ja, so Forsake of Consistency

50:12.000 --> 50:14.000
sage ich dann eigentlich auch gerne,

50:14.000 --> 50:16.000
aber dann auf der anderen Seite,

50:16.000 --> 50:18.000
jetzt ist es schon so, jetzt mach mal weiter.

50:18.000 --> 50:20.000
Ja.

50:20.000 --> 50:22.000
Das ist sehr vernünftig, das ist die erwachsenen Variante

50:22.000 --> 50:24.000
zu sagen.

50:24.000 --> 50:26.000
Bin ich jetzt alt, bin ich offiziell jetzt erwachsen.

50:26.000 --> 50:28.000
Erwachsen und alt sind glaube ich

50:28.000 --> 50:30.000
zwei unterschiedliche Konzepte.

50:30.000 --> 50:32.000
Ja, stimmt.

50:32.000 --> 50:34.000
Möchte ich jedenfalls glauben.

50:34.000 --> 50:36.000
Ja.

50:36.000 --> 50:38.000
Okay, hey, pass auf hier.

50:38.000 --> 50:40.000
Das nächste, promise.any,

50:40.000 --> 50:42.000
hat nichts mit Typescript zu tun.

50:42.000 --> 50:44.000
Ah, any.

50:44.000 --> 50:46.000
Ja.

50:46.000 --> 50:48.000
Ja, musste ich mich gerade nochmal

50:48.000 --> 50:50.000
per MDN dran erinnern, was das eigentlich

50:50.000 --> 50:52.000
macht.

50:52.000 --> 50:54.000
Nein, das finde ich, also ich hab's

50:54.000 --> 50:56.000
auch noch nicht geschrieben,

50:56.000 --> 50:58.000
aber ich glaub, weil es das damals noch nicht gab

50:58.000 --> 51:00.000
und ich hatte dann andere Varianten

51:00.000 --> 51:02.000
Workarounds, das zu schreiben.

51:02.000 --> 51:04.000
Ich find's schon ziemlich praktisch, du kannst

51:04.000 --> 51:06.000
halt mehrere promises abfeuern, hast du wieder

51:06.000 --> 51:08.000
in deinem Erratingens

51:08.000 --> 51:10.000
als Parameter

51:10.000 --> 51:12.000
bekommst du auch nur ein Promise zurück

51:12.000 --> 51:14.000
und das ist dann aber quasi

51:14.000 --> 51:16.000
fertig, wenn irgendeines davon

51:16.000 --> 51:18.000
fertig ist. Ich bin mir hier nicht

51:18.000 --> 51:20.000
hundertprozentig sicher, ob das

51:20.000 --> 51:22.000
successful sein muss, ob es auf erstes

51:22.000 --> 51:24.000
oder einfach nur auf irgendeines.

51:26.000 --> 51:28.000
Der war doch

51:28.000 --> 51:30.000
successful, weil irgendeines war ja

51:30.000 --> 51:32.000
all settled.

51:32.000 --> 51:34.000
Nee, all settled war,

51:34.000 --> 51:36.000
wenn alle fertig sind. Gott, ich weiß es auch nicht.

51:36.000 --> 51:38.000
Also das Ding ist, der Use Case, den du beschreibst,

51:38.000 --> 51:40.000
das ist auch immer der, wenn ich so sage,

51:40.000 --> 51:42.000
ja, ja,

51:42.000 --> 51:44.000
schon bei promise,

51:44.000 --> 51:46.000
was war das noch? Race, genau.

51:46.000 --> 51:48.000
Promise.race ist ja ein ganz alter Kamerad so.

51:48.000 --> 51:50.000
Alle promises rennen los und das erste,

51:50.000 --> 51:52.000
wenn es wieder Erfolg oder Fehlschlag ist,

51:52.000 --> 51:54.000
bestimmt mit seinem Erfolg oder Fehlschlag,

51:54.000 --> 51:56.000
was das resultierende Promise dann wird.

51:56.000 --> 51:58.000
Und dann sagen die Leute immer, ah, super

51:58.000 --> 52:00.000
Sache, ich kann also irgendwie so sagen, mach

52:00.000 --> 52:02.000
Request nach A und Request nach B

52:02.000 --> 52:04.000
und der, der zuerst was wird, den nehme ich

52:04.000 --> 52:06.000
dann und dann sage ich eben, ja okay, aber

52:06.000 --> 52:08.000
wenn du jetzt den Request für A bekommen hast,

52:08.000 --> 52:10.000
dann musst du ja daran denken, den für B

52:10.000 --> 52:12.000
abzubrechen. Ja, das ist wahr.

52:12.000 --> 52:14.000
Und das wird

52:14.000 --> 52:16.000
dann selten bedacht und noch seltener

52:16.000 --> 52:18.000
gemacht, würde ich behaupten. Ja.

52:18.000 --> 52:20.000
Das ist sinnvoller ist ein Promise als

52:20.000 --> 52:22.000
eine Art Rapper-Objekt, um einen Wert

52:22.000 --> 52:24.000
zu verstehen, der dann halt irgendwann errechnet

52:24.000 --> 52:26.000
wird. Und so diese ganzen

52:26.000 --> 52:28.000
Controller-Management-Geschichten, da sind wir wieder bei

52:28.000 --> 52:30.000
unseren Rejections oder halt auch dieses

52:30.000 --> 52:32.000
Bündeln von Daten-Streams

52:32.000 --> 52:34.000
gleichsam, ist, glaube ich, mit denen nicht so

52:34.000 --> 52:36.000
gut gemacht. Ich glaube, dazu wäre dann wirklich

52:36.000 --> 52:38.000
ein observable oder was ähnliches sinnvoller,

52:38.000 --> 52:40.000
weil die halt eben lazy sind, weil dann halt

52:40.000 --> 52:42.000
eben der Request auf den keiner mehr wartet,

52:42.000 --> 52:44.000
dann auch automatisch abgebaut wird.

52:44.000 --> 52:46.000
Aber guter Punkt, dass du gerade das mit

52:46.000 --> 52:48.000
was du hast, weil ich jetzt gerade dachte,

52:48.000 --> 52:50.000
Moment, was jetzt eigentlich raised, was

52:50.000 --> 52:52.000
eigentlich Annie, und das Sinnvollere

52:52.000 --> 52:54.000
bei Annie, meiner Meinung nach, ist,

52:54.000 --> 52:56.000
du bekommst

52:56.000 --> 52:58.000
das Successful zurück, wenn jetzt eben

52:58.000 --> 53:00.000
Annie irgendeinst davon successful ist,

53:00.000 --> 53:02.000
aber du bekommst es nur dann rejected,

53:02.000 --> 53:04.000
wenn, glaube ich, alle Promises

53:04.000 --> 53:06.000
rejected sind. Nicht irgendein erstes.

53:06.000 --> 53:08.000
Ja, also okay,

53:08.000 --> 53:10.000
irgendein von den Promises muss ein Erfolg

53:10.000 --> 53:12.000
werden, ansonsten,

53:12.000 --> 53:14.000
das ist halt schief, aber ich mache hier drei

53:14.000 --> 53:16.000
Promises.

53:16.000 --> 53:18.000
Ja.

53:18.000 --> 53:20.000
Ja.

53:20.000 --> 53:22.000
Ich verwende ziemlich wenig von den

53:22.000 --> 53:24.000
Promises immer, wenn es halt irgendwie so

53:24.000 --> 53:26.000
mehr macht, als mach Fetch, gib mir

53:26.000 --> 53:28.000
ein Datum, dass ich dann paarse

53:28.000 --> 53:30.000
und gut ist.

53:30.000 --> 53:32.000
Dann denke ich halt immer, entweder muss

53:32.000 --> 53:34.000
da irgendwie was drum gerappt werden, was das

53:34.000 --> 53:36.000
entweder wegabstrahiert, oder ich brauche

53:36.000 --> 53:38.000
gleich was anderes wie ein observable, und

53:38.000 --> 53:40.000
dann habe ich ein ganz anderes Problem.

53:40.000 --> 53:44.000
Okay, aber gemäß uns auf Produkstechnik,

53:44.000 --> 53:46.000
okay, dann geben wir den mal

53:46.000 --> 53:48.000
einen Daumen hoch.

53:48.000 --> 53:50.000
Bei dem nächsten

53:50.000 --> 53:52.000
fällt mir noch nicht mal Newscase ein.

53:52.000 --> 53:54.000
Keine Ahnung.

53:54.000 --> 53:56.000
Also, wir reden einfach... Halleluja!

53:56.000 --> 53:58.000
Halleluja, echt?

53:58.000 --> 54:00.000
Area Prototype Add.

54:00.000 --> 54:02.000
Also, ich erkläre erst, damit jetzt auch

54:02.000 --> 54:04.000
alle gleich anderen aufschreien können,

54:04.000 --> 54:06.000
wow, da habe ich schon ewig darauf gewartet,

54:06.000 --> 54:08.000
worum geht es, wenn ich jetzt

54:08.000 --> 54:10.000
meine schönen, eckigen Klammern um mit

54:10.000 --> 54:12.000
dem Index auf ein Item darauf

54:12.000 --> 54:14.000
zuzugreifen, dann geht es ja quasi,

54:14.000 --> 54:16.000
dann mache ich ja quasi, wenn ich jetzt

54:16.000 --> 54:18.000
eins von hinten bekommen will, schreibe

54:18.000 --> 54:20.000
ich ja dann rein, area length minus 1,

54:20.000 --> 54:22.000
hat schon immer so gut funktioniert.

54:22.000 --> 54:24.000
Stattdessen gibt es jetzt Add, wo ich auch

54:24.000 --> 54:26.000
negative Werte reinschreiben kann, und der

54:26.000 --> 54:28.000
geht dann von hinten nach vorne. Was es

54:28.000 --> 54:30.000
nicht tut, das habe ich extra ausprobiert,

54:30.000 --> 54:32.000
ich kann nicht einen größeren Wert

54:32.000 --> 54:34.000
angeben, und der loop nicht fuhr, also

54:34.000 --> 54:36.000
wenn ich jetzt ein area habe mit fünf

54:36.000 --> 54:38.000
Händen, und ich schreibe Acht,

54:38.000 --> 54:40.000
dann bekomme ich nicht das Dritt daraus,

54:40.000 --> 54:42.000
ich bekomme Andefind.

54:42.000 --> 54:44.000
Das hätte ich auch sehr weird

54:44.000 --> 54:46.000
gefunden. Ja, ich wollte es mal ausprobieren.

54:46.000 --> 54:48.000
Das ist gut, weil

54:48.000 --> 54:50.000
wir haben ja gelernt, wenn wir es nicht

54:50.000 --> 54:52.000
ausprobieren, gibt es keine lustigen

54:52.000 --> 54:54.000
Klammermeldung. Das sind schon etwas, ja.

54:54.000 --> 54:56.000
Ja, aber ich meine, die negativen

54:56.000 --> 54:58.000
Indizes, das ist auch großartig.

54:58.000 --> 55:00.000
Ja, okay.

55:00.000 --> 55:02.000
Ah, es hat doch schon immer

55:02.000 --> 55:04.000
funktioniert mit area length minus

55:04.000 --> 55:06.000
1. Ja,

55:06.000 --> 55:08.000
wenn du halt nicht permanent dich damit

55:08.000 --> 55:10.000
rumfuhr werken musst.

55:10.000 --> 55:12.000
Außerdem natürlich auch, die Länge ist

55:12.000 --> 55:14.000
natürlich auch ein Faktor, wenn dein

55:14.000 --> 55:16.000
area jetzt irgendwie customers filtert

55:16.000 --> 55:18.000
bei, keine Ahnung, place of birth

55:18.000 --> 55:20.000
oder irgendwie sowas, wenn das dein area ist,

55:20.000 --> 55:22.000
dann musst du ja schreiben, um dann das

55:22.000 --> 55:24.000
letzte rauszukriegen, customers filtert

55:24.000 --> 55:26.000
bei place of birth, eckige Klammern,

55:26.000 --> 55:28.000
customers filtert bei place of birth

55:28.000 --> 55:30.000
dort length minus 1, und dann ist

55:30.000 --> 55:32.000
irgendwie dein Bildschirm zu Ende,

55:32.000 --> 55:34.000
ganz so toll.

55:34.000 --> 55:36.000
Ja, das ist super.

55:36.000 --> 55:38.000
Ich finde es großartig,

55:38.000 --> 55:40.000
kriegt einen Daumen.

55:40.000 --> 55:42.000
So, und beim,

55:42.000 --> 55:44.000
so, jetzt haben wir top level await.

55:44.000 --> 55:46.000
Verstehe ich hier irgendwie nicht,

55:46.000 --> 55:48.000
worum es geht. Ich kenne await.

55:48.000 --> 55:50.000
Aber was ist denn top level await?

55:50.000 --> 55:52.000
Naja, das ist nicht in der Essung Funktion stehen muss.

55:52.000 --> 55:54.000
Hä? Das gibt's?

55:54.000 --> 55:56.000
In Modulen, ja.

55:56.000 --> 55:58.000
In Modulen, ah ja.

55:58.000 --> 56:00.000
Ne? Weil, also

56:00.000 --> 56:02.000
das Problem ist ja, du kannst ja, du musst ja

56:02.000 --> 56:04.000
await in der Assumkronen Funktion haben.

56:04.000 --> 56:06.000
Ach so, ich kann await importen.

56:08.000 --> 56:10.000
await importen?

56:10.000 --> 56:12.000
Import.

56:12.000 --> 56:14.000
Import, ja, entweder per import

56:14.000 --> 56:16.000
oder halt eben so bis in einem script type module

56:16.000 --> 56:18.000
drin. Ja. Weil, das Ding ist ja,

56:18.000 --> 56:20.000
es kommt ja immer wieder zurück,

56:20.000 --> 56:22.000
Oper erzählt vom Krieg, das kommt ja immer wieder zurück

56:22.000 --> 56:24.000
auf document write. Daran

56:24.000 --> 56:26.000
scheitert ja alles.

56:26.000 --> 56:28.000
Weil document write

56:28.000 --> 56:30.000
im script füttert ja den html-Paser

56:30.000 --> 56:32.000
mit neuem input zu dem Zeitpunkt, wo das script

56:32.000 --> 56:34.000
gepasst wird.

56:34.000 --> 56:36.000
Das heißt, deswegen blockieren ja normales

56:36.000 --> 56:38.000
scripts den html-Pasern, deswegen sollte man die entweder

56:38.000 --> 56:40.000
nicht benutzen oder ans Ende der Seite verfrachten.

56:40.000 --> 56:42.000
Das Problem ist halt, wenn du document write

56:42.000 --> 56:44.000
hast, wenn das als feature existiert, kannst

56:44.000 --> 56:46.000
du nicht top level await haben, weil ja notwendiger

56:46.000 --> 56:48.000
Weise await ein promise

56:48.000 --> 56:50.000
auspackt, sprich, es gibt ein trip

56:50.000 --> 56:52.000
über die micro task queue. Das heißt,

56:52.000 --> 56:54.000
der html-Paser muss weiterlaufen

56:54.000 --> 56:56.000
und das script muss also in chron ausgeführt werden.

56:56.000 --> 56:58.000
Du kannst nicht beides haben.

56:58.000 --> 57:00.000
Und weil in Modulen document write verboten

57:00.000 --> 57:02.000
ist und diese Module immer asengrunden sind,

57:02.000 --> 57:04.000
kann man da ein ganz anderes Ausführungsmodell

57:04.000 --> 57:06.000
machen unter anderem mit top level await.

57:06.000 --> 57:08.000
Und das ist großartig.

57:10.000 --> 57:12.000
Das ist großartig.

57:12.000 --> 57:14.000
Ich brauche das jetzt nicht in meinem Alter,

57:14.000 --> 57:16.000
aber mein Ansatz ist mehr so der,

57:16.000 --> 57:18.000
Erzähl, erklär irgendwelchen Leuten auf

57:18.000 --> 57:20.000
möglichst effizienter Art und Weise, in irgendwie

57:20.000 --> 57:22.000
so einem Webtec Workshop, moderne Webentwicklung.

57:22.000 --> 57:24.000
So, je mehr Ausnahmen du hast

57:24.000 --> 57:26.000
umso schwieriger ist es. Und ich habe ja schon

57:26.000 --> 57:28.000
vor sehr langer Zeit, bin ich dazu

57:28.000 --> 57:30.000
übergegangen zu sagen, script ohne type module

57:30.000 --> 57:32.000
ist falsch.

57:32.000 --> 57:34.000
Normales script

57:34.000 --> 57:36.000
ich will jetzt nicht päpslicher sein,

57:36.000 --> 57:38.000
als der Papst, es gibt selber da

57:38.000 --> 57:40.000
es gibt

57:40.000 --> 57:42.000
okay, aber im Allgemeinen,

57:42.000 --> 57:44.000
ist script type module der einzig wahre Weg

57:44.000 --> 57:46.000
und wenn man das macht, kann man halt, da muss man halt

57:46.000 --> 57:48.000
über so kaum wie document write nichts erst sagen.

57:48.000 --> 57:50.000
Da muss man den strict mode gar nicht erst erwähnen

57:50.000 --> 57:52.000
und da muss man gar nicht erst sagen, await

57:52.000 --> 57:54.000
ist halt so ein Ding, das benutzt du.

57:54.000 --> 57:56.000
Ender aus, mit ihm aus.

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

57:58.000 --> 58:00.000
Kannst du genauso gut reden

58:00.000 --> 58:02.000
über temporal,

58:02.000 --> 58:04.000
dass die Probleme von

58:04.000 --> 58:06.000
date ersetzen möchte?

58:06.000 --> 58:08.000
Darüber kann ich nur reden,

58:08.000 --> 58:10.000
ist eine extrem gute und überfällige

58:10.000 --> 58:12.000
Geschichte,

58:12.000 --> 58:14.000
habe ich noch nie benutzt.

58:14.000 --> 58:16.000
Wer da mal reinschauen möchte,

58:16.000 --> 58:18.000
die Seite, die auf der ich gerne ganz

58:18.000 --> 58:20.000
lese, weil die ist auch ganz witzig,

58:20.000 --> 58:22.000
die Seite von TC39

58:22.000 --> 58:24.000
proposal temporal

58:24.000 --> 58:26.000
beziehungsweise, ich sag's mal so,

58:26.000 --> 58:28.000
wer da draußen das Glück hatte,

58:28.000 --> 58:30.000
noch nicht allzu viel mit date zu arbeiten,

58:30.000 --> 58:32.000
da passieren witzige Dinge drauf

58:32.000 --> 58:34.000
und temporal sollte das dann

58:34.000 --> 58:36.000
doch eigentlich fixen,

58:36.000 --> 58:38.000
basiert, glaub ich, auf dem

58:38.000 --> 58:40.000
namespace von math und ist dann korrekt.

58:42.000 --> 58:44.000
Ja, wir brauchen halt halt keine libraries mehr,

58:44.000 --> 58:46.000
aber heutzutage kannst du dich ja dem date-Objekt nicht nähren, ohne irgendwie

58:46.000 --> 58:48.000
date.fn oder so zu verwenden.

58:48.000 --> 58:50.000
Ja, bei mir ist es date.js.

58:52.000 --> 58:54.000
Was ist das?

58:54.000 --> 58:56.000
Date.js.

58:56.000 --> 58:58.000
Okay, ist das das neue Kuhle?

58:58.000 --> 59:00.000
Das ist schon seit 3 Jahren, glaub ich,

59:00.000 --> 59:02.000
das neue Kuhle von moment.js.

59:02.000 --> 59:04.000
Also nicht von moment.js,

59:04.000 --> 59:06.000
aber davon sind alle weggegangen aus Gründen,

59:06.000 --> 59:08.000
weil das dann noch nicht modular war

59:08.000 --> 59:10.000
und dann war es aber schon modular,

59:10.000 --> 59:12.000
weil wir waren, glaub ich, schon alle bei date.js.

59:12.000 --> 59:14.000
Das scheint die etwas schlankere

59:14.000 --> 59:16.000
Version zu sein.

59:16.000 --> 59:18.000
Also dann haben wir modular erweitert,

59:18.000 --> 59:20.000
wenn du sagen willst, du brauchst aber jetzt noch

59:20.000 --> 59:22.000
eine timezone Berechnung, dann nimmst du

59:22.000 --> 59:24.000
halt das timezone Pluckin noch mit rein.

59:24.000 --> 59:26.000
Was ist übrigens auch da draußen?

59:26.000 --> 59:28.000
Gibt es, würde ich auch wieder so immer

59:28.000 --> 59:30.000
ein bisschen als erstes nehmen,

59:30.000 --> 59:32.000
ist die Funktion to local date string

59:32.000 --> 59:34.000
oder so ähnlich,

59:34.000 --> 59:36.000
um das in die Browser Sprache

59:36.000 --> 59:38.000
einfach zu transferieren, ohne dass man

59:38.000 --> 59:40.000
jetzt ein Hiccat hat, wie dass man das

59:40.000 --> 59:42.000
richtige Format angeben muss, wie Datum

59:42.000 --> 59:44.000
und ähnliches, weil das kann ja pro Land

59:44.000 --> 59:46.000
sein. Wir in Deutschland haben vielleicht dieses

59:46.000 --> 59:48.000
tagtagpunktmonatmonatpunkt

59:48.000 --> 59:50.000
ja, ja, ja, ja, ja, was für uns

59:50.000 --> 59:52.000
das macht. Aber das ist ja in anderen

59:52.000 --> 59:54.000
Sprachen, würdest du das anders ausdrücken.

59:54.000 --> 59:56.000
Wir fangen jetzt bitte nicht an mit

59:56.000 --> 59:58.000
monatmonatpunkttagtag, also nee.

59:58.000 --> 01:00:00.000
Nee. Aber alles andere

01:00:00.000 --> 01:00:02.000
mag jetzt legitim und valid sein.

01:00:02.000 --> 01:00:04.000
Hä? Ja,

01:00:04.000 --> 01:00:06.000
ist halt die Frage, ob man das haben will,

01:00:06.000 --> 01:00:08.000
weil Browser Sprache muss ja nicht gleich

01:00:08.000 --> 01:00:10.000
Webseitsprache sein. Nee, das stimmt,

01:00:10.000 --> 01:00:12.000
aber das hast du ja bei der HTML-Validierung

01:00:12.000 --> 01:00:14.000
zum Beispiel auch. Wenn du die Browser Sprache

01:00:14.000 --> 01:00:16.000
hast, weil du hast eine englische Webseite,

01:00:16.000 --> 01:00:18.000
aber das ist ein Formular drin und da haben

01:00:18.000 --> 01:00:20.000
wir dieses Inputfeld und sollte größer 0 sein,

01:00:20.000 --> 01:00:22.000
dann hast du auch dastehen, du musst

01:00:22.000 --> 01:00:24.000
einen Wert größer

01:00:24.000 --> 01:00:26.000
gleich 1 angeben oder so was.

01:00:26.000 --> 01:00:28.000
Na gut.

01:00:28.000 --> 01:00:30.000
Okay, also aber Temporal würde ich mal sagen,

01:00:30.000 --> 01:00:32.000
wir wissen, was es ist, aber benutzt haben wir es noch nicht,

01:00:32.000 --> 01:00:34.000
wenn ich das richtig verstanden habe, oder?

01:00:34.000 --> 01:00:36.000
Nö. Weil wir noch auf

01:00:36.000 --> 01:00:38.000
dem Library treppen. Jupp.

01:00:38.000 --> 01:00:40.000
Genau.

01:00:40.000 --> 01:00:42.000
So, das nächste ist deshalb so geil wie

01:00:42.000 --> 01:00:44.000
.add,

01:00:44.000 --> 01:00:46.000
weil hier haben wir array

01:00:46.000 --> 01:00:48.000
find last.

01:00:48.000 --> 01:00:50.000
Ja,

01:00:50.000 --> 01:00:52.000
das ist jetzt meine handgeschriebene

01:00:52.000 --> 01:00:54.000
Implementierung davon sicherlich eines

01:00:54.000 --> 01:00:56.000
Tagesmal. Ja.

01:00:56.000 --> 01:00:58.000
Oder loadish oder so was Verwendungen.

01:00:58.000 --> 01:01:00.000
Ja,

01:01:00.000 --> 01:01:02.000
loadish ist auch so ein

01:01:02.000 --> 01:01:04.000
so ein Map und Set Verhinderer,

01:01:04.000 --> 01:01:06.000
finde ich.

01:01:06.000 --> 01:01:08.000
Meister, das kommt halt ja noch aus der Zeit,

01:01:08.000 --> 01:01:10.000
ich habe es das ja nicht.

01:01:10.000 --> 01:01:12.000
Da war halt eben eine Key Value Datenstruktur

01:01:12.000 --> 01:01:14.000
in plain Object.

01:01:14.000 --> 01:01:16.000
Muss halt nicht notwendiger

01:01:16.000 --> 01:01:18.000
Weise sein.

01:01:18.000 --> 01:01:20.000
Ne, ja,

01:01:20.000 --> 01:01:22.000
ich habe ja nichts gegen loadish.

01:01:22.000 --> 01:01:24.000
Ich denke mir halt nur so, ja okay Boomer,

01:01:24.000 --> 01:01:26.000
aber komm, gib mir ne Map.

01:01:26.000 --> 01:01:28.000
Also mir fällt

01:01:28.000 --> 01:01:30.000
spontan, fällt mir kein Use Case

01:01:30.000 --> 01:01:32.000
so in der Sekunde

01:01:32.000 --> 01:01:34.000
gerade ein, aber ich hätte es sicher schon mal gebrauchen können,

01:01:34.000 --> 01:01:36.000
wo ich stattdessen halt irgendwie eine eigene Implementierung hatte,

01:01:36.000 --> 01:01:38.000
die mir keine Ahnung, Array mehr umgedreht,

01:01:38.000 --> 01:01:40.000
ich weiß es gerade gar nicht mehr.

01:01:40.000 --> 01:01:42.000
Irgendwas habe ich schon gemacht.

01:01:42.000 --> 01:01:44.000
Irgendwie sowas schrecklich ineffizient ist,

01:01:44.000 --> 01:01:46.000
das kann man bestimmt irgendwie voll schlau machen,

01:01:46.000 --> 01:01:48.000
wenn man es ordentlich macht.

01:01:48.000 --> 01:01:50.000
Apropos schrecklich ineffizient,

01:01:50.000 --> 01:01:52.000
jetzt schweif ich wieder kurz ab,

01:01:52.000 --> 01:01:54.000
was würdest du sagen, wenn du ein,

01:01:54.000 --> 01:01:56.000
durch ein Array itagieren musst,

01:01:56.000 --> 01:01:58.000
und du musst irgendwie halt 2 Sachen drauf machen,

01:01:58.000 --> 01:02:00.000
2, zum Beispiel Filter

01:02:00.000 --> 01:02:02.000
und Map irgendwie in dem Sinne.

01:02:02.000 --> 01:02:04.000
Bevor du es,

01:02:04.000 --> 01:02:06.000
dann sowas wie ein If-Case drinnen,

01:02:06.000 --> 01:02:08.000
um halt zu filtern,

01:02:08.000 --> 01:02:10.000
und wenn der If-Case true ist,

01:02:10.000 --> 01:02:12.000
dann veränderst du dieses Item irgendwie.

01:02:12.000 --> 01:02:14.000
Oder bist du der Fan

01:02:14.000 --> 01:02:16.000
von den Array-Funktionen

01:02:16.000 --> 01:02:18.000
Filter und Map,

01:02:18.000 --> 01:02:20.000
was ja aber 2-mal durch das Array itagiert.

01:02:22.000 --> 01:02:24.000
Ja, also

01:02:24.000 --> 01:02:26.000
ich bin beim 1.

01:02:26.000 --> 01:02:28.000
aber nicht aus dem Grund,

01:02:28.000 --> 01:02:30.000
den du jetzt für das 2. genannt hast.

01:02:30.000 --> 01:02:32.000
Weil, dass der da wirklich 2-mal durchgeht,

01:02:32.000 --> 01:02:34.000
das mag so sein,

01:02:34.000 --> 01:02:36.000
aber ich weiß nicht, ob das auch nach der 7.

01:02:36.000 --> 01:02:38.000
Compiler-Optimierungsstufe immer noch so ist,

01:02:38.000 --> 01:02:40.000
wenn der da auf Maschinen-Ebene

01:02:40.000 --> 01:02:42.000
diese ganzen Dinger hin und her schiebt.

01:02:42.000 --> 01:02:44.000
Aber ich bin wirklich extrem zum

01:02:44.000 --> 01:02:46.000
imperativen Programmier-Primitivismus

01:02:46.000 --> 01:02:48.000
übergewechselt,

01:02:48.000 --> 01:02:50.000
seitdem ich verstanden habe,

01:02:50.000 --> 01:02:52.000
dass gerade auch so die Power von Async

01:02:52.000 --> 01:02:54.000
gerade erst so richtig erweckt wird,

01:02:54.000 --> 01:02:56.000
je weniger Callbacks man an den Backen hat.

01:02:58.000 --> 01:03:00.000
Das Erweight ist ja auch wenn es global verfügbar ist,

01:03:00.000 --> 01:03:02.000
sobald schon irgendeiner Funktion drin,

01:03:02.000 --> 01:03:04.000
das geht das nicht mehr. Und dann irgendwie

01:03:04.000 --> 01:03:06.000
Mapfilter, Reduce, bla bla bla.

01:03:06.000 --> 01:03:08.000
Das Ding ist ja, Callbacks sind ja im Prinzip

01:03:08.000 --> 01:03:10.000
ein Workaround dafür, dass man nicht rein

01:03:10.000 --> 01:03:12.000
imperativ durchprogrammieren kann,

01:03:12.000 --> 01:03:14.000
weil kein Multithreading.

01:03:14.000 --> 01:03:16.000
Das ist ja, dieser Stil ist ja quasi ein Hack.

01:03:16.000 --> 01:03:18.000
Und jetzt, wo der weg ist,

01:03:18.000 --> 01:03:20.000
kann man ja tatsächlich, wenn man will,

01:03:20.000 --> 01:03:22.000
konsequent ein Programmierparadigma

01:03:22.000 --> 01:03:24.000
bestreiten, nämlich das langweilige

01:03:24.000 --> 01:03:26.000
imperative Programmieren, if,

01:03:26.000 --> 01:03:28.000
as for while, und kann den ganzen

01:03:28.000 --> 01:03:30.000
Funktionen so was stehen, wo ich ja auch

01:03:30.000 --> 01:03:32.000
behaupten würde, dass JavaScript

01:03:32.000 --> 01:03:34.000
eine bessere Imperative als eine

01:03:34.000 --> 01:03:36.000
funktionale Programmiersprache ist.

01:03:36.000 --> 01:03:38.000
So, if, as for while, try, catch,

01:03:38.000 --> 01:03:40.000
kannst ganz gut, mit Async await noch so

01:03:40.000 --> 01:03:42.000
besser, aber der ganze funktionale

01:03:42.000 --> 01:03:44.000
Krempel, da ist es dann ja immer noch so,

01:03:44.000 --> 01:03:46.000
dann erzählen dir die FP-Tutorials,

01:03:46.000 --> 01:03:48.000
wie irgendwie Currying geht, und so,

01:03:48.000 --> 01:03:50.000
ja, so kannst du das machen,

01:03:50.000 --> 01:03:52.000
in der richtigen funktionalen Programmiersprache

01:03:52.000 --> 01:03:54.000
ist das aber einfach da.

01:03:54.000 --> 01:03:56.000
Und hier ist das nicht einfach da.

01:03:56.000 --> 01:03:58.000
Wenn man anfängt, so Reibungsverluste

01:03:58.000 --> 01:04:00.000
zu geben, beim Versuch,

01:04:00.000 --> 01:04:02.000
mit JavaScript Funktional zu arbeiten,

01:04:02.000 --> 01:04:04.000
dann denke ich mir halt immer schon so,

01:04:04.000 --> 01:04:06.000
ja...

01:04:06.000 --> 01:04:08.000
Außerdem im Mutable Data kann

01:04:08.000 --> 01:04:10.000
JavaScript halt echt so schlecht.

01:04:10.000 --> 01:04:12.000
Ein großes Projekt von mir, wo ich irgendwie

01:04:12.000 --> 01:04:14.000
früher mal das im Mutable gemacht habe,

01:04:14.000 --> 01:04:16.000
es war so langsam, und seitdem ich einfach

01:04:16.000 --> 01:04:18.000
sage, hier Object as any, steckt die Property

01:04:18.000 --> 01:04:20.000
drauf, und deklariere dich jetzt als

01:04:20.000 --> 01:04:22.000
anderer Typ, das ist so schnell,

01:04:22.000 --> 01:04:24.000
das ist unglaublich.

01:04:24.000 --> 01:04:26.000
Das ist voll auf dem Primitivismus-Trip.

01:04:26.000 --> 01:04:28.000
Also 100% massiv maximal

01:04:28.000 --> 01:04:30.000
aus einer Reihe

01:04:30.000 --> 01:04:32.000
von Gründen einfach auch in den mentalen Loads

01:04:32.000 --> 01:04:34.000
zu vereinfachen. If Else For a while

01:04:34.000 --> 01:04:36.000
gimme weg mit dem ganzen

01:04:36.000 --> 01:04:38.000
Flatmap-Latest.

01:04:38.000 --> 01:04:40.000
Blah!

01:04:42.000 --> 01:04:44.000
Ich glaube, das Neuste, was kommen wird,

01:04:44.000 --> 01:04:46.000
ist Group By.

01:04:46.000 --> 01:04:48.000
Auch das ist wunderbar, weil

01:04:48.000 --> 01:04:50.000
da kann ich auch wieder meine persönliche

01:04:50.000 --> 01:04:52.000
Implementierung in die Tonne treten.

01:04:52.000 --> 01:04:54.000
Das ist ja irgendwie nur grad

01:04:54.000 --> 01:04:56.000
bei Firefox

01:04:56.000 --> 01:04:58.000
irgendwas beta. Ich weiß es nicht ganz genau,

01:04:58.000 --> 01:05:00.000
aber ungefähr ein ganz neuer Browse

01:05:00.000 --> 01:05:02.000
unterstützt und kein anderer.

01:05:02.000 --> 01:05:04.000
Das ist

01:05:04.000 --> 01:05:06.000
tatsächlich auch überraschend nicht trivial

01:05:06.000 --> 01:05:08.000
mit diesem Group By.

01:05:08.000 --> 01:05:10.000
Hab ich schon öfter solche Sachen implementiert.

01:05:10.000 --> 01:05:12.000
Das heißt,

01:05:12.000 --> 01:05:14.000
das wäre jetzt meine Sache, wo ich sagen würde,

01:05:14.000 --> 01:05:16.000
geil, dass es das endlich gibt,

01:05:16.000 --> 01:05:18.000
weil da habe ich schon Stunden immer

01:05:18.000 --> 01:05:20.000
reingesteckt, bis es dann wirklich korrekt war.

01:05:20.000 --> 01:05:22.000
Das habe ich auch richtig durchgetestet.

01:05:22.000 --> 01:05:24.000
Das ist kompliziert.

01:05:24.000 --> 01:05:26.000
Aber ist super, weil

01:05:26.000 --> 01:05:28.000
da kannst du das daraus resultieren, der iterable

01:05:28.000 --> 01:05:30.000
nehmen. Kannst das in den Map-Konstrukte reinpacken

01:05:30.000 --> 01:05:32.000
und zack!

01:05:32.000 --> 01:05:34.000
Genau bei dieser Funktion bin ich das erste Mal

01:05:34.000 --> 01:05:36.000
über das Wort iterable gestoßen, weil

01:05:36.000 --> 01:05:38.000
dann hatte ich eben das auch so geschrieben

01:05:38.000 --> 01:05:40.000
mit Array from Array

01:05:40.000 --> 01:05:42.000
und hab auch den Kommentar bekommen

01:05:42.000 --> 01:05:44.000
Hä? Aber du gibst doch schon Array rein.

01:05:44.000 --> 01:05:46.000
Warum machst du Array from Array?

01:05:46.000 --> 01:05:48.000
Und ich sag ganz klug, ja, kann ja auch

01:05:48.000 --> 01:05:50.000
sein. Gut, wir verwenden keine Sets.

01:05:50.000 --> 01:05:52.000
Aber könnte ja sein.

01:05:52.000 --> 01:05:54.000
Könnte ja passieren.

01:05:54.000 --> 01:05:56.000
Man muss ja Future-Proofing betreiben.

01:05:56.000 --> 01:05:58.000
Ja, total.

01:05:58.000 --> 01:06:00.000
Okay, Error-Prototype-Course.

01:06:00.000 --> 01:06:02.000
Ich muss mich outen.

01:06:02.000 --> 01:06:04.000
Was ist das?

01:06:04.000 --> 01:06:06.000
Ich weiß es auch nicht, aber jetzt, wo ich

01:06:06.000 --> 01:06:08.000
sehe, weiß ich es und ich finde es gut, glaube ich.

01:06:08.000 --> 01:06:10.000
Also ich habe jetzt dann, ich kann das schreiben

01:06:10.000 --> 01:06:12.000
beim so einen Try-Catch

01:06:12.000 --> 01:06:14.000
Throw-New-Error.

01:06:14.000 --> 01:06:16.000
Wenn ich da korrekt bin, ist es egal, ob man

01:06:16.000 --> 01:06:18.000
so Error schreibt oder nur Throw-New-Error.

01:06:18.000 --> 01:06:20.000
Und dann schreibe ich halt

01:06:20.000 --> 01:06:22.000
Connecting to Database Failed

01:06:22.000 --> 01:06:24.000
und dann gebe ich Cause-Error ein.

01:06:24.000 --> 01:06:26.000
Ah, doch, das klingt gut.

01:06:26.000 --> 01:06:28.000
Ja, weil du ja im Prinzip den

01:06:28.000 --> 01:06:30.000
Fehler sozusagen aufbereitest.

01:06:30.000 --> 01:06:32.000
Ja, das ist sehr gut.

01:06:32.000 --> 01:06:34.000
Oh, das ist ja großartig. Das brauche ich.

01:06:34.000 --> 01:06:36.000
Also, scenario also nochmal

01:06:36.000 --> 01:06:38.000
um es jetzt runterzubrechen.

01:06:38.000 --> 01:06:40.000
Wir händeln eine Exception

01:06:40.000 --> 01:06:42.000
und das Exception-Händling besteht daraus

01:06:42.000 --> 01:06:44.000
auch einen Fehler wieder zu werfen

01:06:44.000 --> 01:06:46.000
oder enthält das zumindest

01:06:46.000 --> 01:06:48.000
und man will den Fehler zurückführer machen

01:06:48.000 --> 01:06:50.000
und dann gibt man das bei Cause-Error.

01:06:50.000 --> 01:06:52.000
Finde ich super.

01:06:52.000 --> 01:06:54.000
Ja, jetzt ist die Frage.

01:06:54.000 --> 01:06:56.000
Weißt du, wir können das jetzt hier auswählen.

01:06:56.000 --> 01:06:58.000
Wir wissen, was das ist, aber haben es noch nicht benutzt.

01:06:58.000 --> 01:07:00.000
Zählt das auch, wenn wir jetzt gerade

01:07:00.000 --> 01:07:02.000
erst beim Betrachten des Code-Samples verstanden haben,

01:07:02.000 --> 01:07:04.000
was es ist?

01:07:04.000 --> 01:07:06.000
Also, ich habe ja hier manche Sachen durchgegangen

01:07:06.000 --> 01:07:08.000
und habe dann zum Beispiel

01:07:08.000 --> 01:07:10.000
bei Temporal hatte ich kurz nicht auf dem Schirm

01:07:10.000 --> 01:07:12.000
so, hey, was ist das denn jetzt gerade?

01:07:12.000 --> 01:07:14.000
Ich habe mich googelt und dachte mir

01:07:14.000 --> 01:07:16.000
ja, ja, ja, kenne ich.

01:07:16.000 --> 01:07:18.000
Ich glaube, das steht extra ganz oben.

01:07:18.000 --> 01:07:20.000
Ne, bei dem war es nicht.

01:07:20.000 --> 01:07:22.000
Bei irgendeinem anderen Section

01:07:22.000 --> 01:07:24.000
stand irgendwie dabei.

01:07:24.000 --> 01:07:26.000
Man sollte es auch nur ankreuzen,

01:07:26.000 --> 01:07:28.000
wenn man es jetzt aktuell gerade verwendet

01:07:28.000 --> 01:07:30.000
und nicht so von vor zehn Jahren.

01:07:30.000 --> 01:07:32.000
Aha, okay.

01:07:32.000 --> 01:07:34.000
Na, das ist doch die Legacy-Abteilung.

01:07:34.000 --> 01:07:36.000
Das sind wir ja nicht.

01:07:36.000 --> 01:07:38.000
Ja, nee, aber hier ist, weiß ich,

01:07:38.000 --> 01:07:40.000
ich weiß auch nicht.

01:07:40.000 --> 01:07:42.000
Ich habe noch nie gehört,

01:07:42.000 --> 01:07:44.000
es fühlt sich so an, als hätte ich versagt.

01:07:44.000 --> 01:07:46.000
Ja, genau, und wir versagen nicht

01:07:46.000 --> 01:07:48.000
und deswegen kriegen wir hier ein grünes Häkchen.

01:07:48.000 --> 01:07:50.000
So, läuft.

01:07:50.000 --> 01:07:52.000
So, das nächste.

01:07:52.000 --> 01:07:54.000
Object Has Own.

01:07:54.000 --> 01:07:56.000
Wer jetzt drauf wartet, dass ich sage

01:07:56.000 --> 01:07:58.000
Property, genau, das ist der Sinn davon.

01:07:58.000 --> 01:08:00.000
Wir haben ja auch das gehabt,

01:08:00.000 --> 01:08:02.000
dieses Has Own Property.

01:08:02.000 --> 01:08:04.000
Wenn ich mich bei der Schreibweise

01:08:04.000 --> 01:08:06.000
nicht irre, dann müsste das sein

01:08:06.000 --> 01:08:08.000
Objektname

01:08:08.000 --> 01:08:10.000
mit Has Own Property

01:08:10.000 --> 01:08:12.000
und es ist auch immer nicht ganz trivial,

01:08:12.000 --> 01:08:14.000
was da genau, also man kann da drüber,

01:08:14.000 --> 01:08:16.000
es kann ein paar Steuerbesteine

01:08:16.000 --> 01:08:18.000
und jetzt haben wir stattdessen

01:08:18.000 --> 01:08:20.000
die neue Variante, dass ich wirklich Object schreibe

01:08:20.000 --> 01:08:22.000
mit einem großen O

01:08:22.000 --> 01:08:24.000
und nicht enderbar so ein Object Has Own

01:08:24.000 --> 01:08:26.000
und dann als Parameter gebe ich mein Objektname,

01:08:26.000 --> 01:08:28.000
also mein Objekt rein

01:08:28.000 --> 01:08:30.000
und schreibe welche Property

01:08:30.000 --> 01:08:32.000
als String und funktioniert.

01:08:32.000 --> 01:08:34.000
Genau, wenn ich jetzt mal

01:08:34.000 --> 01:08:36.000
das Acrylic der Java-Übersetzung hernehmen darf,

01:08:36.000 --> 01:08:38.000
es ist jetzt keine Instanz-Methode

01:08:38.000 --> 01:08:40.000
von Objekten mehr, sondern eine statische

01:08:40.000 --> 01:08:42.000
Methode der Object-Klasse.

01:08:42.000 --> 01:08:44.000
Wunderschön.

01:08:44.000 --> 01:08:46.000
Was für eine Aufwertung.

01:08:46.000 --> 01:08:48.000
Naja, das Schöne ist halt, der

01:08:48.000 --> 01:08:50.000
wichtigste Scholperstein ist, du kannst ja

01:08:50.000 --> 01:08:52.000
ein Objekt erzeugen ohne Prototype

01:08:52.000 --> 01:08:54.000
und Has Own Property wohnt hier auf dem Prototype

01:08:54.000 --> 01:08:56.000
und wenn du Object Create mit Null machst,

01:08:56.000 --> 01:08:58.000
dann hast du gar kein Has Own Property mehr

01:08:58.000 --> 01:09:00.000
und das passiert jetzt hiermit nicht mehr.

01:09:00.000 --> 01:09:02.000
Außerdem wieder irgendwie ein so dämliches Ding,

01:09:02.000 --> 01:09:04.000
was ich einfach wegignorieren kann,

01:09:04.000 --> 01:09:06.000
wie ich das in der Skript erkläre.

01:09:06.000 --> 01:09:08.000
So, es gibt keine eingebauten Methoden,

01:09:08.000 --> 01:09:10.000
irgendwie Ja to String und Value Off,

01:09:10.000 --> 01:09:12.000
kannst du alle ignorieren. Willst du wissen,

01:09:12.000 --> 01:09:14.000
ob Property drauf ist, nimmst du Has Own.

01:09:14.000 --> 01:09:16.000
Bada Bing, Bada Bung läuft.

01:09:16.000 --> 01:09:18.000
Was ist, gibt es jetzt noch

01:09:18.000 --> 01:09:20.000
ein Use Case für

01:09:20.000 --> 01:09:22.000
Property

01:09:22.000 --> 01:09:24.000
in Object?

01:09:24.000 --> 01:09:26.000
Der wichtigste ist für mich,

01:09:26.000 --> 01:09:28.000
dass TypeScript das als TypeGuard checkt.

01:09:28.000 --> 01:09:30.000
Moment, aber könnte ich das jetzt nicht auch

01:09:30.000 --> 01:09:32.000
dann einfach mit Object Has Own schreiben?

01:09:32.000 --> 01:09:34.000
Ja, probieren wir mal aus.

01:09:34.000 --> 01:09:36.000
Kommt halt drauf an, weil

01:09:36.000 --> 01:09:38.000
ist schwierig, weil

01:09:38.000 --> 01:09:40.000
wenn ich das jetzt irgendwie typen wollte,

01:09:40.000 --> 01:09:42.000
müsste ich ja den

01:09:42.000 --> 01:09:44.000
ersten Parameter, das fragliche Objekt

01:09:44.000 --> 01:09:46.000
als Typ Parameter haben,

01:09:46.000 --> 01:09:48.000
um das gegebenenfalls zu constrain,

01:09:48.000 --> 01:09:50.000
dass man nur gültige Keys angibt,

01:09:50.000 --> 01:09:52.000
aber das will man ja auch nicht, weil man will ja erstmal rausfinden,

01:09:52.000 --> 01:09:54.000
ob dieser Key da drauf ist, das müsste gleichsam ein TypeGuard sein.

01:09:54.000 --> 01:09:56.000
Aber für was?

01:09:56.000 --> 01:09:58.000
Ich glaube, das ist alles zu kompliziert.

01:09:58.000 --> 01:10:00.000
Würde ich jetzt mal raten, ich habe nicht nachgeschaut.

01:10:00.000 --> 01:10:02.000
Ja, und von zu kompliziert

01:10:02.000 --> 01:10:04.000
gehen wir jetzt wieder zum Letzten,

01:10:04.000 --> 01:10:06.000
und wir sind hier wieder bei RecApps.

01:10:06.000 --> 01:10:08.000
Ich habe gehört, es ist da gar keine

01:10:08.000 --> 01:10:10.000
dunkle Magie.

01:10:10.000 --> 01:10:12.000
Es geht um RecApps

01:10:12.000 --> 01:10:14.000
Match Indices.

01:10:14.000 --> 01:10:16.000
Ja.

01:10:16.000 --> 01:10:18.000
Ja, wenn man jetzt so was braucht,

01:10:18.000 --> 01:10:20.000
dann ist bestimmt gut.

01:10:20.000 --> 01:10:22.000
Ja, wobei, ich würde das

01:10:22.000 --> 01:10:24.000
eventuell

01:10:24.000 --> 01:10:26.000
doch in dem Fall schon,

01:10:26.000 --> 01:10:28.000
und an welchen Indices

01:10:28.000 --> 01:10:30.000
ist das eben aufgetreten,

01:10:30.000 --> 01:10:32.000
wenn man das braucht.

01:10:34.000 --> 01:10:36.000
Ich glaube, ich schließe mich da in einer Bewertung an.

01:10:36.000 --> 01:10:38.000
Wenn man das braucht, ist das etwas,

01:10:38.000 --> 01:10:40.000
was man braucht.

01:10:40.000 --> 01:10:42.000
Ich kann es davor nicht,

01:10:42.000 --> 01:10:44.000
aber ich habe mir das Code Beispiel durchgelesen,

01:10:44.000 --> 01:10:46.000
und es kam mir sofort einleuchtend vor,

01:10:46.000 --> 01:10:48.000
also würde ich schreiben, know what it is.

01:10:48.000 --> 01:10:50.000
Ich glaube, ich mache hier

01:10:50.000 --> 01:10:52.000
das ganze Testergebnis falsch.

01:10:52.000 --> 01:10:54.000
Okay, never heard of it.

01:10:54.000 --> 01:10:56.000
Alles super hier.

01:10:56.000 --> 01:10:58.000
My not sure what it is.

01:10:58.000 --> 01:11:00.000
Sie hätten vielleicht das Code Example nicht dazu schreiben dürfen,

01:11:00.000 --> 01:11:02.000
weil dann hätte ich wirklich gesagt,

01:11:02.000 --> 01:11:04.000
worum geht es?

01:11:04.000 --> 01:11:06.000
Ja, aber ich glaube,

01:11:06.000 --> 01:11:08.000
dann ist das nicht so.

01:11:08.000 --> 01:11:10.000
Bei einigen haben sie es ja gemacht.

01:11:10.000 --> 01:11:12.000
Promise All Zettel hat kein Code Beispiel.

01:11:12.000 --> 01:11:14.000
Proxies sind nicht mal richtig gemarkt,

01:11:14.000 --> 01:11:16.000
da ist der Hintergrund gar nicht grau.

01:11:16.000 --> 01:11:18.000
Interessant.

01:11:18.000 --> 01:11:20.000
Ja, aber das ist wahrscheinlich, weil das halt Code ist.

01:11:20.000 --> 01:11:22.000
Ja, das ist nicht die

01:11:22.000 --> 01:11:24.000
der Proxy Constructor.

01:11:24.000 --> 01:11:26.000
Nach welcher Logik sind hier manchmal Code Beispieler dabei

01:11:26.000 --> 01:11:28.000
und manchmal nicht?

01:11:28.000 --> 01:11:30.000
Na ja,

01:11:30.000 --> 01:11:32.000
wir müssen ja auch sagen, es geht hier um JavaScript,

01:11:32.000 --> 01:11:34.000
deswegen ist glaube ich Logik

01:11:34.000 --> 01:11:36.000
eine nachgeordnete Priorität.

01:11:40.000 --> 01:11:42.000
So, Browser APIs.

01:11:42.000 --> 01:11:44.000
Auf geht's.

01:11:44.000 --> 01:11:46.000
Service Workers.

01:11:46.000 --> 01:11:48.000
Ja, auf jede.

01:11:48.000 --> 01:11:50.000
In meinem Universum

01:11:50.000 --> 01:11:52.000
ist es aber schon so,

01:11:52.000 --> 01:11:54.000
dass dieser ganze Progressive Web App Hype

01:11:54.000 --> 01:11:56.000
ein bisschen vorbeizusein scheint.

01:11:56.000 --> 01:11:58.000
In meiner Welt scheint es für mich auch

01:11:58.000 --> 01:12:00.000
vorbeizusein, bzw.

01:12:00.000 --> 01:12:02.000
vielleicht ist es einfach von Frameworks schon

01:12:02.000 --> 01:12:04.000
Web wegabstrahiert.

01:12:06.000 --> 01:12:08.000
Also entweder ist schon dabei

01:12:08.000 --> 01:12:10.000
oder man macht es manuell nicht selber

01:12:10.000 --> 01:12:12.000
oder man hat irgendwie ein speziellen Case

01:12:12.000 --> 01:12:14.000
und da macht man es halt, aber

01:12:14.000 --> 01:12:16.000
ja.

01:12:16.000 --> 01:12:18.000
Also immer wenn mir eine Website kommt mit

01:12:18.000 --> 01:12:20.000
und ich mir auch installiere,

01:12:20.000 --> 01:12:22.000
tendiere ich tendenziell eher dazu zu sagen,

01:12:22.000 --> 01:12:24.000
nee, komm, geh weg, einfach so,

01:12:24.000 --> 01:12:26.000
weil das eine weitere Sorte von Programme

01:12:26.000 --> 01:12:28.000
sie dann auf meinem Rechner rumklappert.

01:12:28.000 --> 01:12:30.000
Und ich habe ja schon zwei Sorten von Programmen,

01:12:30.000 --> 01:12:32.000
nämlich die normalen Programme und die,

01:12:32.000 --> 01:12:34.000
die halt als Tab in meinem Browser wohnen

01:12:34.000 --> 01:12:36.000
und so ein Hybrid brauche ich nicht unbedingt,

01:12:36.000 --> 01:12:38.000
so gefühlt.

01:12:38.000 --> 01:12:40.000
Also hier, wir haben jetzt wieder die Antwortmöglichkeiten,

01:12:40.000 --> 01:12:42.000
wie habt ihr es noch nie gehört?

01:12:42.000 --> 01:12:44.000
Ich weiß, was es ist, aber noch nie benutzt.

01:12:44.000 --> 01:12:46.000
Ich habe es benutzt, es geht jetzt nicht drum,

01:12:46.000 --> 01:12:48.000
ja, ich würde es auch wieder benutzen,

01:12:48.000 --> 01:12:50.000
wenn der Use Case sich bieten würde, aber irgendwie,

01:12:52.000 --> 01:12:54.000
ja, er würde es sich halt schon bieten,

01:12:54.000 --> 01:12:56.000
aber es ist halt alles irgendwie noch so,

01:12:56.000 --> 01:12:58.000
also man vergrößert dann ja das Problem

01:12:58.000 --> 01:13:00.000
mit, ich will eine Web-App publizieren,

01:13:00.000 --> 01:13:02.000
dass ja an sich genommen schon keine Trivialität ist,

01:13:02.000 --> 01:13:04.000
das wird dadurch nicht wirklich einfacher,

01:13:04.000 --> 01:13:06.000
wenn man das noch dazu packt.

01:13:06.000 --> 01:13:08.000
Ja.

01:13:08.000 --> 01:13:10.000
Und der Mehrwert,

01:13:10.000 --> 01:13:12.000
manchmal nicht ganz so klar.

01:13:12.000 --> 01:13:14.000
Deswegen, also ich würde sagen, haben wir benutzt

01:13:14.000 --> 01:13:16.000
und enthalten uns jedes weiteren Kommentar

01:13:16.000 --> 01:13:18.000
über die Toten nur Gutes.

01:13:18.000 --> 01:13:20.000
Genau, das nächste ist,

01:13:20.000 --> 01:13:22.000
ich finde es schaut immer so schön aus,

01:13:22.000 --> 01:13:24.000
Intel, also Internationalization,

01:13:24.000 --> 01:13:26.000
hier mein ähnlicher Punkt wieder wieder vor,

01:13:26.000 --> 01:13:28.000
ich habe halt ein kleiner Library

01:13:28.000 --> 01:13:30.000
für Internationalization

01:13:30.000 --> 01:13:32.000
und kümmere nämlich um nichts weiteres.

01:13:32.000 --> 01:13:34.000
Ja.

01:13:34.000 --> 01:13:36.000
Ich verrichte keine ehrliche Arbeit,

01:13:36.000 --> 01:13:38.000
die Internationalisierung bräuchte,

01:13:38.000 --> 01:13:40.000
von daher stellt sich das Problem nicht,

01:13:40.000 --> 01:13:42.000
aber wir wissen, was es ist.

01:13:42.000 --> 01:13:44.000
Für Open Source,

01:13:44.000 --> 01:13:46.000
Leute wahrscheinlich wichtiger,

01:13:46.000 --> 01:13:48.000
ich benutze dann die Open Source,

01:13:48.000 --> 01:13:50.000
sonst sagt eine Danke oder spendieren Kaffee.

01:13:50.000 --> 01:13:52.000
So macht man das.

01:13:52.000 --> 01:13:54.000
So, WebGL

01:13:54.000 --> 01:13:56.000
ist weit entfernt von dem,

01:13:56.000 --> 01:13:58.000
was ich im Alltag tue.

01:14:00.000 --> 01:14:02.000
Also irgendwann in der frühen Kreidezeit

01:14:02.000 --> 01:14:04.000
habe ich mal ein WebGL Shader geschrieben,

01:14:04.000 --> 01:14:06.000
einfach nur zum Ausprobieren

01:14:06.000 --> 01:14:08.000
und dann habe ich so ein grünes Quadrat im Browser gehabt

01:14:08.000 --> 01:14:10.000
und habe da irgendwie 50 Zellen für gebraucht

01:14:10.000 --> 01:14:12.000
und ich mache jetzt wieder Background Color Green.

01:14:12.000 --> 01:14:14.000
Ich habe das im Studium gehabt.

01:14:14.000 --> 01:14:16.000
Ich weiß nicht mehr, ob Bachelor oder Master

01:14:16.000 --> 01:14:18.000
und ich dachte, das wird jetzt total geil

01:14:18.000 --> 01:14:20.000
und wir mussten irgendwie ein Roboter zeichnen

01:14:20.000 --> 01:14:22.000
und den Arm schwenken lassen

01:14:22.000 --> 01:14:24.000
von dem Roboter.

01:14:24.000 --> 01:14:26.000
Ne,

01:14:26.000 --> 01:14:28.000
das war,

01:14:28.000 --> 01:14:30.000
er hat keinen Spaß.

01:14:30.000 --> 01:14:32.000
Also da fand ich so Turing-Maschine

01:14:32.000 --> 01:14:34.000
und der Terministik und so was ausrechnen

01:14:34.000 --> 01:14:36.000
und Matrixen auszurechnen

01:14:36.000 --> 01:14:38.000
und Hashtabels

01:14:38.000 --> 01:14:40.000
auf Papier zu schreiben

01:14:40.000 --> 01:14:42.000
hat mir mehr Spaß gemacht.

01:14:42.000 --> 01:14:44.000
Ja,

01:14:44.000 --> 01:14:46.000
da gehe ich mit

01:14:46.000 --> 01:14:48.000
nur weil wir uns keine Hashtabels

01:14:48.000 --> 01:14:50.000
sondern mehr so der Untergang des römischen Reiches.

01:14:50.000 --> 01:14:52.000
Aber, wir haben es beide benutzt, ja?

01:14:52.000 --> 01:14:54.000
Ja, wir haben es beide benutzt.

01:14:54.000 --> 01:14:56.000
Ja, hallo.

01:14:56.000 --> 01:14:58.000
Stimmt, wir fragen uns ja gar nicht,

01:14:58.000 --> 01:15:00.000
ja, ja, ja, haben es benutzt, Thumbs Up.

01:15:00.000 --> 01:15:02.000
Web Animations

01:15:02.000 --> 01:15:04.000
habe ich nicht benutzt.

01:15:04.000 --> 01:15:06.000
Nicht ein einziges Mal Element.Animate

01:15:06.000 --> 01:15:08.000
Keyframe-Frame geben.

01:15:08.000 --> 01:15:10.000
Nein, tatsächlich kein einziges Mal.

01:15:10.000 --> 01:15:12.000
Bei View bekommst du Transitions

01:15:12.000 --> 01:15:14.000
out of the box mit.

01:15:14.000 --> 01:15:16.000
Da gibt es die Komponente Transition,

01:15:16.000 --> 01:15:18.000
da kannst du ein bisschen Werte angeben

01:15:18.000 --> 01:15:20.000
und weiter ging es

01:15:20.000 --> 01:15:22.000
bei meinen Newscases bisher nicht.

01:15:22.000 --> 01:15:24.000
Ich sage es nicht, dass es gut oder schlecht ist,

01:15:24.000 --> 01:15:26.000
aber es ist einfach so.

01:15:26.000 --> 01:15:28.000
Ja, das ist halt die Pest der modernen Webframeworks,

01:15:28.000 --> 01:15:30.000
wo manche Sachen so einfach sein könnten,

01:15:30.000 --> 01:15:32.000
wie, ah, okay, es ist hier gerade

01:15:32.000 --> 01:15:34.000
ein Ereignis passiert

01:15:34.000 --> 01:15:36.000
wenn als Nebenwirkung gleichsam

01:15:36.000 --> 01:15:38.000
die Animationen abgespielt werden.

01:15:38.000 --> 01:15:40.000
Erstens passiert hier nichts, es gibt hier

01:15:40.000 --> 01:15:42.000
nur Daten und Nebenwirkungen schon gar nicht.

01:15:42.000 --> 01:15:44.000
Hier ist React angesagt, ja, ja, ja, ja, ja.

01:15:44.000 --> 01:15:46.000
Und dann nimmst du halt lieber diese Library mit

01:15:46.000 --> 01:15:48.000
in den 7 Megabyte JavaScript, wenn du eine Animation haben willst,

01:15:48.000 --> 01:15:50.000
aber wehe, du rufst einfach eine Standardfunktion auf.

01:15:50.000 --> 01:15:52.000
Ich würde es ja gerne benutzen,

01:15:52.000 --> 01:15:54.000
aber man lässt mich ja nicht.

01:15:56.000 --> 01:15:58.000
Ja, so ist das.

01:15:58.000 --> 01:16:00.000
Dann kommen

01:16:00.000 --> 01:16:02.000
dann kommen wir zu

01:16:02.000 --> 01:16:04.000
WebRTC

01:16:04.000 --> 01:16:06.000
Real-Time-Communication.

01:16:08.000 --> 01:16:10.000
Wir kämen uns ja nicht in den Sinn,

01:16:10.000 --> 01:16:12.000
jemals WebRTC zu benutzen.

01:16:12.000 --> 01:16:14.000
Nee,

01:16:14.000 --> 01:16:16.000
das wird natürlich nicht live informieren.

01:16:16.000 --> 01:16:18.000
Ich wollte jetzt mehr so auf unseren

01:16:18.000 --> 01:16:20.000
Sendcaster-Call anspielen.

01:16:20.000 --> 01:16:22.000
Ah,

01:16:22.000 --> 01:16:24.000
stimmt.

01:16:24.000 --> 01:16:26.000
Wir benutzen das, ja, also Layers of Interaction,

01:16:26.000 --> 01:16:28.000
so nutzen wir das jetzt selber,

01:16:28.000 --> 01:16:30.000
da nutzen wir ein Framework, das das nutzt.

01:16:30.000 --> 01:16:32.000
Also WebGL von Handschreiben sicherlich

01:16:32.000 --> 01:16:34.000
eine Zumutung, nimmst du 3JS,

01:16:34.000 --> 01:16:36.000
ist total easy.

01:16:36.000 --> 01:16:38.000
WebRTC benutzen zu Fuß,

01:16:38.000 --> 01:16:40.000
geradezu unmöglich mit einer Library machbar,

01:16:40.000 --> 01:16:42.000
aber noch besser ist es, man schmeißt irgendwie

01:16:42.000 --> 01:16:44.000
Sendcaster-Geld in den Rachen und dann benutzen wir es einfach

01:16:44.000 --> 01:16:46.000
so, indem man auf einen Button klickt.

01:16:46.000 --> 01:16:48.000
Das zählt doch als benutzen oder nicht?

01:16:48.000 --> 01:16:50.000
Ja, benutzt.

01:16:50.000 --> 01:16:52.000
Wir machen uns halt die Welt,

01:16:52.000 --> 01:16:54.000
wie es uns gefällt.

01:16:54.000 --> 01:16:56.000
Nicht wahr? Aber ich meine, hey, das ist wirklich mal

01:16:56.000 --> 01:16:58.000
ein Webstand, wo man wirklich sagen kann,

01:16:58.000 --> 01:17:00.000
das ist derzeit zum De facto-Standard geworden.

01:17:00.000 --> 01:17:02.000
Ja.

01:17:02.000 --> 01:17:04.000
Oder hast du noch irgendwelche Software auf deiner Kiste,

01:17:04.000 --> 01:17:06.000
womit du regelmäßig irgendwelche Calls

01:17:06.000 --> 01:17:08.000
durchführst und das findet nicht im Browser statt?

01:17:12.000 --> 01:17:14.000
So, die ganzen Skypes und so sind einfach

01:17:14.000 --> 01:17:16.000
bei mir komplett verschwunden. Das ist einfach immer Browser-Tab

01:17:16.000 --> 01:17:18.000
aufmachen.

01:17:18.000 --> 01:17:20.000
Ist das nicht auch

01:17:20.000 --> 01:17:22.000
Elektron-Webtechnik, also möglicherweise was anderes?

01:17:22.000 --> 01:17:28.000
Auf Titten, aber ich weiß es nicht.

01:17:28.000 --> 01:17:30.000
Zoom ist ein guter Einwand.

01:17:30.000 --> 01:17:32.000
Ja, ich habe keine Ahnung.

01:17:32.000 --> 01:17:34.000
Zoom ist ja was, ich bringe gerade Zoom und Slack

01:17:34.000 --> 01:17:36.000
durcheinander. Guten Morgen.

01:17:36.000 --> 01:17:38.000
Wie kann ich ein Zoom und Slack

01:17:38.000 --> 01:17:40.000
durcheinander bringen?

01:17:40.000 --> 01:17:42.000
Ja, ne, nicht bei mir.

01:17:42.000 --> 01:17:44.000
Hier regiert ja der Pinguin.

01:17:44.000 --> 01:17:46.000
Und der Teams-Kleint ist ja tatsächlich,

01:17:46.000 --> 01:17:48.000
also den kannst du dir für Linux runterladen.

01:17:48.000 --> 01:17:50.000
Aber wenn du den hast und du bist da irgendwie

01:17:50.000 --> 01:17:52.000
so Master auf die Teams-Gruppe,

01:17:52.000 --> 01:17:54.000
dann hast du so subtile UI-Dinger,

01:17:54.000 --> 01:17:56.000
die auf Linux fehlen.

01:17:56.000 --> 01:17:58.000
Und das weiß halt keiner.

01:17:58.000 --> 01:18:00.000
Ich hatte da mal einen wunderbaren,

01:18:00.000 --> 01:18:02.000
wunderbaren Remote Workshop und die so,

01:18:02.000 --> 01:18:04.000
klick halt eben einfach da drauf.

01:18:04.000 --> 01:18:06.000
Ja, aber das ist doch nicht hier.

01:18:06.000 --> 01:18:08.000
Aber das ist doch da.

01:18:08.000 --> 01:18:10.000
Nee, ist das nicht, bis wir halt gemerkt haben.

01:18:10.000 --> 01:18:12.000
Teams auf Windows und Teams auf Linux

01:18:12.000 --> 01:18:14.000
hat halt diesen einen Button nicht.

01:18:14.000 --> 01:18:16.000
Ja.

01:18:16.000 --> 01:18:18.000
Ich habe Slack und Google.

01:18:18.000 --> 01:18:20.000
Ja, besser.

01:18:20.000 --> 01:18:22.000
Ich weiß immer nicht, ob Meet oder Hangout heißt,

01:18:22.000 --> 01:18:24.000
was immer gerade der Name das ist.

01:18:24.000 --> 01:18:26.000
Glauben, es heißt Meet, aber ich bin auch nicht sicher.

01:18:26.000 --> 01:18:28.000
Ich gönne sicher irgendwie, es heißt Meet,

01:18:28.000 --> 01:18:30.000
aber es hat irgendwie noch Hangout.

01:18:30.000 --> 01:18:32.000
Ja, ja, ist der Link.

01:18:32.000 --> 01:18:34.000
Ja, gut.

01:18:34.000 --> 01:18:36.000
Ebenfalls funktioniert halt einfach

01:18:36.000 --> 01:18:38.000
das Web-Speech-API.

01:18:38.000 --> 01:18:40.000
Brauche ich halt auch,

01:18:40.000 --> 01:18:42.000
nicht?

01:18:42.000 --> 01:18:44.000
Nee, hab ich auch tatsächlich noch nie

01:18:44.000 --> 01:18:46.000
auch nur eine Demo mitgebaut, wenn ich jetzt mal so

01:18:46.000 --> 01:18:48.000
lustige Demos bauen.

01:18:48.000 --> 01:18:50.000
Auf jeden Fall.

01:18:50.000 --> 01:18:52.000
Fällt mir halt jetzt auch gerade mal auf.

01:18:52.000 --> 01:18:54.000
Aber die ist komplett aus meiner Wahrnehmung

01:18:54.000 --> 01:18:56.000
rausgefallen. Interessant.

01:18:56.000 --> 01:18:58.000
Man kann auch so Konferenz-Talks machen

01:18:58.000 --> 01:19:00.000
und dann fängt man zu singen und dann wird alles witzig.

01:19:00.000 --> 01:19:02.000
Also für die Extrovertierten, für die Introvertierten

01:19:02.000 --> 01:19:04.000
wie mich wird natürlich alles schrecklich.

01:19:04.000 --> 01:19:06.000
Ja, aber was tut man nicht alles

01:19:06.000 --> 01:19:08.000
für die Show?

01:19:08.000 --> 01:19:10.000
So, dann Web-Sort-Cad.

01:19:10.000 --> 01:19:12.000
Auf der Webseite,

01:19:12.000 --> 01:19:14.000
im Einsatz, funktioniert ganz wunderbar

01:19:14.000 --> 01:19:16.000
in so einem Feature.

01:19:16.000 --> 01:19:18.000
Ich stell mir mal kurz WordPress vor,

01:19:18.000 --> 01:19:20.000
weil kennt jeder

01:19:20.000 --> 01:19:22.000
und zwei Leute

01:19:22.000 --> 01:19:24.000
oder fünf Leute haben drauf Zugriff,

01:19:24.000 --> 01:19:26.000
um zu sagen, obacht jemand anders

01:19:26.000 --> 01:19:28.000
werkelt da auch gerade rum

01:19:28.000 --> 01:19:30.000
und irgendjemand, wie man es halt dann implementieren möchte,

01:19:30.000 --> 01:19:32.000
irgendjemanden davon entzieht man halt jetzt quasi

01:19:32.000 --> 01:19:34.000
die Rechte.

01:19:34.000 --> 01:19:36.000
Kann man natürlich quasi auf die einfache

01:19:36.000 --> 01:19:38.000
Variante machen und sagen, hier hast du

01:19:38.000 --> 01:19:40.000
den ganzen

01:19:40.000 --> 01:19:42.000
so ein Layer drüber und kannst halt nichts mehr klicken.

01:19:42.000 --> 01:19:44.000
Könntest du jetzt halt in die

01:19:44.000 --> 01:19:46.000
DevTools reingehen und das wegmachen

01:19:46.000 --> 01:19:48.000
und vielleicht noch ein Request absenden

01:19:48.000 --> 01:19:50.000
und der würde vielleicht ein Error werfen

01:19:50.000 --> 01:19:52.000
oder du implantierst es besser und sagst, du kannst

01:19:52.000 --> 01:19:54.000
gar nichts mehr ab, Browser förd,

01:19:54.000 --> 01:19:56.000
nichts mehr ab.

01:19:56.000 --> 01:19:58.000
Dafür haben wir das im Einsatz

01:19:58.000 --> 01:20:00.000
und eben mit Web-Sort-Cad 2 ist damit einfach

01:20:00.000 --> 01:20:02.000
ziemlich stabil und gut läuft, dass auch die Leute

01:20:02.000 --> 01:20:04.000
dann gleich wieder Zugriff haben, sobald

01:20:04.000 --> 01:20:06.000
andere Tapp oder so was geschlossen wurde.

01:20:06.000 --> 01:20:08.000
Und da haben wir auch so eine Überprüfung drin,

01:20:08.000 --> 01:20:10.000
mit wie war es zu zwischenzeitlich offline

01:20:10.000 --> 01:20:12.000
und sobald alles funktioniert und weiter.

01:20:12.000 --> 01:20:14.000
Was

01:20:14.000 --> 01:20:16.000
halt so auf anderem Wege wirklich

01:20:16.000 --> 01:20:18.000
nur eine Zumutung wäre, das zu machen.

01:20:18.000 --> 01:20:20.000
Ja, auf der anderen Seite würde ich sagen,

01:20:20.000 --> 01:20:22.000
ich würde jetzt auch Web-Sort-Cad nicht überstrapazieren,

01:20:22.000 --> 01:20:24.000
sondern das, was ich mit Long Polling machen

01:20:24.000 --> 01:20:26.000
kann, würde ich dann auch damit machen,

01:20:26.000 --> 01:20:28.000
weil es halt trotzdem

01:20:28.000 --> 01:20:30.000
einfacher ist.

01:20:30.000 --> 01:20:32.000
Es ist halt wirklich so ein Ding, damit

01:20:32.000 --> 01:20:34.000
kann man halt echt Probleme wunderbar lösen,

01:20:34.000 --> 01:20:36.000
aber das fängt halt dann irgendwann an, so

01:20:36.000 --> 01:20:38.000
alle anderen Abläufe mit zu beeinflussen, weil

01:20:38.000 --> 01:20:40.000
es einfach da ist und irgendwie so eine

01:20:40.000 --> 01:20:42.000
extra Wurst gebraten bekommt.

01:20:42.000 --> 01:20:44.000
Also sich davon fernhalten,

01:20:44.000 --> 01:20:46.000
so lange wie man kann, wie es noch sinnvoll ist,

01:20:46.000 --> 01:20:48.000
aber sobald halt eben nötig ist,

01:20:48.000 --> 01:20:50.000
nimmt man es halt, ja. Also würde ich sagen,

01:20:50.000 --> 01:20:52.000
kriegen wir hier einen Daumen, haben wir benutzt,

01:20:52.000 --> 01:20:54.000
finden wir gut.

01:20:56.000 --> 01:20:58.000
Jut.

01:20:58.000 --> 01:21:00.000
Custom Elements.

01:21:00.000 --> 01:21:02.000
Nicht benutzt.

01:21:04.000 --> 01:21:06.000
Fleißigst benutzt, muss ich sagen.

01:21:06.000 --> 01:21:08.000
Ganz, ganz eifrig.

01:21:08.000 --> 01:21:10.000
Ja, natürlich hier.

01:21:10.000 --> 01:21:12.000
Die Browser-Standard-Fraktion.

01:21:12.000 --> 01:21:14.000
Naja, es ist halt wirklich so,

01:21:14.000 --> 01:21:16.000
die Dinger sind mittlerweile relativ

01:21:16.000 --> 01:21:18.000
ausgereift und stabil.

01:21:18.000 --> 01:21:20.000
Die zu schreiben, ist die absolute

01:21:20.000 --> 01:21:22.000
Zumutung. Das geht gar nicht.

01:21:22.000 --> 01:21:24.000
Wenn man das jedenfalls so

01:21:24.000 --> 01:21:26.000
Vanilla machen möchte.

01:21:26.000 --> 01:21:28.000
Wenn man das irgendwie machen möchte, mit irgendwelchen

01:21:28.000 --> 01:21:30.000
Libraries, kann man es bei meiner Meinung auch gleich

01:21:30.000 --> 01:21:32.000
sonst sein lassen und irgendwie sofort

01:21:32.000 --> 01:21:34.000
sich Angular installieren, weil dann

01:21:34.000 --> 01:21:36.000
ist es ja keine Vanillakomponente mehr.

01:21:36.000 --> 01:21:38.000
Aber ich hätte dann

01:21:38.000 --> 01:21:40.000
eine Prognose

01:21:40.000 --> 01:21:42.000
zu Custom Elements.

01:21:42.000 --> 01:21:44.000
Weil, also

01:21:44.000 --> 01:21:46.000
so Webkomponent sind halt ganz super für so

01:21:46.000 --> 01:21:48.000
Komponenten. So irgendwie das eine UI-Element,

01:21:48.000 --> 01:21:50.000
das ich halt eben haben will. Das ist super.

01:21:50.000 --> 01:21:52.000
Und man kann damit tatsächlich auch ganz gut,

01:21:52.000 --> 01:21:54.000
wenn man irgendwie eine Art Produkt hat,

01:21:54.000 --> 01:21:56.000
tatsächlich

01:21:56.000 --> 01:21:58.000
Pluckins machen, so wirklich so M-Bats,

01:21:58.000 --> 01:22:00.000
so der sprichwörtliche

01:22:00.000 --> 01:22:02.000
Spitzklammer Google Dash Map, Spitzklammer

01:22:02.000 --> 01:22:04.000
so ein Mix-In

01:22:04.000 --> 01:22:06.000
Gleichsam hat man das früher genannt.

01:22:06.000 --> 01:22:08.000
So ein

01:22:08.000 --> 01:22:10.000
embeddable. Kann man damit glaube ich auch extrem

01:22:10.000 --> 01:22:12.000
gut machen. Es ist halt nur so mittlerweile sind wir ja

01:22:12.000 --> 01:22:14.000
im Zeitalter der Datensilus angekommen und so

01:22:14.000 --> 01:22:16.000
binde einfach deine Webseite in meine ein

01:22:16.000 --> 01:22:18.000
so mashupmäßig. Das gibt es ja gar nicht mehr.

01:22:18.000 --> 01:22:20.000
Aber wenn man so was mal machen möchte,

01:22:20.000 --> 01:22:22.000
ist das natürlich super.

01:22:22.000 --> 01:22:24.000
Und ich glaube tatsächlich,

01:22:24.000 --> 01:22:26.000
dass so die ganzen ergonomischen

01:22:26.000 --> 01:22:28.000
Nachteile von Custom Elements

01:22:28.000 --> 01:22:30.000
durch TypeScript beseitigt werden können.

01:22:30.000 --> 01:22:32.000
Wenn

01:22:32.000 --> 01:22:34.000
wir mal so weit sind, dass es

01:22:34.000 --> 01:22:36.000
ECMAScript Decorators fertig standardisiert

01:22:36.000 --> 01:22:38.000
gibt.

01:22:38.000 --> 01:22:40.000
Ich habe ja vor mittlerweile

01:22:40.000 --> 01:22:42.000
allzu langer Zeit mal irgendwie, ich glaube

01:22:42.000 --> 01:22:44.000
in einem TypeScript Update mal mit Stefan darüber gesprochen,

01:22:44.000 --> 01:22:46.000
dass ich nicht glaube, dass ECMAScript Decorators

01:22:46.000 --> 01:22:48.000
jemals was werden.

01:22:48.000 --> 01:22:50.000
Mittlerweile scheinen die aber doch durch den

01:22:50.000 --> 01:22:52.000
Prozess bei TC39 relativ

01:22:52.000 --> 01:22:54.000
gut durchzugehen.

01:22:54.000 --> 01:22:56.000
Und wenn man dann einfach sozusagen deklarieren kann,

01:22:56.000 --> 01:22:58.000
ich habe hier eine Klasse geschrieben und die

01:22:58.000 --> 01:23:00.000
Klasse definiert ein HTML

01:23:00.000 --> 01:23:02.000
Tag, indem ich einfach über die Klasse

01:23:02.000 --> 01:23:04.000
ein Decorator drüber klatsche. Dann ist das

01:23:04.000 --> 01:23:06.000
ein ergonomischer Gewinn gegenüber

01:23:06.000 --> 01:23:08.000
ich muss das Ding manuell registrieren

01:23:08.000 --> 01:23:10.000
und vorher gucken, ob der Technik schon belegt

01:23:10.000 --> 01:23:12.000
ist und dann irgendwie FLs und so. Wenn ich

01:23:12.000 --> 01:23:14.000
einfach deklarieren kann, so ist das jetzt.

01:23:14.000 --> 01:23:16.000
Und wenn ich bei einer privaten Property einfach definieren

01:23:16.000 --> 01:23:18.000
kann, du bist reflektiert in einer

01:23:18.000 --> 01:23:20.000
Dom-Property und in einem Attribut mit dieser

01:23:20.000 --> 01:23:22.000
und jenen Transformationsfunktionen.

01:23:22.000 --> 01:23:24.000
Dann kann das echt ergonomisch ziemlich gut

01:23:24.000 --> 01:23:26.000
werden.

01:23:26.000 --> 01:23:28.000
Da kommt noch was.

01:23:28.000 --> 01:23:30.000
Zwischenzeitlich war ich da echt so ein bisschen so,

01:23:30.000 --> 01:23:32.000
dass es so mühsam die Dinger zu bauen, dass man

01:23:32.000 --> 01:23:34.000
das echt keinem zumuten kann.

01:23:34.000 --> 01:23:36.000
Aber ich glaube, da geht

01:23:36.000 --> 01:23:38.000
noch was. Das wird noch, das wird richtig gut.

01:23:38.000 --> 01:23:40.000
Schauen wir uns das in fünf Jahren an.

01:23:40.000 --> 01:23:42.000
Das geht schneller.

01:23:42.000 --> 01:23:44.000
Und ich meine, es fehlt dem Ganzen natürlich

01:23:44.000 --> 01:23:46.000
auch so ein Applicationsmodell.

01:23:46.000 --> 01:23:48.000
So, eine Komponente

01:23:48.000 --> 01:23:50.000
ist ja sowieso ein schlechter Name, weil alles

01:23:50.000 --> 01:23:52.000
ist ja irgendwie die Komponente.

01:23:52.000 --> 01:23:54.000
Genau, der ganze hätt ich es mit anfangen.

01:23:54.000 --> 01:23:56.000
Das ist irgendwie Entwickler XY

01:23:56.000 --> 01:23:58.000
und Entwicklerin ABC.

01:23:58.000 --> 01:24:00.000
Und sagst denen halt, dass es eine Komponente haben,

01:24:00.000 --> 01:24:02.000
die komplett unterschiedliche Dinger im Kopf.

01:24:02.000 --> 01:24:04.000
Aber wenn man mal hingehen würde, man würde

01:24:04.000 --> 01:24:06.000
das halt irgendwie mal so strukturieren.

01:24:06.000 --> 01:24:08.000
Also meine aktuelle Theorie ist,

01:24:08.000 --> 01:24:10.000
Web-Components sind ja eigentlich

01:24:10.000 --> 01:24:12.000
so normalerweise

01:24:12.000 --> 01:24:14.000
richtige Custom-HTML-Elemente,

01:24:14.000 --> 01:24:16.000
die so wirklich standalone sind

01:24:16.000 --> 01:24:18.000
und wohl definiert und die reflektieren

01:24:18.000 --> 01:24:20.000
ihre Attribute in Dom-Properties

01:24:20.000 --> 01:24:22.000
und so weiter.

01:24:22.000 --> 01:24:24.000
Damit kannst du keine Applikation bauen.

01:24:24.000 --> 01:24:26.000
Also, die brauchst du dafür, aber du brauchst halt noch andere Sachen.

01:24:26.000 --> 01:24:28.000
Du brauchst halt so eine Art

01:24:28.000 --> 01:24:30.000
Quick and Dirty Templating, wo man einfach nur sagen kann,

01:24:30.000 --> 01:24:32.000
ein Konstrukt wie eine Sidebar besteht

01:24:32.000 --> 01:24:34.000
aus dem, dem und dem Ding,

01:24:34.000 --> 01:24:36.000
ruther deklarieren wie so eine reudige React Komponente

01:24:36.000 --> 01:24:38.000
für die Istekiste ohne internen State und so Spaß.

01:24:38.000 --> 01:24:40.000
Also es braucht dafür ein Konzept

01:24:40.000 --> 01:24:42.000
und es braucht halt irgendwie auch ein Konzept

01:24:42.000 --> 01:24:44.000
des Datenhaltenden,

01:24:44.000 --> 01:24:46.000
des Datenhaltenden Objekts, das da drüber gestülpt ist.

01:24:46.000 --> 01:24:48.000
Das war ja meine Idee von vorhin.

01:24:48.000 --> 01:24:50.000
So kein Proxy, sondern ein HTML-Element,

01:24:50.000 --> 01:24:52.000
dass diese Dinger dann provided für alle,

01:24:52.000 --> 01:24:54.000
die da drin genestet sind.

01:24:54.000 --> 01:24:56.000
Und dann kann man ja tatsächlich mit Events

01:24:56.000 --> 01:24:58.000
und so Subscription-Mechanismen,

01:24:58.000 --> 01:25:00.000
die noch nicht mal irgendwie echte Subscriptions

01:25:00.000 --> 01:25:02.000
und Observables sein müssen. Das kann alles super locker

01:25:02.000 --> 01:25:04.000
gekoppelt sein. Wirklich was bauen, was echt gut funktioniert.

01:25:04.000 --> 01:25:06.000
Glaube ich, ich bin mal,

01:25:06.000 --> 01:25:08.000
ich habe mal das beforst

01:25:08.000 --> 01:25:10.000
für ein Unternehmen,

01:25:10.000 --> 01:25:12.000
das mal so gesagt hat, hey,

01:25:12.000 --> 01:25:14.000
TypeScript mit Web Components,

01:25:14.000 --> 01:25:16.000
sollte man das jetzt mal machen

01:25:16.000 --> 01:25:18.000
und dann habe ich mal wirklich einfach so was gebaut

01:25:18.000 --> 01:25:20.000
und dann bin ich relativ, bin so nah an das Ergebnis

01:25:20.000 --> 01:25:22.000
herangekommen, dass ich relativ sicher bin,

01:25:22.000 --> 01:25:24.000
dass, wenn noch ein paar Dinger nachgerüstet

01:25:24.000 --> 01:25:26.000
werden in der Welt, so Decorators here,

01:25:26.000 --> 01:25:28.000
bischen APIs da,

01:25:28.000 --> 01:25:30.000
dass das echt ein Konzept werden könnte,

01:25:30.000 --> 01:25:32.000
dass wirklich konkurrenzfähig ist.

01:25:32.000 --> 01:25:34.000
Weil im Moment ist es halt nicht konkurrenzfähig.

01:25:34.000 --> 01:25:36.000
Ja.

01:25:36.000 --> 01:25:38.000
Das Hallo Welt von Vue.js,

01:25:38.000 --> 01:25:40.000
du hast das ganze Tutorial durchgespielt,

01:25:40.000 --> 01:25:42.000
bist du deine erste Komponente

01:25:42.000 --> 01:25:44.000
bei Web Components überhaupt erst mal

01:25:44.000 --> 01:25:46.000
gedacht hast.

01:25:46.000 --> 01:25:48.000
Aber da geht noch fast, da glaube ich,

01:25:48.000 --> 01:25:50.000
das wird gut.

01:25:50.000 --> 01:25:52.000
Als nächstes haben wir Shatterdom,

01:25:52.000 --> 01:25:54.000
ganz klar habe ich benutzt,

01:25:54.000 --> 01:25:56.000
weil habe ja Vue benutzt,

01:25:56.000 --> 01:25:58.000
ganz klar habe ich Shatterdom benutzt.

01:25:58.000 --> 01:26:00.000
Ach, das ist da einfach so mit drin?

01:26:00.000 --> 01:26:02.000
Also automatisch

01:26:02.000 --> 01:26:04.000
verwendest Shatterdom?

01:26:04.000 --> 01:26:06.000
Irgendein Dom verwendet es im Endeffekt,

01:26:06.000 --> 01:26:08.000
Virtualdom, Shatterdom.

01:26:08.000 --> 01:26:10.000
Shatterdom ist ja

01:26:10.000 --> 01:26:12.000
dieses Web Component-Ding

01:26:12.000 --> 01:26:14.000
für, du kommst hier nicht rein,

01:26:14.000 --> 01:26:16.000
die, beim Number-Input, die kleinen Pfeile.

01:26:16.000 --> 01:26:18.000
Ja, ich drücke das anders aus,

01:26:18.000 --> 01:26:20.000
das stimmt so natürlich nicht,

01:26:20.000 --> 01:26:22.000
aber ich kümmere mich nicht drum,

01:26:22.000 --> 01:26:24.000
weil ich habe Frameworks, die sich drum kümmern,

01:26:24.000 --> 01:26:26.000
dass der Dom richtig geupdatet wird.

01:26:26.000 --> 01:26:28.000
Dann meinst du das Virtualdom?

01:26:28.000 --> 01:26:30.000
Ja, stimmt.

01:26:30.000 --> 01:26:32.000
Genau, nicht das Shatterdom.

01:26:32.000 --> 01:26:34.000
Ja, macht aber nichts,

01:26:34.000 --> 01:26:36.000
weil du weißt, was es ist,

01:26:36.000 --> 01:26:38.000
haben wir jetzt gerade gemerkt.

01:26:38.000 --> 01:26:40.000
Und ich habe es schon benutzt, deswegen kriegts den Daumen, also passt das alles.

01:26:40.000 --> 01:26:42.000
Sehr gut.

01:26:42.000 --> 01:26:44.000
Okay.

01:26:46.000 --> 01:26:48.000
Was haben wir noch?

01:26:48.000 --> 01:26:50.000
Die Page Visibility API.

01:26:50.000 --> 01:26:52.000
Hm.

01:26:52.000 --> 01:26:54.000
Hm.

01:26:54.000 --> 01:26:56.000
Was macht die?

01:26:56.000 --> 01:26:58.000
Tab ist nicht fokussiert,

01:26:58.000 --> 01:27:00.000
kriegst du mit und kannst dann irgendwie

01:27:00.000 --> 01:27:02.000
Arbeit reduzieren.

01:27:02.000 --> 01:27:04.000
Ja.

01:27:04.000 --> 01:27:06.000
Ja, das klingt interessant.

01:27:06.000 --> 01:27:08.000
Klingt interessant, ist aber auch so ein bisschen

01:27:08.000 --> 01:27:10.000
Tragedy of the comments, ne?

01:27:10.000 --> 01:27:12.000
Wenn du das nicht benutzt,

01:27:12.000 --> 01:27:14.000
dann leiden ja andere drunter.

01:27:14.000 --> 01:27:16.000
Ja.

01:27:16.000 --> 01:27:18.000
Du frisst ja Ressourcen,

01:27:18.000 --> 01:27:20.000
aber du frisst ja die Ressourcen von wem anders.

01:27:20.000 --> 01:27:22.000
Also muss sich das ja streng genommen

01:27:22.000 --> 01:27:24.000
so richtig nicht

01:27:24.000 --> 01:27:26.000
stören.

01:27:26.000 --> 01:27:28.000
Weißt du, du bist ein besserer Mitbürger

01:27:28.000 --> 01:27:30.000
und du beschmierst die Bushaltestelle halt eben nicht

01:27:30.000 --> 01:27:32.000
mit deinem Ressourcenverbrauch, aber pfff, ne?

01:27:32.000 --> 01:27:34.000
Ja, gut, wenn ich mir aber den

01:27:34.000 --> 01:27:36.000
Accessibility-State im Web anschaue,

01:27:36.000 --> 01:27:38.000
dann sind wir da eh nicht so doll.

01:27:38.000 --> 01:27:40.000
Eben.

01:27:40.000 --> 01:27:42.000
Freundlich zu sein.

01:27:42.000 --> 01:27:44.000
Eben. Also ich würde sagen,

01:27:44.000 --> 01:27:46.000
Pagevisibility-API

01:27:46.000 --> 01:27:48.000
wissen wir, benutzt haben wir es noch nicht,

01:27:48.000 --> 01:27:50.000
wenn ich dich jetzt richtig verstanden habe

01:27:50.000 --> 01:27:52.000
und man sollte so eine Art

01:27:52.000 --> 01:27:54.000
Name-and-Shame-Kampagne starten

01:27:54.000 --> 01:27:56.000
für alle Ressourcen hungrigen Dinger, die im Hintergrund...

01:27:56.000 --> 01:27:58.000
Ich überlege gerade, was spannend sein könnte,

01:27:58.000 --> 01:28:00.000
wenn ich jetzt zum Beispiel

01:28:00.000 --> 01:28:02.000
einen Video pausiere,

01:28:02.000 --> 01:28:04.000
wenn ich jetzt weggehe.

01:28:04.000 --> 01:28:06.000
Ich weiß aber gar nicht, ob das nicht automatisch passiert

01:28:06.000 --> 01:28:08.000
weil ich hier auch eigentlich

01:28:08.000 --> 01:28:10.000
eh übernennen wahrscheinlich wieder

01:28:10.000 --> 01:28:12.000
eine Library ein, die sich schon drum kümmert.

01:28:12.000 --> 01:28:14.000
Ähm, ja,

01:28:14.000 --> 01:28:16.000
gut.

01:28:16.000 --> 01:28:18.000
Oder ne, jetzt fällt mir gerade was ein.

01:28:18.000 --> 01:28:20.000
Wir haben,

01:28:20.000 --> 01:28:22.000
wir benutzen confetti.js

01:28:22.000 --> 01:28:24.000
weil wenn man da auf einen bestimmten

01:28:24.000 --> 01:28:26.000
Button drückt, dann kommt confetti ist ein

01:28:26.000 --> 01:28:28.000
Highlight. Und da ist mir schon oft aufgefallen,

01:28:28.000 --> 01:28:30.000
wenn ich das lokal laufen lasse,

01:28:30.000 --> 01:28:32.000
dann laufen bei mir so background

01:28:32.000 --> 01:28:34.000
Shops die laufen so ein bisschen.

01:28:34.000 --> 01:28:36.000
Deswegen mache ich immer, dann drücke ich auf den Button, kommt confetti.

01:28:36.000 --> 01:28:38.000
Ich weiß aber schon auf dem Local House

01:28:38.000 --> 01:28:40.000
dauert es kurz 10 Sekunden und gehe woanders hin

01:28:40.000 --> 01:28:42.000
und komme zurück und erst dann

01:28:42.000 --> 01:28:44.000
sehe ich, dass confetti zu Ende gehen.

01:28:44.000 --> 01:28:46.000
Ich weiß aber nicht, ob das überhaupt

01:28:46.000 --> 01:28:48.000
überhaupt notwendig ist oder ob das nicht eh

01:28:48.000 --> 01:28:50.000
im Browser drin ist. Ich bin mir unsicher.

01:28:50.000 --> 01:28:52.000
Hm.

01:28:52.000 --> 01:28:54.000
Hm.

01:28:54.000 --> 01:28:56.000
Ja, das können nur die Kommentare

01:28:56.000 --> 01:28:58.000
zu dieser Revision klären, glaube ich.

01:29:00.000 --> 01:29:02.000
Nächste Antwort gilt

01:29:02.000 --> 01:29:04.000
auch für Broadcast Channel

01:29:04.000 --> 01:29:06.000
API. Ne, muss ich ganz ehrlich sagen,

01:29:06.000 --> 01:29:08.000
ich weiß nicht mal was das ist.

01:29:08.000 --> 01:29:10.000
Ja, aber das klingt doch schon so, als würde ich

01:29:10.000 --> 01:29:12.000
was Broadcasten

01:29:12.000 --> 01:29:14.000
an verschiedene

01:29:14.000 --> 01:29:16.000
Windows,

01:29:16.000 --> 01:29:18.000
an verschiedene Tabs, oder

01:29:18.000 --> 01:29:20.000
vielleicht an alle Iframes

01:29:20.000 --> 01:29:22.000
auf einer, jetzt frage ich mich, ist das

01:29:22.000 --> 01:29:24.000
über den ganzen Browser

01:29:24.000 --> 01:29:26.000
oder vielleicht nur in meinem Tab

01:29:26.000 --> 01:29:28.000
Broadcast dann alles?

01:29:28.000 --> 01:29:30.000
Aber wenn die da nicht auch Window Post Message?

01:29:30.000 --> 01:29:32.000
Äh, ja, aber dann musst du die ja

01:29:32.000 --> 01:29:34.000
für kennen.

01:29:34.000 --> 01:29:36.000
Ja. Du musst ja auch mal ein Iframe das

01:29:36.000 --> 01:29:38.000
zu schicken, musst du es ja adressieren können.

01:29:38.000 --> 01:29:40.000
Und Broadcast Channel, wenn ich das jetzt grad

01:29:40.000 --> 01:29:42.000
bei NPM, meine Fresse,

01:29:42.000 --> 01:29:44.000
MDN, nicht NPM,

01:29:44.000 --> 01:29:46.000
da finde ich keine Informationen,

01:29:46.000 --> 01:29:48.000
da finde ich nur Megabytes.

01:29:48.000 --> 01:29:50.000
So sehe ich, dann ist es wirklich

01:29:50.000 --> 01:29:52.000
postmessagemäßig, nur halt eben

01:29:52.000 --> 01:29:54.000
wird halt eben ge Broadcasted an alle, die

01:29:54.000 --> 01:29:56.000
halt da relevant sind und das wären halt

01:29:56.000 --> 01:29:58.000
eben die Dinge auf dem selben Origin,

01:29:58.000 --> 01:30:00.000
also all die Windows und Tabs und Frames und so weiter.

01:30:00.000 --> 01:30:02.000
Also der Top Level Begriff, den du

01:30:02.000 --> 01:30:04.000
gesucht hast, Browsing Context.

01:30:04.000 --> 01:30:06.000
Also alles, was halt irgendwie so

01:30:06.000 --> 01:30:08.000
eine Instanz da drin ist, die würden damit

01:30:08.000 --> 01:30:10.000
dann adressiert werden.

01:30:10.000 --> 01:30:12.000
Genau, eine Instanz vermachen.

01:30:12.000 --> 01:30:14.000
Ziemlich gut sein im Bereich von,

01:30:14.000 --> 01:30:16.000
wenn man jetzt wirklich kompliziert der Webseiten

01:30:16.000 --> 01:30:18.000
hat, mit mehreren

01:30:18.000 --> 01:30:20.000
Microfront Ends und mehreren Sourcen,

01:30:20.000 --> 01:30:22.000
wo alles herkommt.

01:30:22.000 --> 01:30:24.000
In dem Bereich von, ich hab halt meine kleine

01:30:24.000 --> 01:30:26.000
Next Remix, Next Whatever

01:30:26.000 --> 01:30:28.000
App, ist es

01:30:28.000 --> 01:30:30.000
nicht notwendig.

01:30:30.000 --> 01:30:32.000
Na ja, aber dann,

01:30:32.000 --> 01:30:34.000
wenn das jetzt sozusagen einfach nur Microfront Ends

01:30:34.000 --> 01:30:36.000
in einem Browsing Kontext, also in einem Tab

01:30:36.000 --> 01:30:38.000
wären, dann könntest du ja zum Broadcast

01:30:38.000 --> 01:30:40.000
einfach irgendwelche Events auf das

01:30:40.000 --> 01:30:42.000
Window schmeißen. Den Broadcast Channel brauchst du

01:30:42.000 --> 01:30:44.000
ja, wenn du nicht ein gescheites Windowobjekt

01:30:44.000 --> 01:30:46.000
hast und viele verschiedene Fenster offen hast.

01:30:46.000 --> 01:30:48.000
Guter Punkt, stimmt.

01:30:48.000 --> 01:30:50.000
Also

01:30:50.000 --> 01:30:52.000
Multifenster App

01:30:52.000 --> 01:30:54.000
wäre da mehr so der Use Case.

01:30:54.000 --> 01:30:56.000
Das Net wäre, wenn das so ginge.

01:30:56.000 --> 01:30:58.000
Dann denk ich mal, guck mal nach.

01:30:58.000 --> 01:31:00.000
Könnt interessant werden.

01:31:00.000 --> 01:31:02.000
Na die spannende Frage ist halt, ob man

01:31:02.000 --> 01:31:04.000
sozusagen sämtlichen Kommunikationsfluss,

01:31:04.000 --> 01:31:06.000
also

01:31:06.000 --> 01:31:08.000
du hast jetzt irgendwie dein Nachrichtenbus

01:31:08.000 --> 01:31:10.000
und der ist halt eben aktuell dein Windowobjekt.

01:31:10.000 --> 01:31:12.000
Kann man da einfach 1 zu 1

01:31:12.000 --> 01:31:14.000
ein Broadcast Channel für einsetzen, hat man

01:31:14.000 --> 01:31:16.000
dann automatisch eine Multifensterfähige App.

01:31:16.000 --> 01:31:18.000
Das wäre halt nett, wenn das ginge.

01:31:18.000 --> 01:31:20.000
Du bist unser

01:31:20.000 --> 01:31:22.000
Proof-of-Concept.

01:31:22.000 --> 01:31:24.000
Hm.

01:31:24.000 --> 01:31:26.000
Ja.

01:31:26.000 --> 01:31:28.000
Alles klar, Captain.

01:31:28.000 --> 01:31:30.000
Dann werde ich das mal tun.

01:31:30.000 --> 01:31:32.000
Mache ich tatsächlich.

01:31:32.000 --> 01:31:34.000
Ich muss zwar jetzt am Wochenende ganz viel Weihnachtsdeko

01:31:34.000 --> 01:31:36.000
anbringen, aber wenn ich da mal zwischendurch

01:31:36.000 --> 01:31:38.000
mich an der Computer setzen darf,

01:31:38.000 --> 01:31:40.000
dann werde ich das mal tun.

01:31:40.000 --> 01:31:42.000
Übrigens, wir müssen alle noch ein Adventskranz machen,

01:31:42.000 --> 01:31:44.000
weil ich hab festgestellt, dass wir schon ja vor Dezember

01:31:44.000 --> 01:31:46.000
ersten Advent haben. Und ich als

01:31:46.000 --> 01:31:48.000
erst strengen, bläubige, bayerische Bürger.

01:31:48.000 --> 01:31:50.000
Der erste

01:31:50.000 --> 01:31:52.000
ist der Herr Zanz.

01:31:52.000 --> 01:31:54.000
Wir sind maximal ungläubige,

01:31:54.000 --> 01:31:56.000
weit weg von Bayern,

01:31:56.000 --> 01:31:58.000
befindliche gerade noch eben als

01:31:58.000 --> 01:32:00.000
bürgerdurchgehende Personen.

01:32:00.000 --> 01:32:02.000
Aber in diesem Haushalt,

01:32:02.000 --> 01:32:04.000
wenn auch nur Weihnachten in die Nähe rückt.

01:32:04.000 --> 01:32:06.000
Also, das können jetzt leider die Zuhörer

01:32:06.000 --> 01:32:08.000
nicht sehen, aber siehst du, in der Hintergrund

01:32:08.000 --> 01:32:10.000
haben wir die ganzen Adventskalender.

01:32:10.000 --> 01:32:12.000
Ja.

01:32:12.000 --> 01:32:14.000
Aber nächstes Mal, wenn ich hier bin, wirst du es nicht

01:32:14.000 --> 01:32:16.000
wiedererkennen hier alles.

01:32:16.000 --> 01:32:18.000
Ich habe keinen Kranz, ich bin so ganz modern,

01:32:18.000 --> 01:32:20.000
ein Brett.

01:32:20.000 --> 01:32:22.000
Ja, wir hatten so einen

01:32:22.000 --> 01:32:24.000
Kasten hatten wir früher mal. Den haben wir mal

01:32:24.000 --> 01:32:26.000
irgendwo im Gartencenter gekauft.

01:32:26.000 --> 01:32:28.000
Und das war dann unser, also, es war kein

01:32:28.000 --> 01:32:30.000
Adventskranz, weil es halt eben ein Kasten war.

01:32:30.000 --> 01:32:32.000
Aber in dem Kasten war so viel Kram,

01:32:32.000 --> 01:32:34.000
dass es auch schon irgendwie

01:32:34.000 --> 01:32:36.000
kranzig wurde. Und wir haben uns dann am Ende auf die

01:32:36.000 --> 01:32:38.000
Sprachregelung Adventskrasten geeinigt.

01:32:38.000 --> 01:32:40.000
Sehr gut.

01:32:40.000 --> 01:32:42.000
Und jetzt haben wir einen riesigen Kranz, der von einer

01:32:42.000 --> 01:32:44.000
Decke hängt, die gerade eben in der Lage ist,

01:32:44.000 --> 01:32:46.000
das zu supporten, weil das hier ein klappriger Altbau

01:32:46.000 --> 01:32:48.000
ist.

01:32:48.000 --> 01:32:50.000
Könnte man jetzt den klapprigen Altbau

01:32:50.000 --> 01:32:52.000
finden, indem man die Geolocation

01:32:52.000 --> 01:32:54.000
API verwendet?

01:32:54.000 --> 01:32:56.000
Da geht das, glaube ich, relativ gut,

01:32:56.000 --> 01:32:58.000
weil große Fenster.

01:32:58.000 --> 01:33:00.000
Da kann man den Satelliten noch

01:33:00.000 --> 01:33:02.000
raussehen.

01:33:02.000 --> 01:33:04.000
Ja.

01:33:04.000 --> 01:33:06.000
Der Geolocation API.

01:33:06.000 --> 01:33:08.000
Damals, ich glaube, irgendwie so das zweite

01:33:08.000 --> 01:33:10.000
Kapitel im HTML5-Buch nach der Einführung.

01:33:10.000 --> 01:33:12.000
So alt ist das schon.

01:33:12.000 --> 01:33:14.000
Hab es seither auch nicht mehr benutzt.

01:33:14.000 --> 01:33:16.000
Ich baue halt keine Karten.

01:33:16.000 --> 01:33:18.000
Ich glaube, auch das Problem

01:33:18.000 --> 01:33:20.000
ist halt eben damit auch,

01:33:20.000 --> 01:33:22.000
dass...

01:33:22.000 --> 01:33:24.000
Also, einfach nur Orten.

01:33:24.000 --> 01:33:26.000
Hier bin ich jetzt.

01:33:26.000 --> 01:33:28.000
Ich bestelle mir jetzt Essen.

01:33:28.000 --> 01:33:30.000
Das könnte ja ganz sinnvoll sein.

01:33:30.000 --> 01:33:32.000
Und das klappt auch, glaube ich, ganz gut.

01:33:32.000 --> 01:33:34.000
Aber so dieses

01:33:34.000 --> 01:33:36.000
Position Tracking, wenn du halt irgendwie

01:33:36.000 --> 01:33:38.000
deine Fitness App im Web bauen willst,

01:33:38.000 --> 01:33:40.000
das leidet, glaube ich, echt hart darunter,

01:33:40.000 --> 01:33:42.000
dass so diese Überwachungsprozesse

01:33:42.000 --> 01:33:44.000
und Batterieschonung echt hart gedrosselt

01:33:44.000 --> 01:33:46.000
werden.

01:33:46.000 --> 01:33:48.000
Und wenn der Browser irgendwie im Hintergrund ist,

01:33:48.000 --> 01:33:50.000
dann ist sowieso alles vorbei.

01:33:50.000 --> 01:33:52.000
Und darunter leidet das alles so ein bisschen.

01:33:52.000 --> 01:33:54.000
Weswegen man das, glaube ich,

01:33:54.000 --> 01:33:56.000
weniger häufig sieht und diese ganzen

01:33:56.000 --> 01:33:58.000
Fitnessdinger halt eben alternative Apps

01:33:58.000 --> 01:34:00.000
sind und wahrscheinlich auch erst mal bleiben

01:34:00.000 --> 01:34:02.000
werden, würde ich sagen.

01:34:02.000 --> 01:34:04.000
Tja.

01:34:04.000 --> 01:34:06.000
Aber wenn wir aufrunden, kriegen wir einen

01:34:06.000 --> 01:34:08.000
Daumen daraus, haben wir benutzt.

01:34:08.000 --> 01:34:10.000
Total.

01:34:10.000 --> 01:34:12.000
So, dann haben wir als nächstes

01:34:12.000 --> 01:34:14.000
File System Access

01:34:14.000 --> 01:34:16.000
API.

01:34:16.000 --> 01:34:18.000
Da bin ich mir gar nicht so sicher, wie alt

01:34:18.000 --> 01:34:20.000
oder wie neu das eigentlich ist, bzw.

01:34:20.000 --> 01:34:22.000
wie viele Methoden da

01:34:22.000 --> 01:34:24.000
bei allen Browsen überhaupt zur Verfügung

01:34:24.000 --> 01:34:26.000
stehen oder nicht.

01:34:26.000 --> 01:34:28.000
Und die wievielte

01:34:28.000 --> 01:34:30.000
Iteration dieses Konzepts das ist.

01:34:30.000 --> 01:34:32.000
Weil ich meine irgendwie ganz, ganz alte

01:34:32.000 --> 01:34:34.000
Chrome-Versionen hatten eine Variante

01:34:34.000 --> 01:34:36.000
davon schon seit Ewigkeiten.

01:34:36.000 --> 01:34:38.000
Aber wir fragen mal die allwissende

01:34:38.000 --> 01:34:40.000
Alte.

01:34:40.000 --> 01:34:42.000
File System Access

01:34:42.000 --> 01:34:44.000
API.

01:34:44.000 --> 01:34:46.000
Sieht ziemlich alt aus.

01:34:46.000 --> 01:34:48.000
Also alt.

01:34:48.000 --> 01:34:50.000
Was ist das Gegenteil von alt? Neu.

01:34:50.000 --> 01:34:52.000
Weil das halt alles schlecht supportet

01:34:52.000 --> 01:34:54.000
ist.

01:34:54.000 --> 01:34:56.000
File System Access API ist auch noch

01:34:56.000 --> 01:34:58.000
kein richtiger Standard, wie ich jetzt hier

01:34:58.000 --> 01:35:00.000
sehe. Ist eine Draft Community

01:35:00.000 --> 01:35:02.000
Report vom W3C.

01:35:02.000 --> 01:35:04.000
Das ist ja normalerweise nicht so...

01:35:04.000 --> 01:35:06.000
Also wenn das jetzt jemand regelmäßig

01:35:06.000 --> 01:35:08.000
macht, würde ich mich halt da eben auch...

01:35:08.000 --> 01:35:10.000
Ich würde es hinterfragen.

01:35:10.000 --> 01:35:12.000
Ja.

01:35:12.000 --> 01:35:14.000
Stream Writing Methoden.

01:35:14.000 --> 01:35:16.000
Da kann man da mal 4-Await-Off benutzen

01:35:16.000 --> 01:35:18.000
in so ein Zeug.

01:35:18.000 --> 01:35:20.000
Das ist schon sehr spannend, aber ich glaube,

01:35:20.000 --> 01:35:22.000
das muss dafür erstmal zumindest mal

01:35:22.000 --> 01:35:24.000
eine Working Draft bekommen

01:35:24.000 --> 01:35:26.000
und nicht so was hier.

01:35:28.000 --> 01:35:30.000
So, was haben wir als nächstes?

01:35:30.000 --> 01:35:32.000
Die Web Share API.

01:35:32.000 --> 01:35:34.000
Habe ich noch nie benutzt? Kennst du die?

01:35:34.000 --> 01:35:36.000
Ja, ich kenne...

01:35:36.000 --> 01:35:38.000
Ich habe mal Navigator dort share gehört

01:35:38.000 --> 01:35:40.000
und jetzt bin ich auch schon

01:35:40.000 --> 01:35:42.000
fertig.

01:35:42.000 --> 01:35:44.000
Genau, das ist das.

01:35:44.000 --> 01:35:46.000
Ja, aber ich weiß nicht, was es tut.

01:35:46.000 --> 01:35:48.000
Also ich habe mal davon gehört, aber ich

01:35:48.000 --> 01:35:50.000
könnte jetzt nicht erklären, was es tut.

01:35:50.000 --> 01:35:52.000
Also ich meine, ich könnte es mir jetzt

01:35:52.000 --> 01:35:54.000
irgendwie educated guesses machen

01:35:54.000 --> 01:35:56.000
und sagen, das schert wohl

01:35:56.000 --> 01:35:58.000
irgendwelche Daten,

01:35:58.000 --> 01:36:00.000
was auch sonst, wenn nicht Daten.

01:36:00.000 --> 01:36:02.000
Ja, nee, es ist dieser Workflow

01:36:02.000 --> 01:36:04.000
und du sagst, teile das mit

01:36:04.000 --> 01:36:06.000
irgendwie.

01:36:06.000 --> 01:36:08.000
Du drückst auf den Share-Button drauf

01:36:08.000 --> 01:36:10.000
und dann kommt ja, willst du eine

01:36:10.000 --> 01:36:12.000
Message mit dem Messenger an den schicken

01:36:12.000 --> 01:36:14.000
oder eine E-Mail an die jene Person?

01:36:14.000 --> 01:36:16.000
Das ist das, nur als Web-Technologie.

01:36:16.000 --> 01:36:18.000
Als Web-Technologie.

01:36:18.000 --> 01:36:20.000
Das ist ja auch spannend generell,

01:36:20.000 --> 01:36:22.000
dass Webseiten so langsam fast ein bisschen

01:36:22.000 --> 01:36:24.000
mehr wie Apps auf mobilen End-Geräten

01:36:24.000 --> 01:36:26.000
teilweise werden können.

01:36:26.000 --> 01:36:28.000
Auch mit Notifications habe ich da schon

01:36:28.000 --> 01:36:30.000
ganz spannende Sachen gesehen.

01:36:30.000 --> 01:36:32.000
Nee, habe ich auch nicht. Und das Ding ist halt,

01:36:32.000 --> 01:36:34.000
das ist halt auch so eine Inselgeschichte.

01:36:34.000 --> 01:36:36.000
Wofür

01:36:36.000 --> 01:36:38.000
auf Mobil-Geräten man da sicherlich

01:36:38.000 --> 01:36:40.000
ein Feature hat, was dann Bedürfnis

01:36:40.000 --> 01:36:42.000
erfüllt.

01:36:42.000 --> 01:36:44.000
Aber so den Share-Button gibt es ja

01:36:44.000 --> 01:36:46.000
auf dem Desktop gar nicht.

01:36:46.000 --> 01:36:48.000
Ja, das gibt es schon,

01:36:48.000 --> 01:36:50.000
wenn du jetzt irgendwie

01:36:50.000 --> 01:36:52.000
Videos aufnimmst.

01:36:52.000 --> 01:36:54.000
Also klar, ich bin auch noch so ein bisschen old-school

01:36:54.000 --> 01:36:56.000
und ich mache irgendwie meinen Quicktime-Video

01:36:56.000 --> 01:36:58.000
und lade es halt hoch.

01:36:58.000 --> 01:37:00.000
Es gibt ja auch so Tools wie Loom.

01:37:00.000 --> 01:37:02.000
Und dann stellt man da halt seinen 5-Minuten-Video.

01:37:02.000 --> 01:37:04.000
Das kann man dann schicken.

01:37:04.000 --> 01:37:06.000
Und da gibt es ja ganz viele Share-Links.

01:37:06.000 --> 01:37:08.000
Das sind halt Buttons,

01:37:08.000 --> 01:37:10.000
die dann eigene Modal-Implementierungen

01:37:10.000 --> 01:37:12.000
haben

01:37:12.000 --> 01:37:14.000
und halt halt alles eine eigene, wie gesagt,

01:37:14.000 --> 01:37:16.000
Implementierung. Ob du jetzt den

01:37:16.000 --> 01:37:18.000
Embed-Links haben willst oder den Share-Link

01:37:18.000 --> 01:37:20.000
oder ob du alles mögliche kriegst

01:37:20.000 --> 01:37:22.000
oder bei Google es auch schwer.

01:37:22.000 --> 01:37:24.000
Das ist ja schon ein bisschen was anderes,

01:37:24.000 --> 01:37:26.000
als wenn ich auf meinem Telefon einfach

01:37:26.000 --> 01:37:28.000
einen Messenger installiere

01:37:28.000 --> 01:37:30.000
und irgendeinen Photogallery-Manager

01:37:30.000 --> 01:37:32.000
installiere. Und die beiden wissen nichts voneinander,

01:37:32.000 --> 01:37:34.000
aber die haben halt eben einfach ein Protokoll

01:37:34.000 --> 01:37:36.000
eingebaut, mit dem ich aus der Fotogallerie

01:37:36.000 --> 01:37:38.000
was an den Messenger schicken kann,

01:37:38.000 --> 01:37:40.000
ohne dass die beiden was voneinander wissen müssen.

01:37:40.000 --> 01:37:42.000
So ein Mechanismus

01:37:42.000 --> 01:37:44.000
jetzt irgendwie im so normalen Windows-Rechner gibt es ja nicht.

01:37:44.000 --> 01:37:46.000
So ein Protokoll, oder?

01:37:46.000 --> 01:37:48.000
Ich denke nicht.

01:37:48.000 --> 01:37:50.000
Also wie gesagt, auch das Beispiel,

01:37:50.000 --> 01:37:52.000
was ich gerade meinte, ist halt eine Eigenimplementierung

01:37:52.000 --> 01:37:54.000
von Share, dann bekommst du ein Link

01:37:54.000 --> 01:37:56.000
und das ist ja nicht so Teil,

01:37:56.000 --> 01:37:58.000
dass es über Slack mit der Person

01:37:58.000 --> 01:38:00.000
wie es auf dem Handy fliegt machen könnte.

01:38:00.000 --> 01:38:02.000
Genau.

01:38:02.000 --> 01:38:04.000
Aber das ist halt der Workflow, der das

01:38:04.000 --> 01:38:06.000
supportet wird und das ist ja schon ein bisschen seltsam

01:38:06.000 --> 01:38:08.000
hier in der API zu haben.

01:38:08.000 --> 01:38:10.000
Die halt sozusagen eine Sorte von Device

01:38:10.000 --> 01:38:12.000
irgendwie ganz gut bespielt, aber wo ich halt irgendwie

01:38:12.000 --> 01:38:14.000
so auf dem Desktop, also ich habe hier

01:38:14.000 --> 01:38:16.000
jetzt ein Share-Button hier in meinem Chrome,

01:38:16.000 --> 01:38:18.000
anscheinend Seite teilen kann ich drauf drücken.

01:38:18.000 --> 01:38:20.000
Link kopieren an meine Geräte senden,

01:38:20.000 --> 01:38:22.000
also irgendwas gibt es da schon. Aber üblich

01:38:22.000 --> 01:38:24.000
vielleicht sind wir zu alt.

01:38:24.000 --> 01:38:26.000
Link teilen über LinkedIn,

01:38:26.000 --> 01:38:28.000
das ist aber garantiert nicht etwas, was

01:38:28.000 --> 01:38:30.000
irgendwie der aus meinem Nutzerverhalten

01:38:30.000 --> 01:38:32.000
ermittelt hat.

01:38:32.000 --> 01:38:34.000
Das ist Hard-Coded, da bin ich mir sicher.

01:38:34.000 --> 01:38:36.000
Naja,

01:38:36.000 --> 01:38:38.000
oder vielleicht liege ich auch einfach falsch,

01:38:38.000 --> 01:38:40.000
aber es ist halt interessant so diese Dinger zu sehen,

01:38:40.000 --> 01:38:42.000
weil das das Web sammelt ja diese ganzen

01:38:42.000 --> 01:38:44.000
APIs einfach immer so einem Laufe der Zeit

01:38:44.000 --> 01:38:46.000
und sollte eines Tages irgendwie mal das Smartphone

01:38:46.000 --> 01:38:48.000
so aus der Mode kommen, da bin ich ja mal

01:38:48.000 --> 01:38:50.000
sehr gespannt, was dann mit den ganzen APIs los ist,

01:38:50.000 --> 01:38:52.000
ob das so was ist wie irgendwie so der

01:38:52.000 --> 01:38:54.000
Mediatype TV in CSS heutzutage.

01:38:54.000 --> 01:38:56.000
Wo man irgendwie so sagt, so

01:38:56.000 --> 01:38:58.000
alleine die Aussage es gäbe ein

01:38:58.000 --> 01:39:00.000
Mediatype TV ist in der modernen Welt so ein

01:39:00.000 --> 01:39:02.000
Kategoriefehler.

01:39:02.000 --> 01:39:04.000
Wer weiß, wer weiß.

01:39:04.000 --> 01:39:06.000
So, kommen wir zum

01:39:06.000 --> 01:39:08.000
letzten Ding für heute. Wir haben noch extrem

01:39:08.000 --> 01:39:10.000
viele Features vor uns, aber es konnte ja

01:39:10.000 --> 01:39:12.000
keine Ahnung, dass wir hier echt übelst

01:39:12.000 --> 01:39:14.000
abschweifen und jetzt 90 Minuten gebraucht haben,

01:39:14.000 --> 01:39:16.000
um die ersten zwei Seiten von diesem

01:39:16.000 --> 01:39:18.000
Survey zu bearbeiten. Ja, klassische

01:39:18.000 --> 01:39:20.000
Computer an der Estimation. Natürlich schaffen wir

01:39:20.000 --> 01:39:22.000
alle. Ja, locker, locker.

01:39:22.000 --> 01:39:24.000
Gehen wir noch mehr Aufgaben. Können wir überhaupt

01:39:24.000 --> 01:39:26.000
eine Stunde damit füllen?

01:39:26.000 --> 01:39:28.000
Das ist ja lächerlich.

01:39:28.000 --> 01:39:30.000
So, WebXR Device

01:39:30.000 --> 01:39:32.000
API, habe ich garantiert noch nicht benutzt?

01:39:32.000 --> 01:39:34.000
Du? Nee, ist auch experimental

01:39:34.000 --> 01:39:36.000
und dementsprechend

01:39:36.000 --> 01:39:38.000
nie.

01:39:38.000 --> 01:39:40.000
Ist sie?

01:39:40.000 --> 01:39:42.000
Nicht, ich denke schon.

01:39:42.000 --> 01:39:44.000
Supporting Browser, Browser Compatibility

01:39:44.000 --> 01:39:46.000
Table. Die schaut gar nicht

01:39:46.000 --> 01:39:48.000
so schlecht aus.

01:39:48.000 --> 01:39:50.000
Wohl Chromium, ja, Firefox, nein, Safari, nein.

01:39:50.000 --> 01:39:52.000
Also Chrome.

01:39:52.000 --> 01:39:54.000
Also Chrome Edge

01:39:54.000 --> 01:39:56.000
Opera auch noch.

01:39:56.000 --> 01:39:58.000
Ja, das ist aber ja eigentlich so.

01:39:58.000 --> 01:40:00.000
Ist ja was. Das ist eine ganze Menge Zeug.

01:40:00.000 --> 01:40:02.000
Es scheint ja mal wieder so eine normative Kraft

01:40:02.000 --> 01:40:04.000
des Faktischen zu sein. Chrome kann das.

01:40:04.000 --> 01:40:06.000
Chrome

01:40:06.000 --> 01:40:08.000
ist ja auch viele andere Browser.

01:40:08.000 --> 01:40:10.000
Gibt es da irgendwo eine Spezifikation?

01:40:10.000 --> 01:40:12.000
Scrolls, Scrolls, Scrolls zu.

01:40:12.000 --> 01:40:14.000
Eine Group of Standards

01:40:14.000 --> 01:40:16.000
Rendering 3D scenes

01:40:16.000 --> 01:40:18.000
zu Hardware, bla, bla, bla.

01:40:18.000 --> 01:40:20.000
Ja, ich glaube, das sind halt auch so Sachen.

01:40:20.000 --> 01:40:22.000
Also wenn man da wirklich irgendwie sagt

01:40:22.000 --> 01:40:24.000
I've used it, wenn das jemand sagt,

01:40:24.000 --> 01:40:26.000
dann wäre ich ja wirklich sehr gespannt daran,

01:40:26.000 --> 01:40:28.000
was dieser Use Case ist, weil das kann ja

01:40:28.000 --> 01:40:30.000
nur irgendwie so was sein, die Chrome

01:40:30.000 --> 01:40:32.000
spezifisch oder irgendwie so ein Elektron-Ding.

01:40:32.000 --> 01:40:34.000
Aber so wirklich Web ist das ja

01:40:34.000 --> 01:40:36.000
alles noch zu

01:40:36.000 --> 01:40:38.000
und reif, glaube ich.

01:40:38.000 --> 01:40:40.000
Ja, das ist ja das Interessante

01:40:40.000 --> 01:40:42.000
da drin, dass man das hier in dem Server

01:40:42.000 --> 01:40:44.000
testen.

01:40:44.000 --> 01:40:46.000
Es wird mir jetzt auch nicht wundern, wenn da

01:40:46.000 --> 01:40:48.000
die Rate eher bei

01:40:48.000 --> 01:40:50.000
wenigen Prozent sind, dass die Leute

01:40:50.000 --> 01:40:52.000
davon gehört haben, geschweige denn dann

01:40:52.000 --> 01:40:54.000
benutzt haben.

01:40:54.000 --> 01:40:56.000
Das würde ich auch annehmen.

01:40:56.000 --> 01:40:58.000
Vielleicht, ich könnte jetzt drauf schätzen,

01:40:58.000 --> 01:41:00.000
dass das Survey ein bisschen ein falschen

01:41:00.000 --> 01:41:02.000
Einblick dann

01:41:02.000 --> 01:41:04.000
in die Realität gibt, weil vielleicht eher

01:41:04.000 --> 01:41:06.000
die Leute, die sich eben eh tief mit

01:41:06.000 --> 01:41:08.000
solchen Sachen beschäftigt sind, eher die

01:41:08.000 --> 01:41:10.000
sind, die solche Servers jetzt beantworten

01:41:10.000 --> 01:41:12.000
sind.

01:41:12.000 --> 01:41:14.000
Keine Ahnung, wenn man nicht auf Twitter

01:41:14.000 --> 01:41:16.000
oder Mastodon, der war es auch immer

01:41:16.000 --> 01:41:18.000
gerade in LinkedIn, Instagram.

01:41:18.000 --> 01:41:20.000
Sonst was ist,

01:41:20.000 --> 01:41:22.000
Oh ja, Tiktok-Developer gibt es

01:41:22.000 --> 01:41:24.000
bestimmt auch.

01:41:24.000 --> 01:41:26.000
Generell finde ich, bei diesem

01:41:26.000 --> 01:41:28.000
Survey ist es bestimmt immer ein bisschen

01:41:28.000 --> 01:41:30.000
missleiten, was dann die Ergebnisse sind.

01:41:30.000 --> 01:41:32.000
Aber ich finde es, was über sich dran

01:41:32.000 --> 01:41:34.000
schön fand, das war bei einem CSS-Service,

01:41:34.000 --> 01:41:36.000
fand ich auch schon ganz nett. Man stäubt

01:41:36.000 --> 01:41:38.000
dann hin und wieder, wieder über Sachen,

01:41:38.000 --> 01:41:40.000
da gibt es was. Brau jetzt überhaupt nicht,

01:41:40.000 --> 01:41:42.000
aber ist hier irgendwie cool, dass es irgendwie

01:41:42.000 --> 01:41:44.000
was Kreatives gibt.

01:41:44.000 --> 01:41:46.000
Vielleicht braucht es irgendjemand.

01:41:46.000 --> 01:41:48.000
Oh, das sind so Sachen, die du

01:41:48.000 --> 01:41:50.000
möglicherweise während dieser Revision

01:41:50.000 --> 01:41:52.000
nochmal extra aufgeschrieben hast, um zu sagen,

01:41:52.000 --> 01:41:54.000
oh, warte mal, das schau ich an, das könnte

01:41:54.000 --> 01:41:56.000
eventuell genau mein Problem lösen.

01:41:56.000 --> 01:41:58.000
Dann muss ich nochmal darüber nachdenken,

01:41:58.000 --> 01:42:00.000
möglicherweise gibt es ja auch diese Fälle.

01:42:00.000 --> 01:42:02.000
So, das Schöne ist,

01:42:02.000 --> 01:42:04.000
dieser Survey hier, die hat so ein Table

01:42:04.000 --> 01:42:06.000
of Contents damit zählt.

01:42:06.000 --> 01:42:08.000
20% dieses Service abgearbeitet,

01:42:08.000 --> 01:42:10.000
die auch damit läuft seit einer Stunde

01:42:10.000 --> 01:42:12.000
und 41 Minuten.

01:42:12.000 --> 01:42:14.000
Dazu muss man aber auch sagen, dann gibt es

01:42:14.000 --> 01:42:16.000
zwei Gruppriken wie Front and Frameworks,

01:42:16.000 --> 01:42:18.000
eher gut React, Angular, View, was sollen wir

01:42:18.000 --> 01:42:20.000
jetzt noch großartig dazu sagen, dann gibt es

01:42:20.000 --> 01:42:22.000
halt irgendwie Ember und ja, dann kommen

01:42:22.000 --> 01:42:24.000
vielleicht ein bisschen weniger Bekannte,

01:42:24.000 --> 01:42:26.000
wie Stencil und Quick.

01:42:26.000 --> 01:42:28.000
Da kann man sich eh schon ein bisschen vorstellen,

01:42:28.000 --> 01:42:30.000
wie da die Ergebnisse rauskommen

01:42:30.000 --> 01:42:32.000
und wie gesagt, dann

01:42:32.000 --> 01:42:34.000
kommen die Rendering Frameworks,

01:42:34.000 --> 01:42:36.000
da hast du Next.js und Remix.

01:42:36.000 --> 01:42:38.000
Klar, jeder, der jetzt React angekreust hat,

01:42:38.000 --> 01:42:40.000
kann jetzt auch Next.js und

01:42:40.000 --> 01:42:42.000
Remix wahrscheinlich ankreuzen.

01:42:42.000 --> 01:42:44.000
Da würde ich eher sagen, dass wenn man eine

01:42:44.000 --> 01:42:46.000
ganz andere Vision zu sagen, darüber zu reden,

01:42:46.000 --> 01:42:48.000
was ist eigentlich da der Unterschied

01:42:48.000 --> 01:42:50.000
und was ist das Gleiche? Gut, dann gibt es

01:42:50.000 --> 01:42:52.000
Next, dann gibt es halt Gatsby,

01:42:52.000 --> 01:42:54.000
das Weltkit und dann

01:42:54.000 --> 01:42:56.000
hätte man ja schon ganz schnell 50% gehabt,

01:42:56.000 --> 01:42:58.000
hätte man mal diese ganzen Namen kurz vorgelesen.

01:42:58.000 --> 01:43:00.000
Das ist auch schon echt eine ganze Menge Holz.

01:43:00.000 --> 01:43:02.000
Ja, aber ich,

01:43:02.000 --> 01:43:04.000
ich bin auch mental gar nicht bereit,

01:43:04.000 --> 01:43:06.000
nochmal so ein Framework

01:43:06.000 --> 01:43:08.000
durchzusprechen.

01:43:08.000 --> 01:43:10.000
Ich bin gerade eher auf dem

01:43:10.000 --> 01:43:12.000
Trip,

01:43:12.000 --> 01:43:14.000
dass ich nicht mehr weiß, wie gut

01:43:14.000 --> 01:43:16.000
oder schlecht es ist, wie viele

01:43:16.000 --> 01:43:18.000
verschiedene

01:43:18.000 --> 01:43:20.000
Frameworks es gibt, die das Gleiche lösen.

01:43:20.000 --> 01:43:22.000
Also ich finde es gut, dass es kein Monopol gibt,

01:43:22.000 --> 01:43:24.000
weil dann kann man immer von gegenseitig

01:43:24.000 --> 01:43:26.000
zu anderen

01:43:26.000 --> 01:43:28.000
lernen. Aber was ich, was mir jetzt nach

01:43:28.000 --> 01:43:30.000
Jahren ein bisschen zu anstrengend wird,

01:43:30.000 --> 01:43:32.000
was ist das Gleiche und diese Religiösität dazwischen?

01:43:34.000 --> 01:43:36.000
Ja,

01:43:36.000 --> 01:43:38.000
das ist halt das eine.

01:43:38.000 --> 01:43:40.000
Das andere ist halt,

01:43:40.000 --> 01:43:42.000
was mich halt so ein bisschen mehr so annärft,

01:43:42.000 --> 01:43:44.000
ist halt so diese

01:43:44.000 --> 01:43:46.000
Framework-Astronautik,

01:43:46.000 --> 01:43:48.000
wie ich das manchmal so ganz gerne nenne,

01:43:48.000 --> 01:43:50.000
wo man halt die einfachen Sachen nicht mehr

01:43:50.000 --> 01:43:52.000
einfach machen kann,

01:43:52.000 --> 01:43:54.000
im Namen des Paradigmas, das hier jetzt implementiert wird.

01:43:54.000 --> 01:43:56.000
Was einen überhaupt nicht stört,

01:43:56.000 --> 01:43:58.000
wenn man nicht so wie wir hier

01:43:58.000 --> 01:44:00.000
außer API's drinnen hängt und weiß,

01:44:00.000 --> 01:44:02.000
es könnte so einfach sein, ich könnte hier meine

01:44:02.000 --> 01:44:04.000
80-20-Lösung irgendwie haben.

01:44:04.000 --> 01:44:06.000
Aber

01:44:06.000 --> 01:44:08.000
wenn ich halt so mehr angucke, wie ich halt so

01:44:08.000 --> 01:44:10.000
versuche, irgendwie

01:44:10.000 --> 01:44:12.000
React auf eine Art und Weise zu bespielen,

01:44:12.000 --> 01:44:14.000
dass ich mir noch morgens selber ein Spiegel

01:44:14.000 --> 01:44:16.000
gucken kann,

01:44:16.000 --> 01:44:18.000
das ist schon nicht ganz trivial. Da muss man

01:44:18.000 --> 01:44:20.000
schon so manche Verrenkung für begehen.

01:44:20.000 --> 01:44:22.000
Und das ist halt irgendwie so sehr, sehr ärgerlich.

01:44:22.000 --> 01:44:24.000
Die Plattform bietet einem so viel Out of the Box.

01:44:24.000 --> 01:44:26.000
Und es ist halt nicht

01:44:26.000 --> 01:44:28.000
100 Prozent, was sie einem bietet,

01:44:28.000 --> 01:44:30.000
aber alles von Null auf nochmal neu zu

01:44:30.000 --> 01:44:32.000
implementieren.

01:44:32.000 --> 01:44:34.000
Und dann noch irgendwie da, also unreact,

01:44:34.000 --> 01:44:36.000
was ja irgendwie ein spezifisches Problem löst,

01:44:36.000 --> 01:44:38.000
dann Next.js noch dran zu tackern,

01:44:38.000 --> 01:44:40.000
was dann wiederum so die Dinge, die React

01:44:40.000 --> 01:44:42.000
nicht löst, noch irgendwie löst, aber halt so

01:44:42.000 --> 01:44:44.000
als nachgelagerten Schritt und nicht irgendwie so

01:44:44.000 --> 01:44:46.000
von Grund auf gedacht, sondern mehr so

01:44:46.000 --> 01:44:48.000
vom Ende her kommt. Das sind

01:44:48.000 --> 01:44:50.000
beides Technologien, die ich benutze.

01:44:50.000 --> 01:44:52.000
Also React und Next, da verbringe ich im Moment

01:44:52.000 --> 01:44:54.000
große Teile meines Tages mit. Deswegen erlaube ich

01:44:54.000 --> 01:44:56.000
ja halt eben da dieses vernichtende Urteil,

01:44:56.000 --> 01:44:58.000
weil ich mit denen wirklich schnell zu kämpfen habe.

01:44:58.000 --> 01:45:00.000
Und ich bin da mit einigermaßen produktiv,

01:45:00.000 --> 01:45:02.000
aber meine Güte, wenn ich

01:45:02.000 --> 01:45:04.000
kau trotzdem down auf der Tischkante rum.

01:45:04.000 --> 01:45:06.000
Es könnte so einfach sein,

01:45:06.000 --> 01:45:08.000
lasst mich doch einfach eine Webkomponent

01:45:08.000 --> 01:45:10.000
verwenden. Warum muss ich die...

01:45:14.000 --> 01:45:16.000
Lasst mich doch einfach eine Animation abspielen, wenn was

01:45:16.000 --> 01:45:18.000
passiert ist. Ach so, das Konzept ist

01:45:18.000 --> 01:45:20.000
passiert, gibt es gar nicht, weil es nur Daten gibt.

01:45:20.000 --> 01:45:24.000
Das ist unpraktisch.

01:45:24.000 --> 01:45:26.000
War das eine schöne Abschlussgede?

01:45:26.000 --> 01:45:28.000
Ich bin mir nicht sicher, ob das eine Abschlussrede war

01:45:28.000 --> 01:45:30.000
oder mehr so ein

01:45:30.000 --> 01:45:32.000
Rant, ein unkontrollierter,

01:45:32.000 --> 01:45:34.000
aber gut.

01:45:34.000 --> 01:45:36.000
Machen wir auf jeden Fall einen Abschluss drauf,

01:45:36.000 --> 01:45:38.000
wie wär's? Ja.

01:45:38.000 --> 01:45:40.000
Super, wir danken fürs Zuhören,

01:45:40.000 --> 01:45:42.000
danken für die Unterstützung auf Patreon,

01:45:42.000 --> 01:45:44.000
danken für die zahlreichen Kommentare,

01:45:44.000 --> 01:45:46.000
wo ihr uns erzählen könnt, was ihr

01:45:46.000 --> 01:45:48.000
von Skinny Jeans und Vue.js haltet. Bis zum

01:45:48.000 --> 01:45:50.000
nächsten Mal, tschüssi.

01:46:18.000 --> 01:46:20.000
und bis zum nächsten Mal, tschüssi.