In einem hochexzentrischen Orbit kreisen Vanessa und Peter um den diesjährigen Fragenkatalog zum State of JS herum. Bedingt durch zahllose Exkursionen schaffen sie es so gerade durch ersten ca. 20 % der Umfrage.

Schaunotizen

[00:01:50] State of JS 2022
Wir starten mit dem Proxy, von dessen Use Cases wir in unser beider Realitäten zu berichten haben. Promise.allSettled() ist weniger spannend, erlaubt uns aber einen Schwenk zum breiteren Konzept der Iterables. Fragen rund um Dynamic Import werden im Bundle mit Stilfragen rund um Skinny Jeans abgefühstückt, wonach Peter Nullish Coalescing und Vanessa Logical Assignment lobpreisen. Die Schockfrostung der Hölle erfolgt, also Peter (!) von seinen Vue-Abenteuern in Verbindung mit privaten Klassenfeldern berichtet und mit Vanessa diverse Fallen rund um String-Replacement (replace() ist eine Falle, matchAll und replaceAllsind viel besser) durchkaut. Beide Parteien scheitern in Folge daran, ihre Gegenüber von der Großartigkeit von Promise.any() und Array.prototype.at()zu überzeugen. Des Weiteren fallen uns zunehmend kürzer werdende Fun Facts zu Features wie Top-Level await, Temporal, Array.prototype.findLast(), Error.prototype.cause und Object.hasOwn() ein. Spätestens im zweiten Fragebogen, in dem es um Browser-APIS geht, verlässt uns ein wenig der Elan. Service Workers und Custom Elements sind alte Hüte, Shadow DOM darüber hinaus ohne Custom Elements nur bedingt interessant. Angesichts von Web Animations rafft sich Peter nochmal zu einem Rant wider die Frameworks auf, bei WebGL, WebRTC, WebSockets und WebSpeech müssen wir hingegen schlicht die etablierte Existenz der APIs anerkennen. Mit ein paar letzten Spekulationen zur Broadcast Channel API lassen wir die Folge ausklingen.
Transkript
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.
Liked it? Take a second to support Peter on Patreon!