Guten Abend, heute ist der 13.

Juli, wir fangen heute ein bisschen früher an, um halb acht schon.

Wir haben die Episode Nummer 290 vom Donautech Radio an den Mikrofonen, wie bereits gehört, der André und der Tom.

Ja, starten wir halt einmal ein bisschen früher rein.

Und ich glaube, wir haben ja vorher kurz in der Pre-Show quasi schon gesprochen.

Es wird ein bisschen AI-lastig werden heute wieder.

Ich habe ein paar Themen auf der Liste.

Und ja, wo soll man denn anfangen?

Wir haben auch so von den Meetups, wo wir waren.

Ich weiß nicht, ob wir da noch was sagen.

Das ist schon relativ lange her.

Ja, das ist schon wieder Ja.

Können wir vielleicht am Ende noch kurz schauen, ob wir noch was mehr wollen.

Also ja, fangen wir mit dem Vibe-Coding und du hast ja vor letztem eigentlich schon was draufgestellt da dann, Vibe-Coding mit React, gell?

Ja, habe ich das noch gar nicht erzählt.

Gell?

Aber ich kann mir schon ungefähr vorstellen, es geht auch darum, du hast ja mal gesagt, ihr sucht quasi für das Frontend-Developer, für React und so, gell?

Und da wärst du wahrscheinlich das selber auch ein bisschen mal angeschaut haben, damit du da ein bisschen mitreden kannst, sozusagen bei der Beurteilung auch was sagen kannst.

Ja, stimmt eigentlich, ja.

Stimmt, ja.

Also ich hab's gar nicht, den Punkt hab ich gar nicht aus dem Aussage drauf gesetzt, aber ja, stimmt eigentlich, wenn ich mir das genau überlege.

Ich hab damals halt dann so ein bisschen auch das Problem gehabt, dass ich halt die, oder die Herausforderung gehabt, dass ich halt dann Bewerbungsgespräche gemacht hab mit React-Entwicklern, habe aber selbst schon länger nicht mehr React entwickelt.

Ich habe einmal Freeland-mäßig ein React-Projekt gemacht, das ist jetzt aber auch schon wieder gefühlt vier oder fünf Jahre her.

Und in dem Bereich wissen wir ja alle, der ist halt so schnelllebig, dass da mein Wissen schon ziemlich angestoppt war.

Ja, genau.

Und ich habe mir halt dann gedacht, naja, okay, in diesem ganzen Bewährungsprozess habe ich halt dann auch überlegt, ich mag jetzt da jetzt irgendwie keine Live-Coding-Session machen.

Also erstens einmal, weil es natürlich dann für mich relativ schwer ist, mit weniger Erfahrung, dass ich so live dann auch ich selbst quasi da irgendwie judge.

Ich wollte aber auch nicht quasi diese Variante machen, so wie es andere Firmen machen, die den Bewerbern dann eine Aufgabe zukommen lassen.

Und der werkelt da irgendwas, aber ich finde das auch, also erstens mal denke ich mir immer, ja okay, wenn du Google bist, kannst du das machen.

Aber nicht, was du eine kleine Firma bist, wo du im Endeffekt dann vielleicht manche Leute sogar verschreckst oder so ein bisschen schon, wie soll ich sagen, wo manche da schon dann doch ablehnend entgegenstehen.

Weil die halt sagen, ja, Alter, wieso soll ich mir da jetzt vier, fünf Stunden hinsitzen oder einen Tag für irgendein Beispielprojekt und dann geht es vielleicht gar nicht weiter oder habe ich nichts davon.

Das verstehe ich auch.

Und ich finde es halt auch in Zeiten von KI dann halt auch relativ witzlos, weil, ich meine, dann generierst du es halt und arbeitest halt drüber und so, was vermutlich schon relativ viel machen werden, genau, einfach wegen einem Zeitfaktor.

Und jetzt habe ich gesagt, so, jetzt mache ich die Variante, dann generiere ich es halt selber, so eine React-App, arbeite halt selber drüber.

Und die Coding-Session, Ist halt dann daraus bei uns bestanden, dass halt der Bewerbungs-Assessment eben gekriegt hat.

Das war eben diese Form als generierte App.

Ich meine, ich habe schon drüber gearbeitet und so.

Genau, aber im Grunde eine generierte App.

Und ja, dann haben wir halt einfach drüber geredet, ja, in der Coding-Session.

Und ja, genau, das war einmal sehr interessant, weil da kann man mich erinnern.

Ich meine, das ist jetzt eigentlich schon Monate her.

Aber im Grunde diese App, die da, also ich habe das genau so, habe ich das glatt beschrieben.

Ja, so quasi, ja, Coding-Session, Assessment für React-Bewerber, Bewerbungsprozess, was kann man da für Anwendung verwenden, ja, sollen nicht jetzt alt komplex sein, sollen aber ein paar Views drin sein, ja, genau, so hat er ein bisschen poser beschrieben, ja, und der hat man halt wirklich quasi eine lauffähige, generiert.

Und das war eigentlich gleich beim ersten Mal damals, ist da was Laufiges rausgekommen.

Wie ich dann nachher gesehen habe, waren da ein paar fiese Bugs drinnen.

Aus dem aus, also ich weiß es, brauchen wir jetzt glaube ich nicht in die ganze Reacting einsteigen, aber es sind halt ein paar React-Konzepte verwendet worden, was zwar prinzipiell passt, aber die sind halt einfach falscher verwendet worden, und haben dann so Seiteneffekte halt ausgelöst.

Wurscht.

Genau, aber das war schon mal das erste Aha-Erlebnis, was ich gehabt habe, weil das, was generiert wurde, hat eigentlich bis auf die ganzen Bugs, wo man dann sagen kann, ja okay, ist eh absichtlich drin, ja.

War ja cool, wenn das der Bewerb halt auch herausfinden würde, dass da was hat, oder dass es nicht so geil generiert ist und alles Pipi-Fan ist.

Das war schon mal das Erste, ja.

Genau, ja.

Und Und wieso, dass ich jetzt eigentlich den Punkt aufgeschrieben habe, wir haben ja dann zum Klick ein wenig gefunden, die Person hat aber dann natürlich erst mit Verzögerung angefangen und wir haben dann halt schon einmal die ersten Schritte gemacht mit dieser React App, die wir da entwickeln.

Genau, mit anfänglich noch externen Entwicklern zwar, die wir halt für bestimmte Zeit dazugenommen haben, die Reakte vorhin gehabt haben.

Genau, und ja, und in dem, darum habe ich es aufgeschrieben, in dem React-Bereich oder vielleicht generell in dem Frontend-Bereich, wenn du ein bisschen was mit Technologien tust, die halt da verbreitet sind, ist es halt richtig krass, wie weit und wie schnell, dass du halt da vorankommst.

Mit einem AI-Coding-Tool jetzt.

Mit Cloud jetzt in meinem Fall, ja.

Weil ich habe zum Beispiel, weißt du, wir haben, also da geht es eigentlich um die Erstellung einer neuen App, die muss aber quasi bereits bestehende REST-Services hernehmen.

Und wir haben halt so API-Keys in unsere internen REST-Services, REST-APIs in Verwendung.

Genau.

Und ich habe halt dann quasi einfach, was ja dieser Mittelwert ist, die du da brauchst, wo du da irgendwo einhängen musst, bei irgendeinem HTTP-Client auf der Frontend-Seite.

Das kannst du halt quasi alles generieren.

Gibt es denn die API-Beschreibung quasi auch noch und so?

Genau, voll.

Und dann, weißt du, Testfälle, habe ich gesehen, okay, da nimmt man halt dieses V-Test her, zum Beispiel, kann man hernehmen, so, ja, geil, super, und wie schreibe ich, also wie mag ich da jetzt, weißt du, wie tue ich da?

Also bei G-Unit wissen die das gleich auf der Java-Seite.

Frontend-Seite, ja, keine Ahnung, aber halt auch da wieder, weißt du, da kannst du jetzt sagen, hey, generieren wir da bitte mal Tests und dann werden halt Tests generiert, für deinen Code, die halt schon mal die einfachsten Fälle, sage ich jetzt mal, halt abchecken, ja, und dann siehst du da gleich mal, okay, so wird beispielsweise das V-Test jetzt verwendet, aha, okay, so mag ich da, ja, oder so programmiere ich überhaupt mit dem, weil da gibt es ja jetzt auch wieder mehrere Ansätze, ja, bis du mit diesem Test framework da umgekannst und so.

Das V-Test, das V-I-Test, oder?

Ja, genau.

Halbe du eine, ja.

Ja, genau.

Also White ist ja der Package-Manager der Wahl quasi da im Moment da, gell?

Okay, ja.

Genau.

Genau.

Und ja, also es hat mir schon gedacht, wie, ich meine, es ist zwar dann natürlich, also es hat dann, diese Wochen hat dann ein React-Sino-Entwickler bei uns, ein Sino-React-Entwickler bei uns angefangen.

Der hat sich halt auch den Code so ein bisschen angeschaut und hat dann halt auch teilweise gesagt, Ja, kann man schon so machen, aber sollten wir uns vielleicht ein bisschen mehr überlegen und so.

Also der, ja genau, hat da schon wieder einen anderen Blick drauf gehabt.

Aber so, und das wollte ich jetzt damit sagen, wenn du quasi neu bist in einer Technologie jetzt einmal, aber vielleicht schon viel Erfahrung hast du mit anderen Webframeworks oder so, ist es eigentlich ein super Tool, mit dem du einmal erlernen kannst, wie quasi diese neue, wie es überhaupt vorgibt, bei dieser neuen Technologie, für die Implementierung von bestimmten Use Cases.

Ja.

Cool.

Ja, wir haben jetzt da auch gerade die Wochen einmal, eben witzigerweise, das schneit sich dann nicht voll gut, weil wir jetzt auch mal die Entscheidung getroffen haben, in gewissen Bereichen bei uns was mit React zu machen, zum ersten Mal.

Das kommt getrieben daraus, weil bei uns das Product Management und so ganz stark mittlerweile Lovable verwenden.

Haben wir ja schon mal quasi kurz erwähnt in einer unserer Episoden.

Ja, ich verlinke es nochmal.

Lovable auch.

Genau.

Oder Dev.

auf jeden Fall, die haben zum Beispiel jetzt für einen speziellen Use Case, was wir jetzt haben wir machen gerade eben so eine Jira-Integration für Diamond und so und da geht es halt darum dass du quasi, du musst einen, Konfigurationsdialog bauen, wo man dann eben auswählen kann aus dem Jira welche Projekte man synchronisieren will und welche Stati, und wo die dann hinkehren in Diamond, in welchem Aufgabenbaum eingeordnet und so weiter Es wird ein relativ komplizierter Konfigurationsdialog.

Und sie haben dann quasi schon mal angefangen, eben mit Lavable dort dann die Jira-API einzugeben und die Dimer-API und dann halt dort quasi wirklich einen Prototyp zu bauen halt, wie ein Paper-Prototype, aber der halt schon wirklich funktioniert mit den echten Daten.

Damit sie quasi da einfach voll schnell iterieren können und ausprobieren können und schauen können, wie sollte das ungefähr während der Dialog quasi, was wollen wir da für Funktionen drin haben und wie sollen die sich anfühlen und so.

Und dann stellt sich natürlich die Frage, okay, wir integrieren das dann halt wirklich dann in die Anwendung und was Loveable da generiert, ist halt ein React-Code.

Und dann haben wir gesagt, naja, macht das jetzt Sinn, den React-Code quasi zu nehmen, wo das eigentlich schon fast 90% fertig ist.

Man weiß ja, die letzten 10% brauchen dann am meisten Arbeit.

Aber man hat trotzdem jetzt schon mal irgendwas, was sehr weit gediegen ist und was eigentlich schon funktioniert.

Und das jetzt quasi vom Scratch nochmal in einer anderen Technologie nachbauen, macht das eigentlich Sinn?

Weil es ist schon relativ viel Code und umfangreich.

Und dann habe ich eben gesehen, beim Loveable, erstens haben wir den Code dann dort ein bisschen in der Webbaufläche angeschaut, den der erstellt hat.

Und den verstehe ich sogar halbwegs, also wie der halt strukturiert ist und aufgebaut ist, ist die ganze Komponente.

Das schaut ja sauber aus.

Du kannst ihn dann ja auch in einem GitHub-Projekt quasi synchronisieren.

Hast du dann den Code halt wirklich auch im GitHub liegen, kannst theoretisch du dann mit einem anderen Tool drauf weiterarbeiten, mit deiner Idee und den normalen Weiterentwickler und den wieder zurücksinken lassen, ins Laughable und da weiterarbeiten.

Also das ist schon eine ganz geile Plattform eigentlich für sowas auch, weil es einfach.

Die Arbeit, weißt du, gerade bei so Dialoge oft und so, ist dann eigentlich die Iteration oft so langsam, dass du das dem Developer dann gibst, weißt du, und dann deployt der irgendwann nach ein paar Tagen oder was, irgendwann die erste Testversion wo und dann kommst du halt drauf, nein, das habe ich mir aber anders vorgestellt und dann je nicht läuft, desto zirks dauert der oft Tage.

Und so kann das Projektteam eigentlich schon, ohne dass das technische, totale Know-how hat, wie das React-Programmieren geht und so, da voll schnell iterieren, bis der ungefähr so sich anfühlt und ausschaut, wie sie es eigentlich gerne haben wollen.

Das spart schon extrem viel Zeit.

Das ist cool, wenn du irgendeine gemeinsame Technologie hast, die du dann austauschen kannst.

Sind, sag ich mal, haben ja auch junge Leute bei uns im Team und so, die motiviert sind und wo ich sage, ja, wir müssen ja eh mal Richtung Web-Technologien auch uns weiterentwickeln und so weiter, sollte man ja auch doch einmal jetzt dann da React wirklich uns umhauen und, embracen quasi und sagen, wir lassen es auf das ein und du, wenn es neue Leute sucht, ist ja so, weißt du, du wirst ja keinen, erst einmal kannst du keinen einstellen, keinen Senior React-Developer, der dir deine Anwendung umbaut, wenn er dann kommt und das ist noch gar nichts in React und so, das geht auch, da fängt ja keiner an.

Ja, und zweitens mal, du hast es einfach leichter, wenn du schon React Code Basis hast und du suchst dann React Developer, weil einfach viel da verfügbar sind.

Ja, voll.

Ich meine, bei React ist es halt, das habe ich schon ein bisschen gelernt, jetzt auch mit den ersten Schritten, wo wir da jetzt quasi unsere Anwendung mehr oder weniger migrieren auf React.

Ja.

Ja, du, also gerade dieses ganze State-Handling und so in React, wo man sonst jetzt in die Java-Anwendungen eigentlich relativ wenig, glaube ich, darüber nachdenkt, weil du hast halt quasi die Session und so, ja, und speicherst du halt so.

Das ist halt voll das Thema immer bei React.

Und wir sind da gleich, also sogar quasi mit die zwei Externen, die wir uns da am Anfang dazugenommen haben, relativ schnell nach den ersten Views gleich mal schon eingelaufen, okay, jetzt haben wir da zum Beispiel so ein Rerendering-Zyklus, weißt du, weil ja du bei React ist es so, wenn du quasi so State-Änderungen, hervorrufst, dann macht der ein Rerendering von bestimmten Bereichen, ja genau.

Und wenn es halt richtig komplex ist, oder wenn es komplex sehr wird, richtig komplex ist es falsch, also wenn es weggeht von diesen einfachen Beispielen mit einer State-Variablen und so, dann weißt du schon langsam nicht mehr, okay, was löst jetzt da eigentlich ein Rerender aus?

Und dann kannst du richtig auch in so Loops reinkommen, weißt du?

Klar, verändert dann das UI quasi sich wegen einer State-Enderung und das UI, wenn sie sich verändert, ändert wieder den State und so weiter.

Ja, genau.

Ich meine, das Siegste ist eh nicht so, dass das jetzt irgendwie unbemerkt bleibt.

Aber da habe ich schon gemerkt, denke ich mir, puh, okay, wenn das jetzt bei den ersten Views schon ist, dann mag man schon irgendeinen Know-how-Träger haben, der zumindest schon mal die Erfahrung gemacht hat und einem da hilft.

Da gibt es ja, das React selber hat ja Patterns und Mechanismen, wie man halt State-Management macht.

Aber es gibt halt nicht nur das.

Es gibt halt zusätzliche Libraries und so weiter.

Ja, und der Kollege, der jetzt so neig bei uns angefangen hat, der hat halt schon mehrere große Reakt-Anwendungen für größere Kunden halt implementiert oder war da dabei.

Und der sagt halt, ja, das war halt bei einem immer voll das Thema, ja.

Also voll witzig eigentlich, habe ich mir dann gedacht, weil eigentlich nicht einmal so ein kurzes Zeichen für ein Webframework, wenn man sich über sowas, über so ein Spezifikum mehr oder weniger vom Webframework dann solche Gedanken machen muss.

Oder auch mit diesen Hooks, die es daheim haben und so.

Da musst du wissen, wann wird welcher Hook aufgerufen?

Blablabla.

Oder für was ist welcher Hook?

Wo darf ich was machen?

was wird im Rendering aufgerufen, was davor, was danach etc.

Aber ja, so ist das halt in React.

Hat seine Eigenheiten.

Aber es ist halt neben Angular halt voll verbreitet.

Was bei uns halt auch witzig war, wir sind halt auch am Anfang, wie wir jetzt quasi intern noch nicht das Know-how gehabt haben, sondern halt nur extern, sind wir halt im Grunde sehr wie halt so Java-Entwickler herangegangen, weißt du?

Haben halt dann gesagt, so auf der View, da brauchen wir jetzt zum Beispiel keine Ahnung, irgendeine Funktionalität, naja, machen wir halt einen Service dafür, so in die Richtung.

Nur dann kommst du halt drauf, so, ja klar, du kannst schon ein TypeScript Service-Klasse machen, nur du hast doch halt die Panalty-Injection oder irgendwas.

Das heißt, im Grunde, wenn du das mit Klassen halt machst, führt das im Endeffekt dann dazu, dass du halt, keine Ahnung, die Klasse halt dann irgendwo instanzierst oder irgendwo ein Singleton halt einfach generierst und auf das zugreifst, wo du dann schon mal denkst, ja okay, weiß ich nicht, sollte ich dann vielleicht eher funktionaler das programmieren, brauche ich da überhaupt Klassen dann dafür?

Lauter so Entscheidungen, also voll witzig, also was für, ja, wie viele Entscheidungen, dass man da am Anfang dann wieder zu treffen hat.

Mhm.

Witzig.

Ja, also, wie gesagt, so tief sind wir jetzt da noch gar nicht drinnen.

Das hat sich erst jetzt zwei, drei Tage so vor dem Wochenende gegeben.

Und da hast du da das Ding, okay, du nimmst dir jetzt mal den Code und schaust, arbeitest du mit dem weiter?

Und da sind wahrscheinlich halt diese Themen schon irgendwie auf Art und Weise halt dann ein Ansatz von dem da.

Muss man sich halt anschauen, wie das da gemacht worden ist.

Bin gespannt.

Ja.

So, ich habe auch die letzten, irgendwie, ich weiß nicht, vor zwei Wochen schon so gegangen, Alter, wann haben wir unsere nächste Episode, weil ich habe so viele neue Dinge jetzt mit AI-Tools gemacht, aber gerade mit Cloud Code, wo ich einfach mal drüber quatschen will, du unbedingt wieder mit dir.

Und bin ich richtig, ich habe den Hype-Cycle oder die Hype-Zeit gerade gehabt.

Ja, genau.

Also wir haben kurz geschrieben, du hast gesagt, du deployst jetzt gerade irgendwas.

was quasi Vibe gekodet hast.

Jetzt muss ich da mal, also ich habe mir das ein bisschen vorbereitet da dann schon.

Angefangen hat es mit mir eigentlich, dass ich diesen Artikel da gelesen habe, den postet jetzt mal eine.

Der ist von Peter Steinberger.

Das sagt da wahrscheinlich auch was, ein Österreicher, der das PS-PDF-Kit gemacht hat vor Jahren.

Das ist so eine PDF-Viewer-Library und so weiter für iOS.

Und der hat dann seine Firma verkauft vor ein paar Jahren und hat so nochmal eine Zeit Pause gemacht und jetzt ist er gerade wieder voll gestiegen ins Coding und Hacken und ist halt vorher auf dem AI-Zug gerade unterwegs mit all den Tools.

Und der hat dann da einen, er macht auf diesem Post gerade, auf diesem Blog gerade sehr viele Posts regelmäßig, aber er hat da halt einen geschrieben, der mir da irgendwie ins Auge gefallen ist sozusagen und der heißt Cloud Code ist mein Computer.

Und im Prinzip beschreibt er da drinnen, wie er halt in den letzten Tagen oder Wochen Cloud Code genutzt hat, und ich meine grundsätzlich, wir haben das ja schon ein paar Mal gesprochen, es wechselt halt ständig ganz stark, das wissen wir jetzt eh schon, wie sich die i-Tools so nach und nach immer wieder halt gegenseitig überholen und das eine, alle paar Wochen ist wieder das an der Spitze und das.

Ich habe mit Cloud Code schon mal ganz, wie es rauskommen ist, ein bisschen experimentiert, dann wieder ein bisschen liegen lassen, ein bisschen mehr mit Cursor gemacht und so weiter.

Aber jetzt die letzten drei Wochen würde ich sagen, ist eigentlich mein Main-Tool einmal Cloud-Code gewesen.

Und angeregt eben durch diesen Artikel.

Und er schildert halt, das ist da so krass, weil er halt einfach auch sagt, na ja, schau her, Cloud-Code ist im Prinzip jetzt in deinem Terminal drinnen und du kannst dann damit halt Sachen machen lassen, wo du halt vorher vielleicht gar nicht gedacht hättest, dass das irgendwie die AI für dich machen lässt.

Und er macht das auch quasi alles im YOLO-Mode, also quasi ignore all permissions, you may do everything so quasi.

Da gibt es so einen Parameter, dangerous is keep permissions.

Das heißt, wenn es so stark ist, das Cloud Code, fragt dir das auch nicht mehr bei jedem Ding nach, ob es das e-nodd-erf und das-nodd-erf und so, sondern es darf einfach.

Und er hat halt da so Sachen gemacht, wie zum Beispiel er hat Cloud Code verwendet, um seine neue Maschine aufzusetzen und von seinem Backup wieder herzustellen und so Sachen.

Also im Prinzip, wenn das Ding, das AI im Terminal drin ist, kannst du halt quasi auf deiner Maschine ja alles machen.

Und so hat er das ja auch betrieben.

Nicht nur so, dass es quasi innerhalb eines Verzeichnisses irgendein Code schreibt oder bearbeitet, sondern dass es halt wirklich alle möglichen Aufgaben halt auf seinem Computer erledigt.

Und er seinen Computer quasi nur noch steuert, indem er halt Cloud-Code sagt, was er halt zum Teil hat.

Und das hat mich dann ein bisschen zum Nachdenken gebracht und mir dachte, naja, da gibt es doch so Themen bei mir auch die ich halt gerne ein bisschen besser einerseits automatisieren möchte und aber auch die halt irgendwie, zu tun sind, aber ein bisschen vielleicht nervig sind oder halt allweil sozusagen für mich jetzt, weil ich die Zeit nicht dafür habe oder was, und ich habe jetzt da ein paar Sachen mitgeschrieben, was ich halt so gemacht habe in den letzten Wochen Ja, einerseits habe ich zum Beispiel meine ganzen YAML-Files für meine Kubernetes-Cluster in GitHub, in so einen Git-Repository organisiert.

Und da habe ich dann die ganzen Test Environments, die heißen halt unterschiedlich, was weiß ich, Web und Feature und Staging und so weiter.

Und eigentlich habe ich da überall sehr ähnliche Files drinnen, aber irgendwie habe ich dann zum Beispiel das Logging von gewissen Services, die wir da in verschiedenen Dingen deployed haben und neue Microservices und Integrations und so weiter, nicht ganz so sauber durchzogen.

Mal steht da immer vorne, mal steht es hinten, mal mit Bindestrich und so weiter.

Und dann habe ich halt klar einmal gesagt, hey, analysiere die Folder einmal mit diesen YAML-Files und diesen Testumgebungen da und schaue einmal nach, was da unterschiedlich ist und was da gleich ist und versuche da ein bisschen ein Schema abzuleiten vom Naming her.

Und dann hat er das gemacht, haben sich das angeschaut und dann nach ein paar Minuten hat er mir das ausgespuckt und dann habe ich gesagt, naja, jetzt ziehe ich mir bitte das auf dieses System zum Beispiel gerade.

Dann fahre ich mir halt über diese YAML-Files alle drüber und ziehe ich das halt gerade so, dass das einmal irgendwie ein einheitliches Schema hat von dem Naming, dass du quasi, du weißt, das Log-File für das Environment und für das Service heißt so und so und dann findest du das auch immer, wenn du nach die Log suchst und so Zeug.

Hätte ich sicherlich, wenn ich das selber gemacht hätte, auch natürlich alles machen können, aber es wäre halt mega aufwendig mit Compare und das alles zu analysieren, irgendwie niederzuschreiben und dann ein System aufzustellen, wie das sein könnte und so weiter.

Das hat einfach Cloud gemacht für mich.

Das ist voll gut gegangen.

Dann, Und da ist es dann so gewesen, dass das aber so viel verheißen, so viel Inhalt ist, dass das teile sich dann wieder einen Kontext gesprengt hat oder so.

Oder er mir gesagt hat, hey, ich habe das jetzt für das und das Environment gemacht, machst du selber für die anderen fünf.

Dann habe ich gesagt, nein, Bitch, mach eins nach dem anderen einfach was, mach das du für die restlichen fünf.

Ich will da jetzt kein Skript haben oder was das macht, sondern mach das einfach du.

Und dann hat er halt eine halbe Stunde oder so hingewerkelt.

Das war mal ein anderes Ding.

Dann habe ich ein ähnliches Thema gehabt, bei uns alles Management quasi die DT-Isses und so im Jira.

Und da habe ich halt schon irrsinnig viele Projekte drinnen über die Zeit, über die Dienstleistungsprojekte, über die verschiedenen Microservices und Backend und Mobile Clients und Android und iOS und was weiß ich was.

Und wenn dann einmal wer dazugekommen ins Team und wieder wer geht und wenn er mal Praktikant da ist und wenn du mit anderen eine externe Firmen zu haben, aber jetzt sind Städte drinnen, irgendwie so ein bisschen ein Wildwuchs, du weißt teilweise gar nicht mehr, wer ist denn jetzt da wo, bei welchem Jira-Projekt neu sein, in welcher Rolle und so weiter.

Und das, wenn du das im Jira anschauen willst, musst du durch, keine Ahnung, ungefähr 40 verschiedene Projekte durchklicken und da über reinschauen in People und Permissions und so weiter.

Und am Ende hast du irgendwie alles wieder vergessen, was du am Anfang gelesen hast.

Und dann habe ich halt auch einfach gesagt, hey Claude, schau mal bitte mein Jira über die API einfach nach, lese mal da aus, wer in welchen Projekten wo wie zugeordnet ist, welche Gruppen gibt es da drin, welche Rollen, welche User, ja, das brauche ich alles einmal, ich brauche das am besten irgendwie in einem übersichtlichen Markdown-Format oder sowas, damit ich das einmal anschauen kann dann.

Und dann hat halt er mir da so ein Mini, ich glaube, es war dann ein Python-Skript oder was gebaut, ja, mit dem er halt gesagt hat, hey, gib mir mal deinen Jira-API-Key da her, oder paste den am Ende da rein in die Environment-Variable und dann rufst du das Python-Script auf und dann habe ich mir das Python-Script ein bisschen angeschaut, ja, schaut cool aus und am Ende spuckt er mir da so Markdown-File halt aus.

Wo ich diesen auf einen Blick im Übersicht schön sehe, wer wo welche User zugehört, dann sage ich, ah, schau her, da hat der Kollege X, der ist ja vor einem halben Jahr schon ausgeschieden, aber der ist zwar nicht mehr aktiv im Jira, der kann nicht mehr rein, aber der ist noch bei dem und dem und dem Projekt zugeordnet, als Developer oder so.

Hey, klar, Räum dich einmal auf und lösch dich einmal überall raus.

Ah ja, passt, mache ich.

Schreibe dir eine kleine Zusatzroutine in das Python-Skript rein und sag, du rufst so auf mit dem Parameter von dem User die E-Mail und dann entferne ich den aus allen Projekten.

Wo ich mich aber selber wieder überall durch fünf Projekte durchklicken hätte müssen und so.

So geil, also solche Automatisierungen, die du da bauen kannst.

Jetzt habe ich halt, du hast ein Skript und das kann ich jetzt im Prinzip immer wieder erweitern um irgendwelche Fälle, dass ich sage, keine Ahnung, ich würde dann einmal einen User, den ich habe, bei allen Projekten zuordnen oder wegtan oder Gruppen machen aus den und den Leuten und den und den Projekten mit dem und dem Schema oder was.

Keine Ahnung.

Das kannst du alles jetzt über den Cloud einfach steuern.

Braucht nicht mehr im Jiraum klicken.

Krass.

Da kannst du jetzt quasi auch, sag ich mal, wenn es so ein Prozess setzt, wenn du anbordet oder aufbordet und so, da kannst du das eigentlich auch mit so Skripts dann einfach da machen.

So geil.

Dann habe ich, das muss jetzt Jetzt haben wir vielleicht auch Hörer, die nicht so technisch unterwegs sind mit diesen Tools.

Dann habe ich am Wochenende drauf, nachdem ich das die erste Woche alles so gemacht habe, noch was Witziges gehabt habe.

Zum Beispiel, weißt du, da haben wir am Wochenende Giosas gekocht wieder einmal.

Das sind so japanische Teigtaschen.

Und da habe ich immer ein YouTube-Video, was ich für das immer geschaut habe, wo der quasi das gezeigt hat, wie das geht.

Das muss jetzt dann raussuchen, das Giosa-Video.

aber es ist eh wurscht, das suche ich dann noch.

Auf jeden Fall wollte ich dann, haben wir gedacht, naja, ich tue meine ganzen Rezepte im Paprika verwalten.

Das ist so eine App vom, was ich auf iOS und Mac und so weiter halt überall habe, ja, und das synkt halt und daran wollte ich eigentlich das Rezept mit den Zutaten und den Zubereitungsschritten und alles drinnen haben.

Und, Dann habe ich gedacht, naja, jetzt frage ich dann mal Cloud.

Hey, Cloud, ich habe da das YouTube-Video.

Da erklärt er drinnen, wie man Giosas macht.

Und ich hätte gerne quasi die Zutaten, die er da verwendet, als Listen und die Zubereitungsschritte als Text quasi, damit ich das dann in meine Paprika reingeben kann.

Dann sagt Cloud, ja, kein Problem.

Da gibt es ja die Sicht, du hast da das YouTube-Download-Programm als Command-Line-Tool installiert.

Da laden wir einfach das Video runter, extrahieren das MP3.

also das Audio halt quasi einfach und schicken das durch ein Transkript durch, so ein Tool.

Da kommt man her, nehmen wir Visper AI von OpenAI, brauchen wir die nur noch von OpenAI so ein Key dafür, dann schicke ich dir das durch Visper durch.

Dann habe ich so ein Key erstellt auf OpenAI, habe ich das reingepastet, da, Key, und dann werke ich da, wenn du das Video aber transkribiert das mit, FFM-Pack quasi und bla bla, schicke das durch das Visper ein durch und ein paar Minuten spare ich, hat er das Transkript, was der da spricht in dem Video, am Ende tut er das Transkript noch lesen, tut die Zutaten extrahieren und die, Zubereitungsschritte und ich kann das in meine Pappencanny pasten.

Alter, krass.

Wie krass?

Ich hatte früher irgendwie, keine Ahnung, fünf Tools installiert oder irgendwas und herum probiert.

Und so sage ich ihm halt das, was ich gerne haben möchte.

Das ist...

Ja.

Und weil jetzt da noch gerade einfällt und da sage ich ihm das, das ist nämlich auch noch total relevant, auf das bin ich jetzt auch voll umgestiegen, das habe ich auch aus dem Peter seinen Artikel raus und zwar.

Der hat da die Empfehlung gemacht für dieses Whisperflow AI.

Ja, das ist, also ich habe mir eh schon ein paar Mal drüber geredet, ich habe das auch schon ein paar Mal gesagt, ich habe voll lange jetzt die OpenAI, ChatGPT Desktop App verwendet, quasi, um Text zu diktieren.

Man kann ja mit der OpenAI-Desktop-App normal reintippen in das Chat-Shirt-Fenster oder man kann ein richtiges Gespräch führen mit ihm, wo er im Audioformat zurückspricht und so weiter.

Aber was ich oft tue, ist einfach das Mikrofonsymbol zu verwenden, um ich spreche ihm was, mein Prompt quasi, und ich will es aber dann am Ende im Text haben.

Sodass ich es zum Beispiel auch einfach in Cursor umgekopiert habe oder in Copilot oder wo auch immer.

Und jetzt mit dem Tool, mit diesem Whisper Flow, das nutzt im Prinzip auch diese advanced, neuernd, guten, super guten AI-Transkript-Tools.

Und du kannst halt dann einfach, die Standard-Tasten ist glaube ich auf die Funktionstaste, das heißt, ich druck einfach auf die Funktionstaste, wenn das App am Mac läuft und dann sprich ich los.

Und dann hast du da so eine kleine App im Hintergrund halt laufen, die das komplette, was du sprichst, das Wort umwandelt in Text und teilweise eben sogar ausbessert, wenn es merkt, du versprichst dir und sagst, ah, nein, so und so, oder korrigiert Sätze teilweise ein bisschen auch, wenn du das irgendwie falsch vom Grammatikalischen her sprichst, aber es ist jetzt so geil, weil ich auch ein Cloud oft, da muss ich dir wirklich, der funktioniert jetzt saugut, wenn du den extrem gut beschreibst, was du haben willst.

Und da freut es mich dann eben allweil schon nicht so viel da reintippen, sondern ich spreche an das einfach halt, mit diesem Whisperflow, Und teilweise habe ich jetzt angefangen, E-Mails und was weiß ich, mit dem Whisper Flow einfach zu diktieren, meine Assistentin da sozusagen.

Und du halt einfach mit dem Whisper Flow Funktionstasten und sprichst du schon los.

Oder Slack-Messages und alles mögliche.

Du hast so viel, jetzt halt da reinzusprechen einfach.

Und gerade weil so prompt ist, ist das halt einfach krass.

Also, ich bin echt jetzt da oft davor geguckt und dachte, what the fuck, Alter, das fühlt sich schon echt an wie Zukunft jetzt, Teiler, es ist echt jeden Tag noch wieder, und das macht richtig süchtig, also es macht richtig süchtig, ich habe dann oft am Abend jetzt noch Sessions gemacht, weißt du, mein früher habe ich das auch oft getan, aber jetzt habe ich auf dem Kopf nicht mehr so frei gehabt am Abend, und jetzt bin ich so süchtig gerade wieder, nach, okay, jetzt fällt mir dann was ein, eben in jeder Minute irgendwo auch beim Abendessen, und ich habe echt so innerlich so ein Ding so, Alter, das kannst du ja auch mit dem machen und das auch.

Und dann schreibe ich mir selber schon so weg in so eigene Listen, dass ich das auch mal probieren müsste.

Und dann hucke ich mich wieder hin am Abend und mache Cloud auf und probiere halt wieder.

Und das ist echt krass, was das Teil, was ich mache.

Ja, krass.

Und was ich eben da deployed habe, das kann ich auch noch erzählen so, das war eben zum Beispiel, ich habe jetzt ein paar Mal geredet, das Manned Renovate im Einsatz, was ja quasi unsere Bitbucket-Repository scannet und da die Dependence ist quasi das Update-Vorschlag.

Und da habe ich jetzt das Erkenntnis halt gehabt, dass das halt dann oft so ist, wir haben jetzt sehr viele Spring-Projekte und wenn du jetzt zum Beispiel dann ein Spring-Boot-Upgrade von 3.4.5 auf 3.4.6 oder wie es jetzt ist, 3.4.7 oder so hast, dann schlägt dir das MandRenovate halt mal schon für zwölf Repositories dieses Update vor.

Also es erstellt in jedem von den Repositories, was du halt hast, wo du Spring Boot verwendest, ein Pool-Request, wo dann sozusagen die gleiche Dependency halt eigentlich updatet wird für alle diese Projekte.

Und da war es mir dann schon wieder teilweise zu mühsam, dass ich dann in jedes dieser Projekte gehe oder jeden dieser Pool-Requests, wo ich dann sage, ich schaue mir das einmal an bei einem Projekt oder was und sage, ja, minimaler Change und passt, ja, oder Spring Cloud oder whatever.

Es sind immer so ähnliche Dependencies, die halt alle in den Projekten drin sind.

Und dann sage ich, ja passt, die Pool-Requests, die Builds sind green und jetzt muss ich da überall durchklicken, Approve, Merge, Rebase und fast forward.

Approve, Merge, Rebase, das zwölfmal.

Ja, so.

Da habe ich mir ein Tool gebaut dafür.

So, das habe ich gesagt, du Claude, da, ich möchte halt gerne ein Tool, was man in einer Oberflächenheit über die Bitbucket-API, abfragt, welche Pool-Requests es dort gibt und wenn die von dem Tool mehr und Renovate sind, sollen die da aufgelistet werden, ja.

Und dann, ja, und dann habe ich mich halt da hin iteriert, dass der, okay, dass ich es noch sortieren kann und dass ich mir den Bildstatus da anzeige, ob er grün oder rot ist und dass ich mir halt, dass ich gewisse Projekte sozusagen da ausfiltern kann, die nicht quasi managen.

Und ja, jetzt kann ich einfach in dieses Web-UI gehen und sehe dort alle diese Pull-Progress von Manned Renovate und kann man es dann eben sortieren nur noch und dann sehe ich die gleichen von dem gleichen Update her und kann da auf Multi-Select-Checkbox einfach links mehrere hinklicken und dann oben rechts am Button klicken und sage einfach Approven Merge.

Und dann tut man eher über die API von Bitbucket, die alle Approven, Fast Forward, also Rebase Fast Forward Merge.

Von zehn Projekten auch gleichzeitig.

Das ist auch geil.

Spart mir so viel Zeit schon wieder.

Und das Tool war in einer Stunde, da was gebaut.

Krass, ja.

Ja, ich habe mir da ja die Woche einmal, also das Cloud-Code, das ist ja, ist das immer nur jetzt mit diesem, da brauchst du quasi ja ziemlich teuren Account, oder?

Naja, es gibt mehrere Varianten.

Also der Steinbieter Peter Steinberger schreibt in seinem Post, also das zahlt sich selber quasi, wenn du die 200 Dollar Max-Variante nimmst.

Aber ich habe sehr lange zuerst die ersten Experimente, die ich in der Zeit gelesen habe, habe ich so gemacht, dass ich den API-Key einfach verwendet habe.

Du kannst einfach ein Gratis-Account beim Thropic haben zum Beispiel und da kannst du API-Keys ausstellen.

Zahlst du quasi pro Token.

Wirst halt nach Tokens abgerechnet.

Und da ist Cloud Code dann schon relativ gleich einmal, das braucht dann schon einiges, wenn du da mal hinwegst zu einem Tag, dann habe ich gemerkt, okay, wenn ich das in der Intensität weiterverwende, habe ich gleich einmal 10 Dollar, 15 Dollar oder so an einem Tag verbraten.

Und dann habe ich gesehen, okay, sie haben das dann aber changed, Du hast quasi bei der Anthropic, wie heißt dieser Plan da dann, du hast dann in dem klärnsten Anthropic Pro-Plan, der eben glaube ich 20 Dollar im Monat kostet, auch schon Cloud Code dabei, aber halt nicht quasi in der Menge an Requests, was du halt bei dem Max hast.

Und da kommst aber auch schon viel wie weiter, es kostet dann quasi, keine Ahnung, 20 Dollar im Monat und vorher hätte ich das ja fast mit dem Rp-Token in einem Tag verboten.

Und da kommst du aber so weit, das habe ich dann in der Zeitung probiert, eine Woche lang habe ich mit dem gearbeitet und da ist dann so, da passiert es mir dann schon ab, dass ich, keine Ahnung, am Nachmittag irgendwo mal um 4 oder so eine Meldung kriege, hey, du bist jetzt am Limit von dem Plan, das Token-Volumen wird um 8 Uhr am Abend wieder resetet oder so.

In das bin ich da schon eingelaufen auch.

Bis jetzt komme ich mit dem aber noch durch, sage ich mal.

Es könnte aber auch durchaus sein, es gibt dann noch einen anderen Layer mit 99 Dollar oder sowas.

Wenn ich jetzt mal wirklich, so wie es jetzt im Moment ausschaut, nehme ich fast kein Kurser mehr und fast kein Co-Pilot mehr, dass ich das andere wieder storniere.

Es ist eh so, sie sagen eh alle, du ja nicht irgendwelche AI-Tools auf der Jahresbasis kaufen.

Das ist einfach so krass.

Sie sind zwar ein bisschen billiger, wenn du es ehrlich zählst, aber du weißt nicht, ob du das nächste Mal dann hernimmst und nicht was anderes wieder hernehmen willst.

So arg wechselt ist die ganze Zeit.

Deswegen hat mir das mit Token auch ganz gut gefallen, dass ich einfach on demand jetzt mal das abrechne, was ich halt brauche.

Ja, aber das hat mich echt brutal fasziniert, was da jetzt gegangen ist mit dem.

Ich habe echt das Gefühl, dass ich wieder mal weiterkomme einfach in gewisse Dinge.

Richtig was weiterbringe.

von meiner Tat nicht sein.

Okay, okay.

Ja, da ist ja eh, warte mal, jetzt habe ich da den Link nicht so gemacht.

Google hat ja auch was released.

Und zwar gibt es ja quasi von Google seit, wann haben sie denn?

Eigentlich ist ja schon wieder zwei Wochen her.

Gemini CLI.

Genau, im Prinzip haben wir jetzt eigentlich eh alle dann schon so ein Command-Dein-Klein-Tag.

Genau, bei OpenAI, die sind glaube ich auch noch Cloud-Code, oder?

Ja, ich habe das Codex gemacht.

Hast du das glaube ich auch?

Codex?

Genau.

Ja genau, das Gemini CLI, das ist halt auch im Grunde so, das installierst du halt als NPM, als globales NPM-Tool sozusagen.

Genau, dann musst du halt deinen Google-Account dahinter legen, besser gesagt, glaube ich, sogar so Google Cloud Project habe ich, glaube ich, dahinter liegen müssen.

Also der wusste, nämlich dann dieses Gemini Cloud Feature dann aktivierst, quasi in dem Projekt.

Okay.

Genau.

Und der sagt dann auch gleich beim Ausführen so, hey, leg mich oder start mich bitte gleich in einem projektspezifischen Verzeichnis, weil ich habe gleich mal im Home-Verzeichnis gestartet, das erkennt aber dann auch gleich.

Ja, das hat der Cloud auch mal gar nicht, ja.

Genau, und dann fragt er dich, am Anfang fragt er dich halt immer, wenn du zum Beispiel irgendwie sagst, hey, kannst du mir das nicht committen oder hin und her, dann sagt er halt, ja, weiß ich nicht, darf ich halt Git immer verwenden oder nicht und so, sagst du halt dann, weiß ich nicht, immer und ja, je mehr, dass du den halt dann verwendenst, desto mehr ja, darf er halt auch im Grunde, desto mehr Berechtigungen sammelt er halt auch.

Genau.

Und desto mehr lernt er halt auch über das Projekt.

Da gibt es eben, also der Cloud schreibt ja so ein verstecktes File auch mit seinen Permissions, das er teilweise im Home-Ablick und teilweise auch in die Projekte selber.

Und da schreibt er immer mit, welche Permissions du ihm schon gegeben hast.

Ja, ich habe nur, das haben wir dann gar nicht ausgeschaut, ich habe nur einmal gehört von wem, dass der, naja, das weiß ich gar nicht.

Schau mal, ich habe nämlich damals so ein Beispielprojekt einmal gemacht.

Gemacht, na na, da sehe ich jetzt nix.

Okay, dann sprechen wir das vielleicht irgendwo zentraler oder sowas, ja.

Aber irgendwie merkt man sich.

Es ist ein bisschen pro Projekt.

Genau, also da gibt es eigentlich auch keinen Dot-Ordner oder was in dem Projekt.

Also ich glaube, ich meine, was ich ihm halt aufgelegt habe, aber das alles nichts mit den Berechtigungen zu tun, das ist glaube ich auch bei Cloud-Code auch so.

Du kannst ihm halt, weißt du, so ein Gemini-Markdown-File ins Hut vom Projekt legen.

Genau, das heißt, du hast einen Finger, der fragt Load-MD, ja?

Ja, genau.

Was du ihm halt dann einschreibst, hey, pass auf, das ist jetzt, was weiß ich, Java-Web-Applikationen, hin und her mit Java 21 und bladiblupp.

Genau, also das Cloud, da gibt es ja so einen eigenen Init-Befehl auch, wenn du das zum ersten Mal kannst, quasi in einem, Projekt, in einem Direktor bist, wo du halt vorher nicht was mit dem, sagst du halt einmal Init und dann schaut er, sie analysiert halt das Directory und leitet schon mal dieses Cloud-MD-File halt aus dem ab, sozusagen.

Er sagt halt dann, okay, das ist ein Java-Projekt mit Spring und so weiter, das schreibt alles in das Ding halt selbstständig mal rein und du kannst halt dann noch adaptieren und anpassen und dann das, an dem hält er sich quasi halt an, wenn du dann irgendwie Sachen auftragst.

Das ist ganz cool eigentlich.

Das Problem ist halt bei mir, so jetzt in der Arbeit, durch die Anstellung jetzt, haben wir da noch keinen Konsensus sozusagen, welche Tools, dass wir da verwenden dürfen.

Das heißt, ich kann es jetzt leider an einem echt, also real-world-Projekt nicht wirklich jetzt verwenden, an einem großen, weil da war es natürlich voll interessant, wie weit das man jetzt in der täglichen Arbeit kam hat.

Ich verwende es halt nur durch das, dass ich quasi selbstständig auch noch in ein paar kleinere Projekte halt dann tätig bin.

Verwende es halt dort ab und zu.

Aber ja, da bringt es mich jetzt halt weit nicht so viel an diese Spielerei.

Oder vielleicht braucht es mir viel, aber ich habe halt da meistens dann Zwingzeit, dass ich dann, mit den Sachen spiele.

Da mache ich einfach die Anpassungen meistens gleich und ohne AI und so.

Ja, viel.

Aber ja, es ist echt so krass, ja.

Also ich weiß noch, wir haben vor, bei uns gibt es quasi so einen, im Unternehmen halt so einen Prozess, der heißt halt AI-Kompass, ja, wo halt quasi Leute so AI-Tools, die es halt verwenden wollen, quasi einmelden einmal.

Und dann gibt es halt so einen Prozess, wo dann auch Legal und so weiter drauf schaut.

Genau.

Und wir haben halt vor zwei oder drei Wochen oder was da was eingekippt.

Und es geht halt alles so schnell.

Und jetzt müssen wir jetzt eigentlich schon wieder ganz andere Tools eingekippen.

Eigentlich mag ich jetzt Cheminise, also Cloud Code oder irgendwas verwenden.

Oder vom USA Cheminise.

Oder so.

Das ist so schnell ändert einfach.

Das ist so, dass da kommt keiner hinterher so richtig.

So wild.

Ja, was wir da auch noch einfach, ich weiß nicht, hab's letztes Mal vielleicht, MCPs haben wir ja auch schon ein bisschen erwähnt und das Cloud kann ja auch.

Mit MCPs und da habe ich jetzt auch mir sehr stark geholfen, einfach weil, ich meine, ich bin halt oft in so einem Flow drinnen, wo ich gleich konkret irgendwie ein Thema halt mir annehme und ja, da freut es mir dann oft da nicht im Vorhinein groß eben eine Jira-Issue und so weiter anlegen, weil ich einfach eher schon im Doing bin und da habe ich jetzt immer wieder so Fälle gehabt, wo ich gesagt habe, okay, da ein Stacktrace im Monitoring aufgedacht, ja, shit, okay, da ist der eine Nullpoint da, passt nicht oder so, dann fixe ich das gleich direkt im Code, weil ich da dabei bin.

Oder ich mache gerade etwas anders und strappe über ein Problem drüber und mache das auch gleich mit oder so.

Und das ist auch wirklich krass im Klar zu sagen, okay, Pass auf, ich habe jetzt den und den speziellen Folgen entdeckt und, Jetzt tun wir du quasi das, was ich jetzt gerade gemacht habe.

Commit mir das einmal, leg mir das auf einen eigenen Brunch, weißt du?

Und das gibt es euch, kann ich alles voll super machen.

Und dann, ja, und jetzt fixen wir das Problem da dann noch, das, was ich jetzt entdeckt habe.

Und dann am Ende, ja, passt.

Ich meine, er führt auf den Adidas zu Hause und tut einen Klick, ich selber ein bisschen durch im Web und so.

Ja, passt.

Dann sage ich mir, ja, so.

Jetzt legen wir bitte für das im Jira, im Project Timer, ein Issue an.

Machen Brunch dafür und kommit das dort.

Dann checkt er schon, was du aus dem Kontext, was du vorher schon mit deinem Gret hast, quasi bei dem Fixen von dem Bug, was er in das Jira-Isch eigentlich einschreiben muss.

Also du musst ihm da gar nicht mehr noch extra viel beschreiben.

Oder du hast ihm quasi schon ein Stacktrace vorher gegeben, was du aus dem Monitoring hast und so.

Das haut er dann auch gleich mit noch in das Jira-Isch rein.

Dann kriegt er wieder die MCP-API von Jira zurück, den Link und die ID und alles.

Und dann legt er da den Branch so an, committet das, macht da schöne Commit-Messages, und dann sage ich, dann push ich halt noch selber zum Beispiel.

Oder dann sage ich ihm, push du.

Und dann wechselt wieder auf den anderen Branch.

Und das macht er alles, diese zehn Schritte.

Wo ich normalerweise ins Jira gegangen bin und dann create new issue und da, da, da, da, copy-paste von da nach da.

Das macht alles er.

Das ist so krass.

Da gibt es ja diesen einen Jira MCP-Server, wo ich mich erinnert habe, da auf GitHub, da siehst du quasi schon so ein GIF oder was da läuft, oder ist es ein Video?

Ja, also es gibt eben diesen MCP, so ein Docker-Image gibt es.

Und was aber auch so ist, dass Atlassian mittlerweile einen offiziellen MCP-Server hat, mit dem du einfach quasi nur noch die Uhr ins Cloud einpasten musst.

Und Cloud versorgt dich dann noch, hey, er lockt dich da mit der Uhr ein, mit der Uhr auf und so.

Ja, da habe ich da meinen Link gerne.

Also Atlassian hat da wirklich einen eigenen MCP, wo du halt das schon voll unterstützt hast für ein Verklagen.

Das geht super gut.

Oder eben auch so Dinge, hey, Cloud, nimm dir mal das Issue sowieso und bauen wir das um, was da in der Mische steht.

Dann holt er sich das und sagt, ah ja, wenn das gut beschrieben ist, geht es schon dahin.

Ich habe ja gesehen, bei JetPrincy AI und so, da kannst du quasi auch eigene MCP-Server und so eintragen.

aber ich weiß nicht, ob es das quasi dann aus Chatprints eher heraus dann quasi genauso nutzen kann, das theoretisch.

Ja, also du kannst, das habe ich auch vorher probiert, du kannst im Cursor und im IntelliJ beim Co-Pilot auch die MCPs ganz normal hinterlegen, auch die von Atlassian, habe ich da auch probiert, auch dort nicht zu sagen, okay, legen wir da das Issue dann dazu an oder holen wir die Information aus dem Issue, was du machen sollst und so.

Geht genauso.

Ja.

Aber jetzt im Cloud ist es voll cool integriert bei mir, weil ich jetzt so viel mit Cloud halt noch habe.

Deswegen taug es mir da halt gerade extrem, dass das so einfach geht, auch mit einem MCP zum Konfigurieren und alles.

Ja, also, aber teilweise ist es jetzt so, das schreibt jeder Peter in seine Blogpost, du brauchst teilweise gar keinen MCP, weil Cloud halt einfach auch direkt die API ansprechen kann.

Weißt du, wenn du in einer Variable, wo du ein AdLessian, also ein Jira-API-Key wo liegen hast, sozusagen, dann sagst du ihm halt, hey, mach ich direkt du den Jira-API Call da.

Oder baue dich das.

Das kann er ja.

Das ist nur Curl und so quasi.

Das ist echt krass.

Ich habe mir dann von Gemini gesehen, also ich habe da ein Projekt, das habe ich jetzt schon quasi, weiß ich nicht, ein halbes Jahr nicht mehr angegriffen.

Also von der Selbstständigkeit noch.

Und jetzt ist halt wieder was da herkommen, ja, und dann haben wir echt einmal von Gemini nur mal erklären lassen, was da bestimmte Views jetzt überhaupt machen oder klassen.

Und das ist einfach so arg, weil er da ziemlich richtig eigentlich liegt, ja.

Der ist so, hey, kannst du mal beschreiben, für was man die und die Klasse da eigentlich braucht, welche Rolle spielt das eigentlich da in dem Service und da, da, da.

Und der spuckt dann einfach raus, ich da, ja, gescheiten Bericht.

Ja, es ist schon wild.

Ja, ich habe jetzt auch bei Kundenprojekten und Dienstleistungen, wenn du das hochfährst, waren immer so Warnings im Log, weil es da immer gedacht hat, das Warning kannst du eigentlich auch mal aufräumen, von wegen, dass da irgendeine Library ein Puff ist, was eigentlich Duplicate ist und dann war es in den Wüchern, keine Ahnung, so Sachen.

Ja, hey, klar, bereinigen wir das da mal.

Ja, das ist, weil die Library im Gradle, da haben sie mit dem und das landet die Version von der und ja, mache ich gar nicht, da habe ich das Clue deine, ja, passt schon.

Das ist so krass.

Dass der jahrelang habe das irgendwie so herumgenommen hat.

Ja, aber jetzt wollte der mal schauen, dass das sauber ist und alles wieder am neuesten Stand und zack, das macht halt Ärger.

Ja, muss man mal schauen.

Wenn sich da mal dann der ganze Staub gelegt hat, oder?

Ja, was dann quasi so das Standard-Tool oder so, was wird dann für jeden?

Ja, also wie gesagt, eben der Staub, es wirbelt ganz schön noch, weil einfach die ganze Zeit jeder mit einem geilen Ding da herkommt, aber eben so, dass jetzt quasi so CLI, also Terminal AI Tools gibt, glaube ich, das ist schon, da merkst du einfach, die anderen sind auch alle jetzt nachgezogen, und da ist schon was dran, also das ist, glaube ich, schon ein cooler Weg, weil du halt auch, und da habe ich heute nicht mehr gebookmacht, einen Twitter-Post habe ich da irgendwo gelesen, so quasi, naja, es ist halt auch viel günstiger, als wenn du halt deine eigene IDE forkern musst und so weiter, so wie es gehört halt dort, und dort die ganzen Sachen AI-mäßig integrieren musst, ist doch auch viel praktischer, du bittest dich einfach als Command-Line-Terminal-Tool an und jeder kann in seiner IDE bleiben, wo er halt gern ist.

Ja.

Weil ich kann ja eben parallel ganz normal, ich habe IDE IntelliJet offen und Terminal halt sozusagen parallel ghosty halt offen von da Cloud mit dem gleichen Folder.

Ja, geht auf jeden Fall, ja.

Und die tue halt immer so parallel halt einfach.

Also der führt den einen Test oder startet den einen wieder hoch, wenn der Cloud was umgebaut hat und so weiter halt.

Ja, wie wird man es recht viel anders machen?

Geht es sein, dann trotzdem Sprachbefehle, die man quasi da reinkippt?

Ja.

Also auch wenn du das im IntelliJ jetzt machst, es würde am Ende des Tages trotzdem irgendwie so chatmäßig passieren.

Ja, das Wundzige, was ich da sage, war, dass ich einen Block markiert habe oder so irgendwas.

Ich habe bearbeitet genau die.

Teil oder so, das ist noch was anderes, aber das habe ich jetzt auch teilweise schon da aufgehört, dass ich einfach sage, okay, in der Klasse, ich paste dann einfach den Full-Reference-Pfad quasi rein oder zu der Methode hin sogar und sage halt, bauen wir die um, dass das nicht tut oder so.

Okay.

Das checkt ihr auch ganz gut.

Ich habe jetzt mal größere Sachen probiert, da tut es ein bisschen schwerer, also ist eh klar, habe ich eh noch nichts erwartet, aber kommt man auch schon extrem weit, sowas wie zum Beispiel, extrahieren wir aus meinem Gradle Multimodule Project noch ein weiteres Modul und ziehen wir den Controller und den Controller und so weiter in das andere Modul um mich.

Mit allen abhängigen Services und so weiter halt dann, weißt du?

Da werkelt eine Zeit dahin, macht man das Modul, macht man die ganzen Gradle-Sachen für das Modul richtig schon, kopiert dann den Controller und ein paar Services um mich, aber naja, da war dann auch noch.

Ja, das ist halt dann schon richtig komplex danach.

Oder?

Ja, es ist schon richtig komplex und der Kontext wird halt dann irgendwann riesengroß, ja, weil das sind dann halt einige Klassen gewesen und einige große Klassen, die er halt mit umgeziehen muss und dann er tut dann schon immer wieder, weißt du, er hat halt keinen richtigen Compile-Class, das merkst du schon, kein Syntax-Tree, der, weißt du, so wie IntelliJet das halt aufgebaut hat, quasi wäre er vom Weg.

Sondern er macht nicht das alles mit Cut und LS und was der mit so Textding halt einfach, das ist halt was anderes.

Naja, voll.

Da, puh, da stehst irgendwo wahrscheinlich dann auch, gell?

Weil im Grunde, du müsstest ja dann auch wissen, semantische jetzt, okay, jetzt bei deinem Multimodul-Projekt, okay, welche Module geben ja zum Beispiel, welche Dependence ist dann transitiv auch weiter, oder halt auch nicht.

Und so, weil das ja nicht ein Tipp-Enders ist, dass du das neue Modul überführen musst, wenn jetzt eine von den kopierten Klassen irgendeine Bibliothek oder so erwähnt.

Das ist dann schon richtig schwierig.

Das ist dann nicht mehr so reine Textmanipulation oder Dateien umeinanderschieben.

Aber das ist ganz witzig, weil du trotzdem, das läuft halt in so einem Terminal mal hin, dauert halt eine halbe Stunde oder irgendwas und da weitest du nicht was anderes und dann schaust du dir mal nach, wie weit ich bin bei dir.

Wer weiß, was der vielleicht da sieht, tatsächlich keine Ahnung, eine AI, die halt noch zusätzliche Kontextinformationen aus IntelliJ zum Beispiel erzählt, wenn wir uns wieder über das Chatbrain, vielleicht ein leichter, wenn man dann sagt, okay, pass auf, dann müssen wir die Dependencies noch aufbereiten irgendwie in Textform, weißt du, dass du halt dann doch irgendwie dann aus der finst okay was gehören solche module eine und so geschichten, Also ja, das ist auf jeden Fall noch ganz schön.

Ich glaube, gerade in der Software-Entwicklung, was du da hast, durch das, dass du halt den Quellcode schreibst und durch das, dass der Quellcode Statements beinhaltet, so wohl definierte und so, ist das halt auch voll das Paradebeispiel eigentlich für so Reasoning und Large Language Models und so.

Ja, ja.

Ja, also da fühlt er sich ja wohl.

Und das merkt man einfach, dass es da gescheit, das merkt man einfach, dass er sich da wohlfühlt.

Apropos wohlfühlt, gerade so von einer Struktur in eine andere überführt und so, das kann er halt auch voll gut.

Und wir haben jetzt eben letzte Woche dann die erste Dimer-Version seit Jahren dann deployed, die Conqueror, wie man halt.

Wahnsinn.

Das ist ja meisternd.

Powered by AI.

Powered by AI und bei dir.

Also ich habe schon viel, ja.

Aber AI hat mich stark dabei unterstützt.

Hätte ich niemals für möglich gehalten, wenn es keiner vor zwei Jahren noch oder so, dass die es in so einer Zeit sich machen lässt.

Aber eben da war dann am Ende auch noch ein so größerer Block drinnen, wo halt sehr viel groovy Metaclass Magic war und so, die da eingesetzt worden ist.

Da wurde dann auch eher einen echt geilen, wo die AI das eigentlich auch gut, auseinandergedröselt hat in statische Sachen, doch nicht einfach von Java.

Und gerade so Sachen eben, Konvertierung von Spock-Tests nach JUnit und so weiter mit SRJ und so weiter, da kannst du nicht die ganzen Klassen konvertieren, die 5000 Zeilen haben, aber so Stück für Stück, das geht schon extrem gut.

Und so haben wir es jetzt dadurch geackert.

Und jetzt ist es geil, jetzt ist kompiliert wieder alles statisch.

Ja, schon cool.

Jetzt habe ich nur noch ein Kundenprojekt der Urwelt ist, was in Grails ist, aber sonst ist alles jetzt ein Spring Boot, Java, Kotlin.

Sehr schön.

Wenn wir gerade bei den Java-Projekten sind, mache ich gleich mit meinem kleinen Punkt weiter.

Ich weiß nicht, haben wir, das war schon ein Podcast-Thema, das J-Specify.

Letzte Episode, glaube ich, haben wir ausführlich durchgekriegt.

Letzte Episode, genau, werden wir vermutlich auch von der Spring oder das Video verlinkt haben.

Genau, haben wir das Video gekriegt.

Okay, passt.

Dann war das eh.

Genau.

Ja, dann habe ich mir gedacht, passt, oder wie fangen wir, genau, in unserer React-App fangen wir mal so an, haben wir halt irgendwo einmal dann auch den Anwendungsfall gehabt, dass wir quasi für bestimmte Rest-API, also ich kürze das jetzt ein bisschen ab, es stimmt jetzt nicht ganz, aber ich sage mal so, für bestimmte Rest-APIs wollten wir halt TypeScript-Stubs generieren.

Genau.

Und da gibt es quasi ein Tool, was wir da verwenden.

Und das Tool kann quasi aus so Java-Beschreibungen von REST-APIs einfach TypeScript-Stubs erzeugen.

Ja, genau.

Und je nachdem, wie halt dann zum Beispiel ein Schnittstück auf der Java-Seite dann annotiert ist, mit Annotationen, fällt halt dann auf der TypeScript-Seite der Typ halt dann so raus aus diesem Stub-Generator, dass zum Beispiel, wenn du jetzt, was weiß ich.

Eben nichts annotierst und da gibst zum Beispiel irgendwo eine Liste zurück in irgendein DTO von Strings, dann würde er das im TypeScript so definieren, dass es ein Array ist, von String oder Undefined.

Also was du im TypeScript kannst, kannst du ja die wildesten Typdefinitionen haben.

Und da kannst du zum Beispiel sagen, hey, in dem Array, sind jetzt Strings oder halt Undefined drinnen.

Und dann schreibst du wirklich Array dann mit der Ecke in Klammer halt, String oder Zeichen mit der Pipe, Undefined.

Ja, genau.

Und das kannst du aber vermeiden, indem du halt mit so Jspecify und so auch den DTO schon gescheit annotierst.

Und den Java DTO.

Und wieso jspecify?

Weil jspecify das kann im Gegensatz zu die Spring Framework Non-Null Annotations, dass du zum Beispiel bei generischen Typen das dazuschreibst.

Also du kannst dann auf der Java-Seite schreiben, List of Non-Null String.

Okay.

Das geht mit der Non-Null Annotation von Spring Framework nicht.

Darum, lange Rede, kurzer Sinn, haben wir gedacht, passt, stelle ich alles umgleich in unserem Monorepo.

Why not?

Ist ja quasi ein simples Search und Replace.

Ja, puh, im Grunde war der Anfang einmal simpel.

Also die Annotations von dem Spring Non-Null auf die J-Specify.

Ja, genau.

Also das J-Specify, da sind ja glaube ich nur vier Annotations drin.

Genau, ja.

Das ist Non-Null, Null-Label und dann noch zwei andere.

Für die Packages, die Marken Null-Label oder irgendwie sowas.

Ja, genau.

Und es ist quasi zum Ersetzen relativ easy, weil du ersetzt sozusagen orgspringframework.lang.null-Label mit org.specify.irgendwas.null-Label.

Also eigentlich nur ein Package.

Ja.

Präfix, Replacement sozusagen, wenn man so mag.

Genau.

Habe ich mir gedacht, dass das so ist.

Dann aber hat es gleich mal getuscht, weil wir verwenden ja Arch-Unit her, also wir verwenden ja Arch-Unit, und wir haben zum Beispiel Arch-Unit-Rule gehabt, die halt geschaut hat, dass bei neuen Packungen Methoden, ja genau, und das hat dann getuscht auf einmal, und dann bin ich draufgekommen, das steht sogar bei einer, und darum erwähne ich es jetzt, weil vielleicht läuft irgendwer anderer da auch noch eine, das steht quasi sogar drinnen bei einer da irgendwo in der Doku das quasi mit JDK 21 halt dazu führen kann, dass unter bestimmten Umständen, diese Annotation dann nicht zu Runtime ausgelesen werden kann oder nicht verfügbar ist, und ich glaube dass wir da genau da eingelaufen sind bei dem Archunit, weil da war es dann tatsächlich so dass der Code, der bis jetzt gut funktioniert hat und halt einfach geschaut hat, ob bei den Parameter quasi normal verwendet wird.

Der ist so drüber gelaufen und der hat aber keine Notation mehr gesehen.

Okay.

Genau.

Da steht jetzt drin, das wird quasi, ich habe JDK 22 gefixt.

Genau.

Ja.

Müsst ihr jetzt eh bald einmal rauszukriegen, ist JDK 22, oder?

Ja, 24 ist auch schon herrosten.

Ist auch schon herrosten.

Genau, aber ich glaube, wir warten halt auf JDK 25, weil ich glaube, das ist dann die nächste LTS-Version.

Ja, irgendwie.

Warte mal.

Wir haben auf jeden Fall bei 21, bei 21 hat die letzte LTS.

Ja, ja, genau.

Achso, 25 ist die nächste Longtime-Support, ja, die kommt im September.

Ja, stimmt.

Ja, genau.

Weil da reden sie ja wieder von, glaube ich, bei Spring und so, dass da quasi bald einmal Support liefern, und so fürs 25, genau, ja.

Genau.

Und das Krasse ist ja, ich habe ja dann gedacht, was sind das eigentlich dann für Annotations, weißt du?

Weil im Grunde, da kannst du ja eben zum Beispiel so generische Typen annotieren oder was er dann im Video und was man glaube eh folgst mal im Podcast an der Greta, mit diesem komischen Syntax da.

Oder du kannst zum Beispiel beim Array was der davor hinschreiben, non null.

Ja.

Also viel wilde Ding.

Was ist denn das eigentlich?

Und dabei gibt es das glaube ich schon relativ lang.

Das sind diese, es gibt diese bei den Annotations, wie heißt das, diese Target oder irgendwie so.

Definieren kannst du was sagst auf dem type und da gibt es aber auch als als kategorie use underscore type und das sind so use underscore type annotations ja die sind glaube ich eigentlich eher gedacht für so nur statische kodeanalyse also für nur für so tools die hat dann drüber laufen davor, Genau, und die haben das aber so annotiert, dass quasi Use-Type ist, aber mit Runtime-Retention.

Okay.

Und ich glaube, dass diese Kombination wahrscheinlich, glaube ich, keiner irgendwie verwendet hat oder so.

Und sie haben das jetzt genutzt gemacht da.

Ja, genau.

Ja, genau.

Ja, wollte nur sagen, es ist, muss man ein bisschen aufpassen, wenn man da Code hat, der dann auch tatsächlich davor irgendwelche Non-Null, Null-Label-Enotations ausgelesen hat zur Laufzeit.

In der Anwendung oder in die Tools oder so.

Also es kann sein, dass das quasi jetzt nochmal bricht.

Waren wir auch jetzt mit JDK 21 da arbeiten.

Grundsätzlich liegt das noch auf der Roadmap, dass wir mit dem J-Specify und so weiter in Richtung, wenn wir das mal geredet haben, war Spring 7.

Ja, genau.

Dass wir da auch was bei uns im Code machen.

Das war schon cool.

Dass du so eine Durchgängigkeit hättest von den Nullchecks.

Da kannst du dann auch diesen Compiler-Fehler auch machen, wenn du was quasi Ja.

Genau, das habe ich jetzt nicht einbaut.

Das habe ich auch noch nicht ganz checkt.

Da gibt es quasi von Erna irgendwie.

Ja, aber da müsste ja dann alles quasi, darf ja keiner mehr irgendwie eine potenzielle Nullpoint Exception verursachen oder sowas.

Ja, ich weiß ja nicht, ob das, also, ja, ich weiß ja nicht, ob man das will, irgendwie, also, ob das in einer großen Applikation überhaupt irgendwann möglich ist.

Ja.

Weil du müsstest ja quasi alle, alle, oder, müsstest ja dann G-Specify verwenden.

Also reicht dann auch nicht nur Spring.

Spring machen sie auch jetzt dann sozusagen und Spring Boot und so.

Und Spring Security und allmöglich.

Aber zumindest in deiner Anwendung gibt es ja auch viel Stellen, wo du eigene Services und da hast und was ich aufrüsten.

Ja, da auf jeden Fall.

Wo du auch den Fehler immer noch machst und das wäre schon, sag ich mal, möglich, dass du in deiner Anwendung zum Beispiel das zumindest durchzieht.

Ja, voll.

Obwohl wir eigentlich auch, das habe ich auch da erst, haben wir da jetzt auch erst überlegt, wie man da diese G-Specify-Spec durchgelesen hat.

Wir müssen dann glaube ich auch viel stärker gleich auf diese Package-weite-Veinstellung dann gehen.

Genau.

Das hat auch ein Kollege, der Marvin, auch bei uns schon mal vorgeschlagen, zum Migrieren, dass man das da hinkommt quasi in die Richtung.

Du musst viel stärker mit diesem Package-Ding heran, wo man schon arbeiten.

Genau, also quasi so ein Opt-out-Rotten, dass man sagt, okay, Opt-in, also es ist US-non-null, aber wenn du halt irgendein Tunnel zurücklieferst, dann musst du es halt auch notieren.

Genau, zum Beispiel so.

Irgendwie so.

Naja, voll.

Und bei uns ist es halt wirklich jetzt, was da jede, keine Ahnung, so Public-Methode oder so, ist halt wirklich dezidiert alles non-null oder null-level.

Was extra notiert hat.

Was extra, ja, was natürlich dann auch.

Aber mir taugt es trotzdem, weißt du, quasi IntelliJ einfach, wir reichen eigentlich schon die Hints dem IntelliJ.

Das ist eigentlich schon für mich viel wert, dass du siehst, was der Entwickler eigentlich vorgehabt hat jetzt damit und nicht da in Cota ausschauen musst, 37 Stufen nach unten, ob das jetzt ein Allsäcker oder nicht.

Aber das muss ich jetzt nochmal kurz sagen, du wirst quasi, du generierst da aus einer Java-Anwendung ein TypeScript-File raus für das Frontend.

Oder?

Ja, wir verwenden da eine Library, da kannst du quasi beliebige Spring Beans einfach als Endpoint annotieren.

Wie heißt die?

Hilla heißt das.

Das ist aber von Wadi, weil bei uns die alten ablegt.

Genau, und das ist aber ein React-Framework des Hiller.

Und einer von anderen Schmess quasi in dem Hiller ist halt, dass du ganz normales Service...

Fullstack React-Framework for Spring, okay.

Da kannst du quasi ganz normale Beans definieren oder das Endpunkt annotieren.

Und die haben halt ganz normale Methoden, wo dann zum Beispiel eben DTOs oder irgendwas zurückkommen.

Genau.

Und C gängig dann her quasi über Gradle-Task etc.

Die zu bestimmten Zeiten laufen und generieren da dann für diese Endpoint-Schnittstellen, also für die Methoden, einfach so TypeScript-Stubs und dann musst du auf der TypeScript-Seite, wenn du jetzt zum Beispiel einen Endpoint hast, der heißt irgendwie, was weiß ich, Worktime-Endpoint, dann kriegst du auf der Frontend-Seite eine TypeScript-Klasse, die heißt da, Worktime-Endpoint und dann kannst du einfach mit Worktime-Endpoint.

Wie quasi, also ob es der Java-Objekt in der Hand hält, einfach die Methoden aufrufen vom Endpunkt.

Und das ganze Marshaling und so, das ist halt jetzt transparent, dass er da im Hintergrund tatsächlich dann ja trotzdem über HTTP sozusagen ja eigentlich ein Rest service aufruft, das ist da versteckt sozusagen.

Mehr oder weniger versteckt, weil wir eh schon draufgekommen sind.

Ja, musst du dann beim Mapping von den DTOs und so, musst du dann auch viel mit Null-Level und Null-Null und so umeinander wirken, damit du dann im TypeScript nicht das Problem hast, dass du da irgendwie ständig Datentypen drin hast, die halt undefined sein können.

Und dann hast du halt auf der TypeScript-Seite das Problem, dass da der Compiler halt dann dauernd schreit und sagt, das könnte undefined sein, bla bla bla.

Ja, mal schauen, wir müssen ja noch schauen, ob wir das überhaupt nehmen, weil, weißt du, viel Magic, ist vielleicht am Anfang einmal ganz lässig, aber wenn du dann in die Richtung gehst, dass es ein bisschen fortschrittlicher wird, das Ganze, und wenn du dann vielleicht einmal einen eigenen HTTP-Client eine da magst, weil du bestehende gewisse Sachen nicht hast, etc., und dann geht man immer schrittweise mehr Weg davon, aber jetzt haben wir mal diese Verwendung, schauen wir mal.

Wir haben nämlich eine ähnliche Idee, quasi gerade im Moment so, weil man eben diesen Bruch hat, hat zwischen diesem Frontend-Code, der mit irgendwie einem Controller im Backend bei uns zusammenarbeiten muss und da hast du auch im Prinzip keine Typisierung wir haben zwar sehr viel ES-Lint-Ding und was ich für Frontend schon, aber, die Objekte, die du halt da über die Endpoints übergeben kriegst, über die ganzen APIs die sind irgendwie halt nicht, gescheit typisiert und die Idee war jetzt auch da, es gibt ja, das schaut jetzt gerade ein Kollege, auch was vom Spring oder wo, wo du quasi aus den ganzen Endpoints dann so ein OpenAPI-Spec generieren kannst.

Das heißt, es generiert aus den Controller aus ein OpenAPI-Spec und dann könnte man ja, also erstens ist es ja nicht schlecht, dass man so ein OpenAPI-Spec hätte für, jetzt bei uns ist es ja so, jetzt greifen wir die Mobile-Developer mit den Android- und iOS-Clients auf diese Endpoints zu.

Da gibt es keine eigene REST API oder was die, was wir jetzt neu gemacht haben mit OpenAI schon von vorher, wo quasi der Code aus dem OpenAI Jammel generiert wird da wäre es dann umgekehrt, aber wenn du sowas hättest, könntest du dann aus dem OpenAI-Spec wieder eben TypeScript-Zeit generieren für das Frontend, und hättest dann da quasi auch die Typisierung dann drinnen und so dass du weißt, okay, das ist nicht das hat den und den Typ was auch cool war.

Ja, das ist dann mit Zweig oder mit Irr-Pause, oder?

Genau.

Im Grunde dann, ja.

Ja, stimmt.

Und da hast du nämlich dann, glaube ich, noch viel mehr Möglichkeiten, eben auf der Java-Seite, wie es halt dann die Generierung quasi dann noch beeinflusst wahrscheinlich.

Ja.

Mit Annotationen und so weiter.

Du kannst auch customisieren, dass du das halt dann noch speziell haben müsstest.

Da schauen wir jetzt gerade ein bisschen an, dass wir das quasi ein bisschen enger aneinander binden, diese Frontend-Development-Sachen, an diese Controller-Backend-Endpoints.

Ja, okay, spannend, ja.

Gut.

Ah ja, ein Thema habe ich dann auch noch etwas dazu, aber das ist mir gerade jetzt während wir da geredet haben, aufgefallen, habe ich jetzt auch ein bisschen experimentiert, nämlich den Dependency-Check.

Es ist so, wir haben wieder mal so eine größere Session gehabt mit einer Bankenaufsicht oder einer Bank, also Kunden von DIMA quasi, eine Bank ist eine Kunde von DIMA und die hat halt irgendwie Muttergesellschaft oder so.

Die brauchen halt immer ganz viel spezielle Security-Fragebürgen beantwortet und so weiter.

Und da gibt es immer NIS und DORA und alle diese ganzen EU-weiten Richtlinien, was es da mittlerweile gibt und so.

Und da musst du halt alle Sachen erfüllen.

Und wenn du solche Fragebögen durchschaust und mit dir einer besprichst, da geht es dann oft auch um das ganze Bill of Materials.

Also, dass du quasi deinem Kunden gegenüber, wie der Bank hat zum Beispiel, auch sagen kannst, was ist meine Bill of Materials, aus welchen Komponenten besteht meine Systemsoftware, meine Software.

Das kommt ja glaube ich auch zu einer Cybersecurity Richtlinie raus, dass das quasi anbieten oder dass das providen können muss, quasi sozusagen.

Genau, also muss nicht, aber sie dann sind halt viel leichter, wenn du ihnen sowas zur Verfügung stellen kannst, so quasi und sie können auf dem Ding dann beurteilen, wie du aufgestellt bist, halt sozusagen sicherheitstechnisch.

Und dann geht es auch natürlich immer darum, naja, was die die Fragen dann so Sachen haben, wie geht es hier halt mit Patch-Management um, was der fixt hier quasi Schwachstellen im System regelmäßig und so weiter.

Da sind wir jetzt sehr mit Manned Renovate und so weiter ganz gut dabei, weil das ist halt immer so getrieben aus halt einfach Update-Sicht, aber es kommt halt ein Update von der Bibliothek und dann updaten wir halt.

Aber was natürlich das andere Ding ist, weißt du Bescheid über potenziell bestehende Vulnerability, in deinem code ja also warst du quasi von deiner bilder material von alle deine komponenten von den dependencies die du verwendest haben da irgendwelche irgendwo bekannte sicherheitslücke.

Und da kommt jetzt dieses, ich habe dann einmal, nachdem wir dieses lange Gespräch und diesen Fragebogen gehabt haben und so weiter, auch mit in dem Fall JGPD, O3 halt ein bisschen recherchiert und so, was man da machen kann, was es da so gibt.

Und da ist immer wieder der Dependency-Check von OWASP halt gefallen.

Und da gibt es ein Gradle-Plugin und ein Maven-Plugin für das.

Und das habe ich dann am Freitag einmal ein bisschen ausgeführt auch.

Und dann auch, das war auch schon geil zum Segen einmal, den Vergleich, wir haben ja quasi im Herbst das große Spring-Update gemacht endlich, von 2.7 weg auf moderne 3.0x und so und dann habe ich das einmal in diesen Dependency-Check ausgeführt lassen auf die alte Version, die wir halt noch im Herbst gehabt haben, und jetzt auf die neue und da sieht man dann auch, wie tut den halt auch den Benefit, was das halt einfach bringt, wenn man bei den Frameworks und Libraries und so weiter aktuell ist, weil halt einfach die Menge der Vulnerabilities, die halt da vorher drinnen waren und jetzt drinnen sind, um heißer halt anders ist.

Und das ist schon ganz geil, also der spuckt halt aus, der checkt halt, listet deine ganzen Gradle-Files und das Zeugelt durch halt und deine Dependencies und fragt dann die diversen Seiten halt ab, ob es zu diesem, was du da verwendest, irgendwo halt bekannte Vulnerabilities gibt und listet dann diesen so ein Vulnerability-Report HTML halt auf.

Ja, finde ich ganz cool, das werde ich jetzt auch irgendwo ein bisschen integrieren bei uns, dass man das ab und zu mal macht, weil was heißt ab und zu, bei jedem Bild mitlaufen lassen würde ich das jetzt nicht machen, weil beim Timer läuft es irgendwie 20 Minuten oder so.

Das dauert ein bisschen.

Das dauert, weil der das quasi wirklich für jede Dependency dann diese ganzen Dinge durchabfragt mit Web-Requests und so.

Aber es ist eine coole Sache, finde ich, weil du einfach ein bisschen das kannst quasi du hast das Schwarz aus diesem nicht automatisiert irgendwie selber machst, dass du das ganze Ding abgerast.

Aber so spielt dir da wirklich einen sehr ausführlichen Bericht halt einfach da zusammen.

Genau.

Also ich mache das immer so, ich habe einen monatlichen Termin, der heißt Check Vulnerabilities.

Okay.

Und dann mache ich das IntelliJ auf und dann gehe ich unter Code, Analyze Code und Show Vulnerable Dependencies.

Okay.

Genau, und ich schaue mir das immer in Metallica bis jetzt.

Ah, okay, warte mal, das probiert es gleich mal live aus.

Da gibt es Code, wo ist das drin?

Analyze Code.

Analyze Code, und da hat man es unten, Show Vulnerable Dependencies.

Ah ja.

Und der liest du dann quasi für alle diese Dependencies.

Select Dependencies on the left to view detail.

Okay, nothing to show.

Warum sehe ich?

Okay, jetzt muss ich mir mal schauen.

Also da importiert das, okay.

Genau, also der macht auch so ein Vulnerability-Check.

Du hast dabei Results Powered by Manned.io recht?

Ja, ich weiß nicht, bei mir steht Checkmarks, was auch immer das ist.

Okay, weil das ist nämlich das Nächste, es gibt natürlich kostenpflichtige Dinge auch, so für das Gescheitze.

Das Manned.io, wo man jetzt das Renovate schon quasi als freie Variante verwenden derzeit, ja, hätte ja in seiner Plattform-Version genau das auch drinnen, ja.

Also das macht ja genau so eine Überwachung auch von den Open Security Risks und so weiter.

Ja.

Du hast ja so eine Oberfläche in einer Web-UI alles schön aufbereitet drinnen, was für eine, wundert mich eigentlich, gut, das Sona, was wir verwenden, macht halt eher halt einfach Richtung statische Code-Analyse und Code-Thematiken halt, das geht nicht so in die Richtung, aber im Prinzip könnte die, ja, könnten die das genauso dazu machen eigentlich auch, ja.

Dass du jetzt so, nicht nur den, weil die werden ja auch im Code wohl nur Abilities usw.

finden.

Aber eigentlich konnten die ja die Dependencies auch anschauen und dann das dann noch zu.

Wenn ich denen dann noch 27 verschiedene Tools für alles brauche.

Jetzt habe ich schon das Manned Renovate.

Im Einsatz kommt es sein, dass ich dann auch sage, okay, ich gehe doch, ich schlucke das und gehe dann auf die kostenpflichtige Manned-Plattform einfach und habe das dann dort halt wenigstens alles in einen.

Ja, naja, voll.

Aber das IntelliJ kann da auch relativ viel, also wenn man sich das nochmal anschauen kann.

Aber das ist halt immer das Ding, okay, dann muss man sich halt den Termin regelmäßig eintragen und auf Kuhn halt einfach, ja.

Ja, voll, voll.

Ich meine, ja, keine Ahnung, ja, sicher.

Die Security Vulnerabilities, die kommen halt dann irgendwann daher, gell.

War das da so, du hast ja jetzt vor ein paar Wochen wieder einmal hingewiesen auf die Tomcat Vulnerability.

Ja, nein, die habe ich über Heise gesehen.

Bei den Großen kriegt man es dann eh über Heise mit mir ist nämlich auch so gegangen, ja.

Ja.

Ich meine, es ist halt dann auch, ich schaue jetzt da gerade ein bisschen durch, so ja.

Ich meine, ein paar Sachen hat man halt, die poppen da immer wieder mal auf, ja, da weiß ich aber ungefähr wieso und so.

Oder das ist, ja.

Ja.

Schwierig.

Schwierig, schwierig, teilweise.

Ja, also wollte ich nochmal anmerken, das ist mir untergelaufen, das Pool.

Habe ich dann ein bisschen ausgeführt für diverse Projekte, was wir so haben.

Ist schon ganz cool zum sehen.

Und dann ist es ja auch so witzig, dann teilweise findet ihr dann halt irgendwie, ich will noch ein Bild ist bei mir jetzt im Timer noch drinnen, weil irgendwie, keine Ahnung, Jasper Reports irgendeine Commons I.O.

Einbindet, das ist der von Version 8, 1.8, und da gab es aber schon 1.11, die das fixt.

Und da kann wir ja dann auch im Gradle extra die Dependencies quasi forcen, dass die halt von herrigen Versionen verwendet werden und so.

Voll.

Ja, und ja, dann wenn man da ein bisschen was tut, zwei, drei Zeilen im Gradle wieder, dann schließt man gleich wieder ein paar so Glücke.

Ich meine, ist immer die Frage, wie relevant ist der Angriffsvektor, aber ja, ist trotzdem nicht schlecht, wenn man da ein bisschen Tool hat, was man da einfach so Sachen braucht.

In der globalen Build-Gradle da hat er Commons Compress, gibt es zum Beispiel was, da haben wir glaube ich eine üdere, hätten wir eigentlich eine üdere Version standardmäßig, das fassen wir da auf, was neicheres und so.

Ja, ja.

Musst halt immer nur rufen, ja, dass halt dann alles geht, das ist halt dann, potenziell dann geil von dem einen ins andere dann tappen.

Nein, aber ich meine jetzt so was, zu meiner Version-Update, das geht meistens bei den, zum Beispiel gerade bei den Apache-Libels und so, das macht halt nicht ein Problem.

Die sind da ganz gut, was die Sonnebelung.

Voll.

Ja, cool, der Dependency-Check.

Irgendwo, ich weiß nicht mehr genau, irgendwo das auch schon mal verwendet, das Plugin, aber ich kann mich nur erinnern, dass wir es dann auch nicht in die Pipeline reinigt haben, oder wir haben es in die Pipeline reinigt und dann wieder aussieht da oder was, weil es wirklich langläuft.

Genau.

Ich kann mir das vorstellen, dass ich das so rein tue als Special Task und dann halt einfach so irgendwie Schedule halt.

Dass das auch mal läuft.

Einmal im Monat.

Oder so.

Ja, voll.

Na gut.

Ja.

Jetzt sind wir eh schon hübsch durch.

Gehen wir eh schon in End-Sprint, gell?

Ja, gehen wir.

Du hast gerade was auf die Liste dazugeschrieben, gell?

Ja?

Kennst du dich da aus?

Nein.

Ich versuche mich gerade irgendwie.

Das ist nicht seltsam.

Das ist, Foundation ist die neue Staffel hier draußen.

Ach so, Foundation.

Von Apple TV?

Hast du das nicht geschaut?

Nein, angefangen haben wir.

Aber wir sind noch nicht so weit.

Genau, wir haben da glaube ich in Season 1 Episode 5 sind wir da erst.

Besteppert.

Okay.

Ja, ja, genau.

Ja, reden wir.

Wir haben nämlich zwischendurch jetzt, was haben wir gerade geschaut?

Ah ja, der Bear ist wieder eine neue Staffel gekommen, ganz überraschend.

Ach so, ja, das war das mit dem Koch.

Genau, ja.

Die haben jetzt eine vierte Staffel gebracht und das haben uns gerade noch zwischendurch reingezwickt wieder.

Okay, okay.

Genau, Ender schaue ich gerade selber halt.

Ja, das ist schon mega cool.

Das hat man auch extrem gut schauen.

Aber Foundation sind wir noch dabei.

Nein, du musst unbedingt, also bei Foundation, ich weiß, der Anfang ist gescheit zack, bei Foundation das weiß ich nur, aber man muss einmal da drüber und ich glaube, dass so Ende der ersten Anfang der zweiten Staffel, da wird es geht dann.

Wie viel Haupt gibt es denn da schon, warte mal, Go to Show Ja.

Das ist glaube ich die vierte oder?

Es hat drei Staffeln bis jetzt gegeben Ja.

Also, nein, ich sehe da nur Season 3.

Achso, ist bei der Season 3 nur eine Folge heraus?

Nein.

Warte mal.

Aber ich kann da nur Season 1 bis 3 auswählen.

Das ist komisch.

Warte mal, Episode 1?

Ah, doch, doch, doch.

Das ist dann Season 3, ja.

Ah, okay.

Gibt es zwei Episoden.

Eine kommt am Freitag jetzt sozusagen, ja.

Ja, genau.

Ah, No Nester Mule, die steht ja schon im Untertitel.

Ja, okay.

Ja, okay.

Ja, aber das bringt es noch nicht viel, weil da ist du vorher nur die zweite.

Ja, okay.

Ich werde jetzt sagen, Daniel, wir müssen da wieder weiterschauen, weil, ja.

Ja, genau.

Mörderpot ist eigentlich auch ganz cool.

Da bin ich jetzt aber einmal stehen geblieben irgendwo.

Muss ich mir jetzt einmal fertig nachschauen.

Nein, das habe ich noch gar nicht gekauft.

Ein Mörderpot.

Genau.

Ist halt, ja, nichts für kleinere Kinder, glaube ich, so.

Muss man ein wenig.

Ist teilweise potenziell ein bisschen blutig.

Hey, Stick ist jetzt auch schon heraus.

Ja, ja, das haben wir auch geschaut, aber bin ich irgendwie auch nicht.

Das soll ja so, da habe ich nur einen Trailer mal gesehen, das soll ja so ein bisschen Ding-mäßig sein, haben sie geschrieben.

Fuck, wie heißt der denn?

Der Fußballtrainer von Apple TV.

Wollt ihr bei das wieder nicht rein?

Achso, wie der...

Ah, ich weiß schon, was du meinst.

Wie ist das?

Ich weiß, aber das fällt auch nicht rein.

von dem englischen Fußballverein.

Verdammt!

Das ist jetzt nicht einfach.

Apple TV Football Show.

Der Ted Lasso.

Kurz bevor es im Google auftacht ist.

Apropos Fußball.

Jetzt werde ich noch Fußball anschauen.

Ist wie bildet denn schon aus?

jetzt sind.

Ah, krass.

Ja, der Sinner hat gewonnen.

Okay.

Also, Revanche geglückt.

Ja, weil bei...

4-6-6-4-6-4 French Open haben, hat noch der Alcaraz gewonnen.

Ja, genau.

Aber ich glaube, heute waren es ein wenig schneller.

Ja, ja.

Aber das war eine...

Ja, die haben ja 5 Stunden 40 oder 5 Stunden 39.

French Open hat wirklich eingeschaltet, in den dritten So-O-So, ja.

Und dann war eben das...

Dann hat der Cine irgendwann drei Matchspiele gehabt.

Ja, genau.

Die hat er dann nicht verwertet und ab dem Zeitpunkt hat er es allgelegt.

So krass.

Hätte ich mir nicht gedacht.

Der hat schon quasi zwei Sets gewonnen gehabt und im dritten war er schon mit drei Matchbällen da und dann verliert er das noch.

Das war so arg.

Das habe ich mir dann alles noch angeschaut.

Das ist einfach so arg.

Das hätte unglaublich sein.

Da gibt es auch, wenn man Alkara sieht, habe ich mir neulich einmal eine Doku angeschaut auf Netflix.

Das ist eigentlich voll ein sympathischer Typ.

Der halt auch einfach nur daheim man muss ja so im Kinderzimmer wohnen und so.

Okay.

Krass, alle die Grenzlein-Vokale da stehen und so.

Ja, ja.

Aber viel am Boden geblieben.

Eigentlich, die ist ja erst 22 oder so, gell.

Ja, so jung, gell.

Das ist so wild.

Auch schon alles gewonnen eigentlich.

Und jetzt sind kassiert 3,47 Millionen Euro, gell, der Sinner für die Sienner.

Der Sinner dann, ja.

Da geht schon ein Bege bei den Turnieren, gell.

Hast du ja gesehen, gell.

Ich glaube, im Halbfinale hat er der Sinner, da habe ich mir nur die Kurzzusammenfassung angeschaut, gegen einen Djokovic hat gespielt.

Ja, da merkst du nicht viel, dass so eine Ablöse schon stattgefunden hat, weil der hat halt kein Level gehabt, der Djokovic.

Ist ja krass.

Ist halt auch einer der besten Tennis-Spieler, die es jemals gegeben hat.

Aber der hat auch kein Level gehabt.

Naja, genau.

Und jetzt ein Club-WM-Finale.

Das ist ja ganz ein komisches Format gewesen, was jetzt zum ersten Mal wir haben.

Die Ticketverkäufe sind eh scheißig laufen und so.

Wo es halt quasi wirklich weltweite, verschiedene Klubs, also wie Bayern und Dortmund und so weiter halt jetzt gegeneinander gespielt haben.

Da war halt auch Inter-Mailand mit dem, ja, nicht Mailand, der Miami.

Das ist der Nassige, okay.

Krass, da muss ich auch ein bisschen schauen, auf Satans wann das stimmt.

Okay, spielen sie es auch, ja.

Genau, heute Paris Saint-Germain gegen Chelsea um 9 Uhr.

Ja cool, dann müssen wir auf zum Ampfiff.

Genau.

Das war's dann.

Bis zum nächsten Mal.

Bis dann.

Ciao.

Ciao.